debugging closure -> MarkupNode

Cargo.lock

@@ -3369,6 +3369,7 @@ name = "roc_code_markup"
 version = "0.1.0"
 dependencies = [
  "bumpalo",
+ "itertools 0.10.1",
  "palette",
  "roc_ast",
  "roc_module",

ast/src/lang/core/def/def_to_def2.rs

@@ -20,11 +20,11 @@ pub fn defs_to_defs2<'a>(
 ) -> Vec<Def2> {
     parsed_defs
         .iter()
-        .map(|loc| to_def2_from_def(arena, env, scope, &loc.value, region))
+        .map(|loc| def_to_def2(arena, env, scope, &loc.value, region))
         .collect()
 }
 
-pub fn to_def2_from_def<'a>(
+pub fn def_to_def2<'a>(
     arena: &'a Bump,
     env: &mut Env<'a>,
     scope: &mut Scope,
@@ -34,8 +34,8 @@ pub fn to_def2_from_def<'a>(
     use roc_parse::ast::Def::*;
 
     match parsed_def {
-        SpaceBefore(inner_def, _) => to_def2_from_def(arena, env, scope, inner_def, region),
+        SpaceBefore(inner_def, _) => def_to_def2(arena, env, scope, inner_def, region),
-        SpaceAfter(inner_def, _) => to_def2_from_def(arena, env, scope, inner_def, region),
+        SpaceAfter(inner_def, _) => def_to_def2(arena, env, scope, inner_def, region),
         Body(&loc_pattern, &loc_expr) => {
             // TODO loc_pattern use identifier
             let expr2 = loc_expr_to_expr2(arena, loc_expr, env, scope, region).0;
@@ -43,6 +43,8 @@ pub fn to_def2_from_def<'a>(
 
             use roc_parse::ast::Pattern::*;
 
+            dbg!(&loc_pattern.value);
+
             match loc_pattern.value {
                 Identifier(_) => {
                     let (_, pattern2) = to_pattern2(

code_markup/Cargo.toml

@@ -14,5 +14,6 @@ serde = { version = "1.0.123", features = ["derive"] }
 palette = "0.5"
 snafu = { version = "0.6", features = ["backtraces"] }
 bumpalo = { version = "3.2", features = ["collections"] }
+itertools = "0.10.1"
 
 [dev-dependencies]

code_markup/src/markup/common_nodes.rs

@@ -51,8 +51,12 @@ pub fn new_blank_mn_w_nls(
 }
 
 pub fn new_colon_mn(expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode {
+    new_operator_mn(nodes::COLON.to_owned(), expr_id, parent_id_opt)
+}
+
+pub fn new_operator_mn(content: String, expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode {
     MarkupNode::Text {
-        content: nodes::COLON.to_owned(),
+        content: content,
         ast_node_id: ASTNodeId::AExprId(expr_id),
         syn_high_style: HighlightStyle::Operator,
         attributes: Attributes::default(),
@@ -104,3 +108,25 @@ pub fn new_right_square_mn(expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -
         newlines_at_end: 0,
     }
 }
+
+pub fn new_func_name_mn(content: String, expr_id: ExprId) -> MarkupNode {
+    MarkupNode::Text {
+        content,
+        ast_node_id: ASTNodeId::AExprId(expr_id),
+        syn_high_style: HighlightStyle::FunctionName,
+        attributes: Attributes::default(),
+        parent_id_opt: None,
+        newlines_at_end: 0,
+    }
+}
+
+pub fn new_arg_name_mn(content: String, expr_id: ExprId) -> MarkupNode {
+    MarkupNode::Text {
+        content,
+        ast_node_id: ASTNodeId::AExprId(expr_id),
+        syn_high_style: HighlightStyle::FunctionArgName,
+        attributes: Attributes::default(),
+        parent_id_opt: None,
+        newlines_at_end: 0,
+    }
+}

code_markup/src/markup/convert/from_expr2.rs

@@ -1,10 +1,8 @@
 
-use crate::{markup::{attribute::Attributes, common_nodes::{
+use crate::{markup::{attribute::Attributes, common_nodes::{new_arg_name_mn, new_blank_mn, new_colon_mn, new_comma_mn, new_equals_mn, new_func_name_mn, new_left_accolade_mn, new_left_square_mn, new_operator_mn, new_right_accolade_mn, new_right_square_mn}, nodes::{MarkupNode, get_string, new_markup_node}}, slow_pool::{MarkNodeId, SlowPool}, syntax_highlight::HighlightStyle};
-        new_blank_mn, new_colon_mn, new_comma_mn, new_equals_mn, new_left_accolade_mn,
-        new_left_square_mn, new_right_accolade_mn, new_right_square_mn,
-    }, nodes::{MarkupNode, get_string, new_markup_node}}, slow_pool::{MarkNodeId, SlowPool}, syntax_highlight::HighlightStyle};
 
 use bumpalo::Bump;
+use itertools::Itertools;
 use roc_ast::{ast_error::ASTResult, lang::{core::{ast::ASTNodeId, expr::{
                 expr2::{Expr2, ExprId},
                 record_field::RecordField,
@@ -20,6 +18,7 @@ pub fn expr2_to_markup<'a, 'b>(
     mark_node_pool: &mut SlowPool,
     interns: &Interns,
 ) -> ASTResult<MarkNodeId> {
+    dbg!(expr2);
     let ast_node_id = ASTNodeId::AExprId(expr2_node_id);
 
     let mark_node_id = match expr2 {
@@ -214,7 +213,7 @@ pub fn expr2_to_markup<'a, 'b>(
             }
         }
         Expr2::Closure{
-            function_type,
+            function_type:_,
             name,
             recursive:_,
             args,
@@ -223,38 +222,63 @@ pub fn expr2_to_markup<'a, 'b>(
         } => {
             let func_name = name.ident_str(interns).as_str();
 
-            let arg_names: Vec<&str> = 
+            let func_name_mn =
-                args.iter(env.pool).map(
+                new_func_name_mn(func_name.to_string(), expr2_node_id);
-                    | (_, arg_node_id) | {
-                        let arg_pattern2 = env.pool.get(*arg_node_id);
 
-                        match arg_pattern2 {
+            let func_name_mn_id = mark_node_pool.add(func_name_mn);
-                            Pattern2::Identifier(id_symbol) => {
+        
-                                id_symbol.ident_str(interns).as_str()
+            let backslash_mn = new_operator_mn("\\".to_string(), expr2_node_id, None);
-                            },
+            let backslash_mn_id = mark_node_pool.add(backslash_mn);
-                            other => {
+
-                                todo!("TODO: support the following pattern2 as function arg: {:?}", other);
+            let arg_names: Vec<&str> = 
-                            }
+            args.iter(env.pool).map(
+                | (_, arg_node_id) | {
+                    let arg_pattern2 = env.pool.get(*arg_node_id);
+
+                    match arg_pattern2 {
+                        Pattern2::Identifier(id_symbol) => {
+                            id_symbol.ident_str(interns).as_str()
+                        },
+                        other => {
+                            todo!("TODO: support the following pattern2 as function arg: {:?}", other);
                         }
                     }
-                )
-                .collect();
-            
-            for (_, arg_node_id) in args.iter(env.pool) {
-                let arg_pattern2 = env.pool.get(*arg_node_id);
-
-                match arg_pattern2 {
-                    Pattern2::Identifier(id_symbol) => {
-                        dbg!(id_symbol.ident_str(interns).as_str());
-                    },
-                    other => {
-                        todo!("TODO: support the following pattern2 as function arg: {:?}", other);
-                    }
                 }
-            }
+            )
+            .collect();
+
+            let arg_mark_nodes = arg_names.iter().map(
+                |arg_name|
+                new_arg_name_mn(arg_name.to_string(), expr2_node_id)
+            );
+        
+            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 mut args_with_commas_ids: Vec<MarkNodeId> = 
+                args_with_commas.into_iter().map(
+                    |mark_node|
+                    mark_node_pool.add(mark_node)
+                ).collect();
+
+            let mut children_ids = vec![backslash_mn_id];
+            children_ids.append(&mut args_with_commas_ids);
+        
+            let args_mn = MarkupNode::Nested {
+                ast_node_id: ASTNodeId::AExprId(expr2_node_id),
+                children_ids,
+                parent_id_opt: None,
+                newlines_at_end: 0,
+            };
+            let args_mn_id = mark_node_pool.add(args_mn);
 
             let body_expr = env.pool.get(*body_id);
-            let body_mark_node = expr2_to_markup(
+            let body_mn_id = expr2_to_markup(
                 arena,
                 env,
                 body_expr,
@@ -263,7 +287,14 @@ pub fn expr2_to_markup<'a, 'b>(
                 interns,
             )?;
 
-            panic!("TODO")
+            let function_node = MarkupNode::Nested {
+                ast_node_id,
+                children_ids: vec![func_name_mn_id, args_mn_id, body_mn_id],
+                parent_id_opt: None,
+                newlines_at_end: 0,
+            };
+
+            mark_node_pool.add(function_node)
         }
         Expr2::RuntimeError() => new_markup_node(
             "RunTimeError".to_string(),

code_markup/src/markup/top_level_def.rs

@@ -25,6 +25,7 @@ pub fn tld_mark_node<'a>(
     interns: &Interns,
 ) -> ASTResult<MarkupNode> {
     let pattern2 = env.pool.get(identifier_id);
+    dbg!(pattern2);
     let val_name = get_identifier_string(pattern2, interns)?;
 
     let val_name_mn = MarkupNode::Text {

code_markup/src/syntax_highlight.rs

@@ -8,6 +8,7 @@ pub enum HighlightStyle {
     Operator, // =+-<>...
     String,
     FunctionName,
+    FunctionArgName,
     Type,
     Bracket,
     Number,
@@ -27,6 +28,7 @@ pub fn default_highlight_map() -> HashMap<HighlightStyle, RgbaTup> {
         (Operator, colors::WHITE),
         (String, from_hsb(346, 65, 97)),
         (FunctionName, colors::WHITE),
+        (FunctionArgName, colors::WHITE),
         (Type, colors::WHITE),
         (Bracket, from_hsb(347, 80, 100)),
         (Number, from_hsb(185, 50, 75)),

compiler/module/src/symbol.rs

@@ -81,6 +81,8 @@ impl Symbol {
                 )
             });
 
+        dbg!(ident_ids);
+
         ident_ids
             .get_name(self.ident_id())
             .unwrap_or_else(|| {