bugfixes

ast/src/constrain.rs

@@ -273,7 +273,7 @@ pub fn constrain_expr<'a>(
         Expr2::Call {
             args,
             expr_var,
-            expr: expr_node_id,
+            expr_id: expr_node_id,
             closure_var,
             fn_var,
             ..

ast/src/lang/core/expr/expr2.rs

@@ -95,7 +95,7 @@ pub enum Expr2 {
     },
     Call {
         args: PoolVec<(Variable, ExprId)>, // 8B
-        expr: ExprId,                      // 4B
+        expr_id: ExprId,                      // 4B
         expr_var: Variable,                // 4B
         fn_var: Variable,                  // 4B
         closure_var: Variable,             // 4B

ast/src/lang/core/expr/expr2_to_string.rs

@@ -128,6 +128,22 @@ fn expr2_to_string_helper(
                 pool.get(*body_id)
             ));
         }
+        Expr2::Call {
+            ..
+        } => {
+            out_string.push_str(&format!(
+                "Call({:?})",
+                expr2,
+            ));
+        }
+        Expr2::Closure {
+            ..
+        } => {
+            out_string.push_str(&format!(
+                "Closure({:?})",
+                expr2,
+            ));
+        }
         other => todo!("Implement for {:?}", other),
     }
 

ast/src/lang/core/expr/expr_to_expr2.rs

@@ -531,7 +531,7 @@ pub fn to_expr2<'a>(
                     let fn_expr_id = env.add(fn_expr, fn_region);
                     Expr2::Call {
                         args,
-                        expr: fn_expr_id,
+                        expr_id: fn_expr_id,
                         expr_var: env.var_store.fresh(),
                         fn_var: env.var_store.fresh(),
                         closure_var: env.var_store.fresh(),
@@ -569,7 +569,7 @@ pub fn to_expr2<'a>(
                     let fn_expr_id = env.add(fn_expr, fn_region);
                     Expr2::Call {
                         args,
-                        expr: fn_expr_id,
+                        expr_id: fn_expr_id,
                         expr_var: env.var_store.fresh(),
                         fn_var: env.var_store.fresh(),
                         closure_var: env.var_store.fresh(),
@@ -659,7 +659,7 @@ pub fn to_expr2<'a>(
             //            (RuntimeError(problem), Output::default())
             todo!()
         }
-        Var { module_name, ident } => canonicalize_lookup(env, scope, module_name, ident, region),
+        Var { module_name, ident } => canonicalize_lookup(env, scope, "#UserApp", ident, region), // TODO use module_name instead
 
         // Below this point, we shouln't see any of these nodes anymore because
         // operator desugaring should have removed them!

ast/src/lang/core/str.rs

@@ -157,7 +157,7 @@ fn desugar_str_segments(env: &mut Env, segments: Vec<StrSegment>) -> Expr2 {
 
         let new_call = Expr2::Call {
             args,
-            expr: concat_expr_id,
+            expr_id: concat_expr_id,
             expr_var: var_store.fresh(),
             fn_var: var_store.fresh(),
             closure_var: var_store.fresh(),

code_markup/src/markup/common_nodes.rs

@@ -16,9 +16,13 @@ pub fn new_equals_mn(ast_node_id: ASTNodeId, parent_id_opt: Option<MarkNodeId>)
 }
 
 pub fn new_comma_mn(expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode {
+    new_comma_mn_ast(ASTNodeId::AExprId(expr_id), parent_id_opt)
+}
+
+pub fn new_comma_mn_ast(ast_node_id: ASTNodeId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode {
     MarkupNode::Text {
         content: nodes::COMMA.to_owned(),
-        ast_node_id: ASTNodeId::AExprId(expr_id),
+        ast_node_id,
         syn_high_style: HighlightStyle::Blank,
         attributes: Attributes::default(),
         parent_id_opt,

code_markup/src/markup/convert/from_expr2.rs

@@ -1,16 +1,8 @@
-use crate::{
-    markup::{
-        attribute::Attributes,
-        common_nodes::{
+use crate::{markup::{attribute::Attributes, common_nodes::{
             new_arg_name_mn, new_arrow_mn, new_blank_mn, new_colon_mn, new_comma_mn, new_equals_mn,
             new_left_accolade_mn, new_left_square_mn, new_operator_mn, new_right_accolade_mn,
             new_right_square_mn,
-        },
-        nodes::{get_string, new_markup_node, MarkupNode},
-    },
-    slow_pool::{MarkNodeId, SlowPool},
-    syntax_highlight::HighlightStyle,
-};
+        }, nodes::{MarkupNode, get_string, join_mark_nodes_commas, join_mark_nodes_spaces, new_markup_node}}, slow_pool::{MarkNodeId, SlowPool}, syntax_highlight::HighlightStyle};
 
 use bumpalo::Bump;
 use itertools::Itertools;
@@ -79,9 +71,9 @@ pub fn expr2_to_markup<'a, 'b>(
             mark_node_pool,
             indent_level,
         ),
-        Expr2::Call { expr: expr_id, .. } => {
+        Expr2::Call { args, expr_id, .. } => {
             let expr = env.pool.get(*expr_id);
-            expr2_to_markup(
+            let fun_call_mark_id = expr2_to_markup(
                 arena,
                 env,
                 expr,
@@ -89,7 +81,41 @@ pub fn expr2_to_markup<'a, 'b>(
                 mark_node_pool,
                 interns,
                 indent_level,
-            )?
+            )?;
+
+            let arg_expr_ids: Vec<ExprId> =  args.iter(env.pool).map(|(_, arg_id)| *arg_id).collect();
+
+            let arg_call_mark_ids: Vec<MarkNodeId> =
+                arg_expr_ids.iter().map(
+                    |arg_id|
+                    {
+                        let arg_expr = env.pool.get(*arg_id);
+
+                        expr2_to_markup(
+                            arena,
+                            env,
+                            arg_expr,
+                            *arg_id,
+                            mark_node_pool,
+                            interns,
+                            0,
+                        )
+                    }
+                ).collect::<ASTResult<Vec<MarkNodeId>>>()?;
+
+            let mut args_with_sapces = join_mark_nodes_spaces(arg_call_mark_ids, true, ast_node_id, mark_node_pool);
+
+            let mut children_ids = vec![fun_call_mark_id];
+            children_ids.append(&mut args_with_sapces);
+
+            let call_node = MarkupNode::Nested {
+                ast_node_id,
+                children_ids,
+                parent_id_opt: None,
+                newlines_at_end: 0,
+            };
+
+            mark_node_pool.add(call_node)
         }
         Expr2::Var(symbol) => {
             let text = env.get_name_for_ident_id(symbol.ident_id())?;
@@ -310,11 +336,9 @@ pub fn expr2_to_markup<'a, 'b>(
                 .map(|ident| ident.as_inline_str().as_str());
 
             let arg_mark_nodes =
-                arg_names.map(|arg_name| new_arg_name_mn(arg_name.to_string(), expr2_node_id));
+                arg_names.map(|arg_name| new_arg_name_mn(arg_name.to_string(), expr2_node_id)).collect_vec();
 
-            let commas = (0..(arg_mark_nodes.len() - 1)).map(|_| new_comma_mn(expr2_node_id, None));
-
-            let args_with_commas: Vec<MarkupNode> = arg_mark_nodes.interleave(commas).collect_vec();
+            let args_with_commas: Vec<MarkupNode> = join_mark_nodes_commas(arg_mark_nodes, ASTNodeId::AExprId(expr2_node_id));
 
             let mut args_with_commas_ids: Vec<MarkNodeId> = args_with_commas
                 .into_iter()

code_markup/src/markup/nodes.rs

@@ -4,15 +4,13 @@ use crate::{
     syntax_highlight::HighlightStyle,
 };
 
-use super::attribute::Attributes;
+use super::{attribute::Attributes, common_nodes::new_comma_mn_ast};
 
 use crate::markup_error::{ExpectedTextNode, NestedNodeMissingChild, NestedNodeRequired};
-use roc_ast::{
-    lang::{core::ast::ASTNodeId, env::Env},
-    mem_pool::pool_str::PoolStr,
-};
+use roc_ast::{lang::{core::ast::ASTNodeId, env::Env}, mem_pool::{pool_str::PoolStr}};
 use roc_utils::{index_of, slice_get};
 use std::fmt;
+use itertools::Itertools;
 
 #[derive(Debug)]
 pub enum MarkupNode {
@@ -422,3 +420,46 @@ pub fn get_root_mark_node_id(mark_node_id: MarkNodeId, mark_node_pool: &SlowPool
 
     curr_mark_node_id
 }
+
+pub fn join_mark_nodes_spaces(mark_nodes_ids: Vec<MarkNodeId>, with_prepend: bool, ast_node_id: ASTNodeId, mark_node_pool: &mut SlowPool) -> Vec<MarkNodeId> {
+    let space_range_max  =
+        if with_prepend {
+            mark_nodes_ids.len()
+        } else {
+            mark_nodes_ids.len() - 1
+        };
+
+    let join_nodes: Vec<MarkNodeId> =
+        (0..space_range_max)
+        .map(|_| {
+            let space_node = MarkupNode::Text {
+                content: " ".to_string(),
+                ast_node_id,
+                syn_high_style: HighlightStyle::Blank,
+                attributes: Attributes::default(),
+                parent_id_opt: None,
+                newlines_at_end: 0,
+            };
+
+            mark_node_pool.add(space_node)
+        })
+        .collect();
+
+    if with_prepend {
+        join_nodes.into_iter().interleave(mark_nodes_ids).collect()
+    } else {
+        mark_nodes_ids.into_iter().interleave(join_nodes).collect()
+    }
+    
+}
+
+pub fn join_mark_nodes_commas(mark_nodes: Vec<MarkupNode>, ast_node_id: ASTNodeId) -> Vec<MarkupNode> {
+    let join_nodes: Vec<MarkupNode> =
+        (0..(mark_nodes.len() - 1))
+        .map(|_| {
+            new_comma_mn_ast(ast_node_id, None)
+        })
+        .collect();
+
+    mark_nodes.into_iter().interleave(join_nodes).collect()
+}

code_markup/src/syntax_highlight.rs

@@ -27,18 +27,18 @@ pub fn default_highlight_map() -> HashMap<HighlightStyle, RgbaTup> {
 
     let mut highlight_map = HashMap::new();
     [
-        (Operator, from_hsb(225, 50, 100)),
+        (Operator, from_hsb(185, 50, 75)),
         (String, from_hsb(346, 65, 97)),
         (FunctionName, almost_white),
-        (FunctionArgName, almost_white),
+        (FunctionArgName, from_hsb(225, 50, 100)),
         (Type, almost_white),
         (Bracket, from_hsb(347, 80, 100)),
-        (Number, from_hsb(185, 50, 75)),
+        (Number, from_hsb(225, 50, 100)),
         (PackageRelated, almost_white),
         (Value, almost_white),
         (RecordField, from_hsb(258, 50, 90)),
-        (Import, from_hsb(185, 50, 75)),
-        (Provides, from_hsb(185, 50, 75)),
+        (Import, from_hsb(225, 50, 100)),
+        (Provides, from_hsb(225, 50, 100)),
         (Blank, from_hsb(258, 50, 90)),
         // comment from_hsb(285, 6, 47) or 186, 35, 40
     ]

editor/src/editor/code_lines.rs

@@ -22,6 +22,10 @@ impl CodeLines {
     ) -> UIResult<()> {
         let nr_of_lines = self.lines.len();
 
+        if index == 17 { // TODO remove me
+            dbg!("breakpoint here");
+        }
+
         if line_nr < nr_of_lines {
             let line_ref = slice_get_mut(line_nr, &mut self.lines)?;
 

editor/src/editor/mvc/ed_update.rs

@@ -263,6 +263,10 @@ impl<'a> EdModel<'a> {
         mark_node_pool: &SlowPool,
     ) -> UIResult<()> {
         let mark_node = mark_node_pool.get(mark_node_id);
+        dbg!(mark_node.get_content());
+        dbg!(&line_nr);
+        dbg!(&col_nr);
+
         let node_newlines = mark_node.get_newlines_at_end();
 
         if mark_node.is_nested() {
@@ -290,9 +294,8 @@ impl<'a> EdModel<'a> {
                 code_lines,
             )?;
 
-            if node_newlines == 0 {
-                *col_nr += node_content.len();
-            }
+
+            *col_nr += node_content.len();
         }
 
         if node_newlines > 0 {