addes test to docs for function

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

@@ -95,7 +95,7 @@ pub enum Expr2 {
     },
     Call {
         args: PoolVec<(Variable, ExprId)>, // 8B
-        expr_id: 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,21 +128,11 @@ fn expr2_to_string_helper(
                 pool.get(*body_id)
             ));
         }
-        Expr2::Call {
+        Expr2::Call { .. } => {
-            ..
+            out_string.push_str(&format!("Call({:?})", expr2,));
-        } => {
-            out_string.push_str(&format!(
-                "Call({:?})",
-                expr2,
-            ));
         }
-        Expr2::Closure {
+        Expr2::Closure { .. } => {
-            ..
+            out_string.push_str(&format!("Closure({:?})", expr2,));
-        } => {
-            out_string.push_str(&format!(
-                "Closure({:?})",
-                expr2,
-            ));
         }
         other => todo!("Implement for {:?}", other),
     }

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

@@ -503,7 +503,7 @@ pub fn expr_to_expr2<'a>(
             let fn_region = loc_fn.region;
 
             // Canonicalize the function expression and its arguments
-            let (fn_expr, mut output) = to_expr2(env, scope, &loc_fn.value, fn_region);
+            let (fn_expr, mut output) = expr_to_expr2(env, scope, &loc_fn.value, fn_region);
             // The function's return type
             let args = PoolVec::with_capacity(loc_args.len() as u32, env.pool);
 
@@ -661,7 +661,10 @@ pub fn expr_to_expr2<'a>(
             //            (RuntimeError(problem), Output::default())
             todo!()
         }
-        Var { module_name, ident } => canonicalize_lookup(env, scope, "#UserApp", ident, region), // TODO use module_name instead
+        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/env.rs

@@ -37,6 +37,7 @@ pub struct Env<'a> {
 }
 
 impl<'a> Env<'a> {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         home: ModuleId,
         arena: &'a Bump,

code_markup/src/markup/common_nodes.rs

@@ -62,7 +62,7 @@ pub fn new_operator_mn(
     parent_id_opt: Option<MarkNodeId>,
 ) -> MarkupNode {
     MarkupNode::Text {
-        content: content,
+        content,
         ast_node_id: ASTNodeId::AExprId(expr_id),
         syn_high_style: HighlightStyle::Operator,
         attributes: Attributes::default(),

code_markup/src/markup/convert/from_ast.rs

@@ -1,4 +1,3 @@
-use bumpalo::Bump;
 use roc_ast::{
     ast_error::ASTResult,
     lang::{core::ast::AST, env::Env},
@@ -13,9 +12,8 @@ use crate::{
     slow_pool::{MarkNodeId, SlowPool},
 };
 
-pub fn ast_to_mark_nodes<'a, 'b>(
+pub fn ast_to_mark_nodes<'a>(
-    arena: &'a Bump,
+    env: &mut Env<'a>,
-    env: &mut Env<'b>,
     ast: &AST,
     mark_node_pool: &mut SlowPool,
     interns: &Interns,
@@ -25,7 +23,7 @@ pub fn ast_to_mark_nodes<'a, 'b>(
     for &def_id in ast.def_ids.iter() {
         let def2 = env.pool.get(def_id);
 
-        let expr2_markup_id = def2_to_markup(arena, env, def2, def_id, mark_node_pool, interns)?;
+        let expr2_markup_id = def2_to_markup(env, def2, def_id, mark_node_pool, interns)?;
 
         set_parent_for_all(expr2_markup_id, mark_node_pool);
 

code_markup/src/markup/convert/from_def2.rs

@@ -5,7 +5,6 @@ use crate::{
 
 use super::from_expr2::expr2_to_markup;
 
-use bumpalo::Bump;
 use roc_ast::{
     ast_error::ASTResult,
     lang::{
@@ -18,9 +17,8 @@ use roc_ast::{
 };
 use roc_module::symbol::Interns;
 
-pub fn def2_to_markup<'a, 'b>(
+pub fn def2_to_markup<'a>(
-    arena: &'a Bump,
+    env: &mut Env<'a>,
-    env: &mut Env<'b>,
     def2: &Def2,
     def2_node_id: DefId,
     mark_node_pool: &mut SlowPool,
@@ -34,7 +32,6 @@ pub fn def2_to_markup<'a, 'b>(
             expr_id,
         } => {
             let expr_mn_id = expr2_to_markup(
-                arena,
                 env,
                 env.pool.get(*expr_id),
                 *expr_id,

code_markup/src/markup/convert/from_expr2.rs

@@ -1,10 +1,19 @@
-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::{MarkupNode, get_string, join_mark_nodes_commas, join_mark_nodes_spaces, new_markup_node}}, slow_pool::{MarkNodeId, SlowPool}, syntax_highlight::HighlightStyle};
+        },
+        nodes::{
+            get_string, join_mark_nodes_commas, join_mark_nodes_spaces, new_markup_node, MarkupNode,
+        },
+    },
+    slow_pool::{MarkNodeId, SlowPool},
+    syntax_highlight::HighlightStyle,
+};
 
-use bumpalo::Bump;
 use itertools::Itertools;
 use roc_ast::{
     ast_error::{ASTResult, IdentIdNotFound},
@@ -25,9 +34,8 @@ use roc_module::{ident::Ident, symbol::Interns};
 use snafu::OptionExt;
 
 // make Markup Nodes: generate String representation, assign Highlighting Style
-pub fn expr2_to_markup<'a, 'b>(
+pub fn expr2_to_markup<'a>(
-    arena: &'a Bump,
+    env: &mut Env<'a>,
-    env: &mut Env<'b>,
     expr2: &Expr2,
     expr2_node_id: ExprId,
     mark_node_pool: &mut SlowPool,
@@ -73,37 +81,23 @@ pub fn expr2_to_markup<'a, 'b>(
         ),
         Expr2::Call { args, expr_id, .. } => {
             let expr = env.pool.get(*expr_id);
-            let fun_call_mark_id = expr2_to_markup(
+            let fun_call_mark_id =
-                arena,
+                expr2_to_markup(env, expr, *expr_id, mark_node_pool, interns, indent_level)?;
-                env,
-                expr,
-                *expr_id,
-                mark_node_pool,
-                interns,
-                indent_level,
-            )?;
 
-            let arg_expr_ids: Vec<ExprId> =  args.iter(env.pool).map(|(_, arg_id)| *arg_id).collect();
+            let arg_expr_ids: Vec<ExprId> =
+                args.iter(env.pool).map(|(_, arg_id)| *arg_id).collect();
 
-            let arg_call_mark_ids: Vec<MarkNodeId> =
+            let arg_call_mark_ids: Vec<MarkNodeId> = arg_expr_ids
-                arg_expr_ids.iter().map(
+                .iter()
-                    |arg_id|
+                .map(|arg_id| {
-                    {
+                    let arg_expr = env.pool.get(*arg_id);
-                        let arg_expr = env.pool.get(*arg_id);
 
-                        expr2_to_markup(
+                    expr2_to_markup(env, arg_expr, *arg_id, mark_node_pool, interns, 0)
-                            arena,
+                })
-                            env,
+                .collect::<ASTResult<Vec<MarkNodeId>>>()?;
-                            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 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);
@@ -139,7 +133,6 @@ pub fn expr2_to_markup<'a, 'b>(
                 let sub_expr2 = env.pool.get(*node_id);
 
                 children_ids.push(expr2_to_markup(
-                    arena,
                     env,
                     sub_expr2,
                     *node_id,
@@ -203,7 +196,6 @@ pub fn expr2_to_markup<'a, 'b>(
 
                         let sub_expr2 = env.pool.get(*sub_expr2_node_id);
                         children_ids.push(expr2_to_markup(
-                            arena,
                             env,
                             sub_expr2,
                             *sub_expr2_node_id,
@@ -264,7 +256,6 @@ pub fn expr2_to_markup<'a, 'b>(
                     expr_var: _,
                 } => {
                     let body_mn_id = expr2_to_markup(
-                        arena,
                         env,
                         env.pool.get(*expr_id),
                         *expr_id,
@@ -335,10 +326,12 @@ pub fn expr2_to_markup<'a, 'b>(
                 .iter()
                 .map(|ident| ident.as_inline_str().as_str());
 
-            let arg_mark_nodes =
+            let arg_mark_nodes = arg_names
-                arg_names.map(|arg_name| new_arg_name_mn(arg_name.to_string(), expr2_node_id)).collect_vec();
+                .map(|arg_name| new_arg_name_mn(arg_name.to_string(), expr2_node_id))
+                .collect_vec();
 
-            let args_with_commas: Vec<MarkupNode> = join_mark_nodes_commas(arg_mark_nodes, ASTNodeId::AExprId(expr2_node_id));
+            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()
@@ -362,7 +355,6 @@ pub fn expr2_to_markup<'a, 'b>(
 
             let body_expr = env.pool.get(*body_id);
             let body_mn_id = expr2_to_markup(
-                arena,
                 env,
                 body_expr,
                 *body_id,

code_markup/src/markup/nodes.rs

@@ -7,28 +7,13 @@ use crate::{
 use super::{attribute::Attributes, common_nodes::new_comma_mn_ast};
 
 use crate::markup_error::{ExpectedTextNode, NestedNodeMissingChild, NestedNodeRequired};
+use itertools::Itertools;
 use roc_ast::{
-    ast_error::ASTResult,
+    lang::{core::ast::ASTNodeId, env::Env},
-    lang::{
-        core::{
-            ast::{ASTNodeId, AST},
-            def::def2::{Def2, DefId},
-            expr::{
-                expr2::{Expr2, ExprId},
-                record_field::RecordField,
-            },
-            header::AppHeader,
-            pattern::get_identifier_string,
-            val_def::ValueDef,
-        },
-        env::Env,
-    },
     mem_pool::pool_str::PoolStr,
 };
-use roc_module::symbol::Interns;
 use roc_utils::{index_of, slice_get};
 use std::fmt;
-use itertools::Itertools;
 
 #[derive(Debug)]
 pub enum MarkupNode {
@@ -178,9 +163,7 @@ impl MarkupNode {
             MarkupNode::Nested { .. } => "".to_owned(),
             MarkupNode::Text { content, .. } => content.clone(),
             MarkupNode::Blank { .. } => BLANK_PLACEHOLDER.to_owned(),
-            MarkupNode::Indent { indent_level, .. } => std::iter::repeat(SINGLE_INDENT)
+            MarkupNode::Indent { indent_level, .. } => SINGLE_INDENT.repeat(*indent_level),
-                .take(*indent_level)
-                .collect(),
         }
     }
 
@@ -331,256 +314,6 @@ pub fn new_markup_node(
     }
 }
 
-
-pub fn def2_to_markup<'a>(
-    env: &mut Env<'a>,
-    def2: &Def2,
-    def2_node_id: DefId,
-    mark_node_pool: &mut SlowPool,
-    interns: &Interns,
-) -> ASTResult<MarkNodeId> {
-    let ast_node_id = ASTNodeId::ADefId(def2_node_id);
-
-    let mark_node_id = match def2 {
-        Def2::ValueDef {
-            identifier_id,
-            expr_id,
-        } => {
-            let expr_mn_id = expr2_to_markup(
-                env,
-                env.pool.get(*expr_id),
-                *expr_id,
-                mark_node_pool,
-                interns,
-            )?;
-
-            let tld_mn = tld_mark_node(
-                *identifier_id,
-                expr_mn_id,
-                ast_node_id,
-                mark_node_pool,
-                env,
-                interns,
-            )?;
-
-            mark_node_pool.add(tld_mn)
-        }
-        Def2::Blank => mark_node_pool.add(new_blank_mn_w_nls(ast_node_id, None, 2)),
-    };
-
-    Ok(mark_node_id)
-}
-
-// make Markup Nodes: generate String representation, assign Highlighting Style
-pub fn expr2_to_markup<'a>(
-    env: &mut Env<'a>,
-    expr2: &Expr2,
-    expr2_node_id: ExprId,
-    mark_node_pool: &mut SlowPool,
-    interns: &Interns,
-) -> ASTResult<MarkNodeId> {
-    let ast_node_id = ASTNodeId::AExprId(expr2_node_id);
-
-    let mark_node_id = match expr2 {
-        Expr2::SmallInt { text, .. }
-        | Expr2::I128 { text, .. }
-        | Expr2::U128 { text, .. }
-        | Expr2::Float { text, .. } => {
-            let num_str = get_string(env, text);
-
-            new_markup_node(num_str, ast_node_id, HighlightStyle::Number, mark_node_pool)
-        }
-        Expr2::Str(text) => new_markup_node(
-            "\"".to_owned() + text.as_str(env.pool) + "\"",
-            ast_node_id,
-            HighlightStyle::String,
-            mark_node_pool,
-        ),
-        Expr2::GlobalTag { name, .. } => new_markup_node(
-            get_string(env, name),
-            ast_node_id,
-            HighlightStyle::Type,
-            mark_node_pool,
-        ),
-        Expr2::Call { expr: expr_id, .. } => {
-            let expr = env.pool.get(*expr_id);
-            expr2_to_markup(env, expr, *expr_id, mark_node_pool, interns)?
-        }
-        Expr2::Var(symbol) => {
-            //TODO make bump_format with arena
-            let text = format!("{:?}", symbol);
-            new_markup_node(text, ast_node_id, HighlightStyle::Variable, mark_node_pool)
-        }
-        Expr2::List { elems, .. } => {
-            let mut children_ids =
-                vec![mark_node_pool.add(new_left_square_mn(expr2_node_id, None))];
-
-            let indexed_node_ids: Vec<(usize, ExprId)> =
-                elems.iter(env.pool).copied().enumerate().collect();
-
-            for (idx, node_id) in indexed_node_ids.iter() {
-                let sub_expr2 = env.pool.get(*node_id);
-
-                children_ids.push(expr2_to_markup(
-                    env,
-                    sub_expr2,
-                    *node_id,
-                    mark_node_pool,
-                    interns,
-                )?);
-
-                if idx + 1 < elems.len() {
-                    children_ids.push(mark_node_pool.add(new_comma_mn(expr2_node_id, None)));
-                }
-            }
-            children_ids.push(mark_node_pool.add(new_right_square_mn(expr2_node_id, None)));
-
-            let list_node = MarkupNode::Nested {
-                ast_node_id,
-                children_ids,
-                parent_id_opt: None,
-                newlines_at_end: 0,
-            };
-
-            mark_node_pool.add(list_node)
-        }
-        Expr2::EmptyRecord => {
-            let children_ids = vec![
-                mark_node_pool.add(new_left_accolade_mn(expr2_node_id, None)),
-                mark_node_pool.add(new_right_accolade_mn(expr2_node_id, None)),
-            ];
-
-            let record_node = MarkupNode::Nested {
-                ast_node_id,
-                children_ids,
-                parent_id_opt: None,
-                newlines_at_end: 0,
-            };
-
-            mark_node_pool.add(record_node)
-        }
-        Expr2::Record { fields, .. } => {
-            let mut children_ids =
-                vec![mark_node_pool.add(new_left_accolade_mn(expr2_node_id, None))];
-
-            for (idx, field_node_id) in fields.iter_node_ids().enumerate() {
-                let record_field = env.pool.get(field_node_id);
-
-                let field_name = record_field.get_record_field_pool_str();
-
-                children_ids.push(new_markup_node(
-                    field_name.as_str(env.pool).to_owned(),
-                    ast_node_id,
-                    HighlightStyle::RecordField,
-                    mark_node_pool,
-                ));
-
-                match record_field {
-                    RecordField::InvalidLabelOnly(_, _) => (),
-                    RecordField::LabelOnly(_, _, _) => (),
-                    RecordField::LabeledValue(_, _, sub_expr2_node_id) => {
-                        children_ids.push(mark_node_pool.add(new_colon_mn(expr2_node_id, None)));
-
-                        let sub_expr2 = env.pool.get(*sub_expr2_node_id);
-                        children_ids.push(expr2_to_markup(
-                            env,
-                            sub_expr2,
-                            *sub_expr2_node_id,
-                            mark_node_pool,
-                            interns,
-                        )?);
-                    }
-                }
-
-                if idx + 1 < fields.len() {
-                    children_ids.push(mark_node_pool.add(new_comma_mn(expr2_node_id, None)));
-                }
-            }
-
-            children_ids.push(mark_node_pool.add(new_right_accolade_mn(expr2_node_id, None)));
-
-            let record_node = MarkupNode::Nested {
-                ast_node_id,
-                children_ids,
-                parent_id_opt: None,
-                newlines_at_end: 0,
-            };
-
-            mark_node_pool.add(record_node)
-        }
-        Expr2::Blank => mark_node_pool.add(new_blank_mn(ast_node_id, None)),
-        Expr2::LetValue {
-            def_id,
-            body_id: _,
-            body_var: _,
-        } => {
-            let pattern_id = env.pool.get(*def_id).get_pattern_id();
-
-            let pattern2 = env.pool.get(pattern_id);
-
-            let val_name = get_identifier_string(pattern2, interns)?;
-
-            let val_name_mn = MarkupNode::Text {
-                content: val_name,
-                ast_node_id,
-                syn_high_style: HighlightStyle::Variable,
-                attributes: Attributes::default(),
-                parent_id_opt: None,
-                newlines_at_end: 0,
-            };
-
-            let val_name_mn_id = mark_node_pool.add(val_name_mn);
-
-            let equals_mn_id = mark_node_pool.add(new_equals_mn(ast_node_id, None));
-
-            let value_def = env.pool.get(*def_id);
-
-            match value_def {
-                ValueDef::NoAnnotation {
-                    pattern_id: _,
-                    expr_id,
-                    expr_var: _,
-                } => {
-                    let body_mn_id = expr2_to_markup(
-                        env,
-                        env.pool.get(*expr_id),
-                        *expr_id,
-                        mark_node_pool,
-                        interns,
-                    )?;
-
-                    let body_mn = mark_node_pool.get_mut(body_mn_id);
-                    body_mn.add_newline_at_end();
-
-                    let full_let_node = MarkupNode::Nested {
-                        ast_node_id,
-                        children_ids: vec![val_name_mn_id, equals_mn_id, body_mn_id],
-                        parent_id_opt: None,
-                        newlines_at_end: 1,
-                    };
-
-                    mark_node_pool.add(full_let_node)
-                }
-                other => {
-                    unimplemented!(
-                        "I don't know how to convert {:?} into a MarkupNode yet.",
-                        other
-                    )
-                }
-            }
-        }
-        Expr2::RuntimeError() => new_markup_node(
-            "RunTimeError".to_string(),
-            ast_node_id,
-            HighlightStyle::Blank,
-            mark_node_pool,
-        ),
-        rest => todo!("implement expr2_to_markup for {:?}", rest),
-    };
-
-    Ok(mark_node_id)
-}
-
 pub fn set_parent_for_all(markup_node_id: MarkNodeId, mark_node_pool: &mut SlowPool) {
     let node = mark_node_pool.get(markup_node_id);
 
@@ -628,218 +361,6 @@ pub fn set_parent_for_all_helper(
     }
 }
 
-fn header_mn(content: String, expr_id: ExprId, mark_node_pool: &mut SlowPool) -> MarkNodeId {
-    let mark_node = MarkupNode::Text {
-        content,
-        ast_node_id: ASTNodeId::AExprId(expr_id),
-        syn_high_style: HighlightStyle::PackageRelated,
-        attributes: Attributes::default(),
-        parent_id_opt: None,
-        newlines_at_end: 0,
-    };
-
-    mark_node_pool.add(mark_node)
-}
-
-fn header_val_mn(
-    content: String,
-    expr_id: ExprId,
-    highlight_style: HighlightStyle,
-    mark_node_pool: &mut SlowPool,
-) -> MarkNodeId {
-    let mark_node = MarkupNode::Text {
-        content,
-        ast_node_id: ASTNodeId::AExprId(expr_id),
-        syn_high_style: highlight_style,
-        attributes: Attributes::default(),
-        parent_id_opt: None,
-        newlines_at_end: 0,
-    };
-
-    mark_node_pool.add(mark_node)
-}
-
-pub fn header_to_markup(app_header: &AppHeader, mark_node_pool: &mut SlowPool) -> MarkNodeId {
-    let expr_id = app_header.ast_node_id;
-    let ast_node_id = ASTNodeId::AExprId(expr_id);
-
-    let app_node_id = header_mn("app ".to_owned(), expr_id, mark_node_pool);
-
-    let app_name_node_id = header_val_mn(
-        app_header.app_name.clone(),
-        expr_id,
-        HighlightStyle::String,
-        mark_node_pool,
-    );
-
-    let full_app_node = MarkupNode::Nested {
-        ast_node_id,
-        children_ids: vec![app_node_id, app_name_node_id],
-        parent_id_opt: None,
-        newlines_at_end: 1,
-    };
-
-    let packages_node_id = header_mn("    packages ".to_owned(), expr_id, mark_node_pool);
-
-    let pack_left_acc_node_id = mark_node_pool.add(new_left_accolade_mn(expr_id, None));
-
-    let pack_base_node_id = header_val_mn(
-        "base: ".to_owned(),
-        expr_id,
-        HighlightStyle::RecordField,
-        mark_node_pool,
-    );
-
-    let pack_val_node_id = header_val_mn(
-        app_header.packages_base.clone(),
-        expr_id,
-        HighlightStyle::String,
-        mark_node_pool,
-    );
-
-    let pack_right_acc_node_id = mark_node_pool.add(new_right_accolade_mn(expr_id, None));
-
-    let full_packages_node = MarkupNode::Nested {
-        ast_node_id,
-        children_ids: vec![
-            packages_node_id,
-            pack_left_acc_node_id,
-            pack_base_node_id,
-            pack_val_node_id,
-            pack_right_acc_node_id,
-        ],
-        parent_id_opt: None,
-        newlines_at_end: 1,
-    };
-
-    let imports_node_id = header_mn("    imports ".to_owned(), expr_id, mark_node_pool);
-
-    let imports_left_square_node_id = mark_node_pool.add(new_left_square_mn(expr_id, None));
-
-    let mut import_child_ids: Vec<MarkNodeId> = add_header_mn_list(
-        &app_header.imports,
-        expr_id,
-        HighlightStyle::Import,
-        mark_node_pool,
-    );
-
-    let imports_right_square_node_id = mark_node_pool.add(new_right_square_mn(expr_id, None));
-
-    let mut full_import_children = vec![imports_node_id, imports_left_square_node_id];
-
-    full_import_children.append(&mut import_child_ids);
-    full_import_children.push(imports_right_square_node_id);
-
-    let full_import_node = MarkupNode::Nested {
-        ast_node_id,
-        children_ids: full_import_children,
-        parent_id_opt: None,
-        newlines_at_end: 1,
-    };
-
-    let provides_node_id = header_mn("    provides ".to_owned(), expr_id, mark_node_pool);
-
-    let provides_left_square_node_id = mark_node_pool.add(new_left_square_mn(expr_id, None));
-
-    let mut provides_val_node_ids: Vec<MarkNodeId> = add_header_mn_list(
-        &app_header.provides,
-        expr_id,
-        HighlightStyle::Provides,
-        mark_node_pool,
-    );
-
-    let provides_right_square_node_id = mark_node_pool.add(new_right_square_mn(expr_id, None));
-
-    let provides_end_node_id = header_mn(" to base".to_owned(), expr_id, mark_node_pool);
-
-    let mut full_provides_children = vec![provides_node_id, provides_left_square_node_id];
-
-    full_provides_children.append(&mut provides_val_node_ids);
-    full_provides_children.push(provides_right_square_node_id);
-    full_provides_children.push(provides_end_node_id);
-
-    let full_provides_node = MarkupNode::Nested {
-        ast_node_id,
-        children_ids: full_provides_children,
-        parent_id_opt: None,
-        newlines_at_end: 1,
-    };
-
-    let full_app_node_id = mark_node_pool.add(full_app_node);
-    let full_packages_node = mark_node_pool.add(full_packages_node);
-    let full_import_node_id = mark_node_pool.add(full_import_node);
-    let full_provides_node_id = mark_node_pool.add(full_provides_node);
-
-    let header_mark_node = MarkupNode::Nested {
-        ast_node_id,
-        children_ids: vec![
-            full_app_node_id,
-            full_packages_node,
-            full_import_node_id,
-            full_provides_node_id,
-        ],
-        parent_id_opt: None,
-        newlines_at_end: 1,
-    };
-
-    let header_mn_id = mark_node_pool.add(header_mark_node);
-
-    set_parent_for_all(header_mn_id, mark_node_pool);
-
-    header_mn_id
-}
-
-// Used for provides and imports
-fn add_header_mn_list(
-    str_vec: &[String],
-    expr_id: ExprId,
-    highlight_style: HighlightStyle,
-    mark_node_pool: &mut SlowPool,
-) -> Vec<MarkNodeId> {
-    let nr_of_elts = str_vec.len();
-
-    str_vec
-        .iter()
-        .enumerate()
-        .map(|(indx, provide_str)| {
-            let provide_str = header_val_mn(
-                provide_str.to_owned(),
-                expr_id,
-                highlight_style,
-                mark_node_pool,
-            );
-
-            if indx != nr_of_elts - 1 {
-                vec![provide_str, mark_node_pool.add(new_comma_mn(expr_id, None))]
-            } else {
-                vec![provide_str]
-            }
-        })
-        .flatten()
-        .collect()
-}
-
-pub fn ast_to_mark_nodes<'a>(
-    env: &mut Env<'a>,
-    ast: &AST,
-    mark_node_pool: &mut SlowPool,
-    interns: &Interns,
-) -> ASTResult<Vec<MarkNodeId>> {
-    let mut all_mark_node_ids = vec![header_to_markup(&ast.header, mark_node_pool)];
-
-    for &def_id in ast.def_ids.iter() {
-        let def2 = env.pool.get(def_id);
-
-        let def2_markup_id = def2_to_markup(env, def2, def_id, mark_node_pool, interns)?;
-
-        set_parent_for_all(def2_markup_id, mark_node_pool);
-
-        all_mark_node_ids.push(def2_markup_id);
-    }
-
-    Ok(all_mark_node_ids)
-}
-
 impl fmt::Display for MarkupNode {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
@@ -901,16 +422,19 @@ 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> {
+pub fn join_mark_nodes_spaces(
-    let space_range_max  =
+    mark_nodes_ids: Vec<MarkNodeId>,
-        if with_prepend {
+    with_prepend: bool,
-            mark_nodes_ids.len()
+    ast_node_id: ASTNodeId,
-        } else {
+    mark_node_pool: &mut SlowPool,
-            mark_nodes_ids.len() - 1
+) -> Vec<MarkNodeId> {
-        };
+    let space_range_max = if with_prepend {
+        mark_nodes_ids.len()
+    } else {
+        mark_nodes_ids.len() - 1
+    };
 
-    let join_nodes: Vec<MarkNodeId> =
+    let join_nodes: Vec<MarkNodeId> = (0..space_range_max)
-        (0..space_range_max)
         .map(|_| {
             let space_node = MarkupNode::Text {
                 content: " ".to_string(),
@@ -930,15 +454,14 @@ pub fn join_mark_nodes_spaces(mark_nodes_ids: Vec<MarkNodeId>, with_prepend: boo
     } 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> {
+pub fn join_mark_nodes_commas(
-    let join_nodes: Vec<MarkupNode> =
+    mark_nodes: Vec<MarkupNode>,
-        (0..(mark_nodes.len() - 1))
+    ast_node_id: ASTNodeId,
-        .map(|_| {
+) -> Vec<MarkupNode> {
-            new_comma_mn_ast(ast_node_id, None)
+    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()

docs/src/def.rs

@@ -4,7 +4,7 @@ use roc_ast::{
     lang::{self, core::def::def_to_def2::def_to_def2},
     mem_pool::pool::Pool,
 };
-use roc_code_markup::{markup::nodes::def2_to_markup, slow_pool::SlowPool};
+use roc_code_markup::{markup::convert::from_def2::def2_to_markup, slow_pool::SlowPool};
 use roc_module::symbol::{IdentIds, Interns, ModuleId, ModuleIds};
 use roc_region::all::Region;
 use roc_types::subs::VarStore;
@@ -17,6 +17,7 @@ pub fn defs_to_html<'a>(
     defs: Vec<roc_parse::ast::Def<'a>>,
     env_module_id: ModuleId,
     env_module_ids: &'a ModuleIds,
+    all_ident_ids: IdentIds,
     interns: &Interns,
 ) {
     let mut env_pool = Pool::with_capacity(1024);
@@ -35,6 +36,7 @@ pub fn defs_to_html<'a>(
         &mut var_store,
         dep_idents,
         env_module_ids,
+        all_ident_ids,
         exposed_ident_ids,
     );
 

docs/src/expr.rs

@@ -5,7 +5,7 @@ use roc_ast::{
     lang::{self, core::expr::expr_to_expr2::expr_to_expr2},
     mem_pool::pool::Pool,
 };
-use roc_code_markup::{markup::nodes::expr2_to_markup, slow_pool::SlowPool};
+use roc_code_markup::{markup::convert::from_expr2::expr2_to_markup, slow_pool::SlowPool};
 use roc_module::symbol::{IdentIds, Interns, ModuleId, ModuleIds};
 use roc_parse::ast::Expr;
 use roc_region::all::Region;
@@ -17,6 +17,7 @@ pub fn expr_to_html<'a>(
     expr: Expr<'a>,
     env_module_id: ModuleId,
     env_module_ids: &'a ModuleIds,
+    all_ident_ids: IdentIds,
     interns: &Interns,
 ) {
     let mut env_pool = Pool::with_capacity(1024);
@@ -33,6 +34,7 @@ pub fn expr_to_html<'a>(
         &mut var_store,
         dep_idents,
         env_module_ids,
+        all_ident_ids,
         exposed_ident_ids,
     );
 
@@ -63,6 +65,7 @@ fn write_expr_to_bump_str_html<'a, 'b>(
         expr2_id,
         &mut mark_node_pool,
         interns,
+        0,
     )?;
 
     let expr2_markup_node = mark_node_pool.get(expr2_markup_id);

docs/src/html.rs

@@ -7,7 +7,7 @@ pub fn mark_node_to_html<'a>(
     mark_node_pool: &SlowPool,
     buf: &mut BumpString<'a>,
 ) {
-    let additional_newlines: usize;
+    let mut additional_newlines = 0;
 
     match mark_node {
         MarkupNode::Nested {
@@ -33,12 +33,13 @@ pub fn mark_node_to_html<'a>(
                 Operator => "operator",
                 Comma => "comma",
                 String => "string",
-                FunctionName => "function_name",
+                FunctionName => "function-name",
+                FunctionArgName => "function-arg-name",
                 Type => "type",
                 Bracket => "bracket",
                 Number => "number",
                 PackageRelated => "package-related",
-                Variable => "variable",
+                Value => "value",
                 RecordField => "recordfield",
                 Import => "import",
                 Provides => "provides",
@@ -62,6 +63,11 @@ pub fn mark_node_to_html<'a>(
 
             additional_newlines = *newlines_at_end;
         }
+        MarkupNode::Indent { .. } => {
+            let content_str = mark_node.get_content();
+
+            write_html_to_buf(&content_str, "indent", buf);
+        }
     }
 
     for _ in 0..additional_newlines {

docs/src/lib.rs

@@ -127,6 +127,7 @@ pub fn syntax_highlight_expr<'a>(
     code_str: &'a str,
     env_module_id: ModuleId,
     env_module_ids: &'a ModuleIds,
+    all_ident_ids: IdentIds,
     interns: &Interns,
 ) -> Result<String, SyntaxError<'a>> {
     let trimmed_code_str = code_str.trim_end().trim();
@@ -134,7 +135,14 @@ pub fn syntax_highlight_expr<'a>(
 
     match roc_parse::expr::test_parse_expr(0, arena, state) {
         Ok(loc_expr) => {
-            expr_to_html(buf, loc_expr.value, env_module_id, env_module_ids, interns);
+            expr_to_html(
+                buf,
+                loc_expr.value,
+                env_module_id,
+                env_module_ids,
+                all_ident_ids,
+                interns,
+            );
 
             Ok(buf.to_string())
         }
@@ -149,6 +157,7 @@ pub fn syntax_highlight_top_level_defs<'a>(
     code_str: &'a str,
     env_module_id: ModuleId,
     env_module_ids: &'a ModuleIds,
+    all_ident_ids: IdentIds,
     interns: &Interns,
 ) -> Result<String, SyntaxError<'a>> {
     let trimmed_code_str = code_str.trim_end().trim();
@@ -157,7 +166,14 @@ pub fn syntax_highlight_top_level_defs<'a>(
         Ok(vec_loc_def) => {
             let vec_def = vec_loc_def.iter().map(|loc| loc.value).collect();
 
-            defs_to_html(buf, vec_def, env_module_id, env_module_ids, interns);
+            defs_to_html(
+                buf,
+                vec_def,
+                env_module_id,
+                env_module_ids,
+                all_ident_ids,
+                interns,
+            );
 
             Ok(buf.to_string())
         }
@@ -972,12 +988,21 @@ fn markdown_to_html(
                 let code_block_arena = Bump::new();
 
                 let mut code_block_buf = BumpString::new_in(&code_block_arena);
+
+                let all_ident_ids = loaded_module
+                    .interns
+                    .all_ident_ids
+                    .get(&loaded_module.module_id)
+                    .unwrap()
+                    .clone(); //TODO remove unwrap
+
                 match syntax_highlight_expr(
                     &code_block_arena,
                     &mut code_block_buf,
                     code_str,
                     loaded_module.module_id,
                     &loaded_module.interns.module_ids,
+                    all_ident_ids,
                     &loaded_module.interns
                 )
                 {

docs/tests/insert_syntax_highlighting.rs

@@ -15,6 +15,13 @@ mod insert_doc_syntax_highlighting {
     fn expect_html(code_str: &str, want: &str, use_expr: bool) {
         let loaded_module = make_mock_module();
 
+        let all_ident_ids = loaded_module
+            .interns
+            .all_ident_ids
+            .get(&loaded_module.module_id)
+            .unwrap()
+            .clone();
+
         let code_block_arena = Bump::new();
         let mut code_block_buf = BumpString::new_in(&code_block_arena);
 
@@ -25,6 +32,7 @@ mod insert_doc_syntax_highlighting {
                 code_str,
                 loaded_module.module_id,
                 &loaded_module.interns.module_ids,
+                all_ident_ids,
                 &loaded_module.interns,
             ) {
                 Ok(highlighted_code_str) => {
@@ -41,6 +49,7 @@ mod insert_doc_syntax_highlighting {
                 code_str,
                 loaded_module.module_id,
                 &loaded_module.interns.module_ids,
+                all_ident_ids,
                 &loaded_module.interns,
             ) {
                 Ok(highlighted_code_str) => {
@@ -144,7 +153,7 @@ main = "Hello, world!"
     fn top_level_def_value() {
         expect_html_def(
             r#"main = "Hello, World!""#,
-            "<span class=\"syntax-variable\">main</span><span class=\"syntax-operator\"> = </span><span class=\"syntax-string\">\"Hello, World!\"</span>\n\n",
+            "<span class=\"syntax-value\">main</span><span class=\"syntax-operator\"> = </span><span class=\"syntax-string\">\"Hello, World!\"</span>\n\n",
         );
     }
 
@@ -152,7 +161,16 @@ main = "Hello, world!"
     fn tld_list() {
         expect_html_def(
             r#"main = [ 1, 2, 3 ]"#,
-            "<span class=\"syntax-variable\">main</span><span class=\"syntax-operator\"> = </span><span class=\"syntax-bracket\">[ </span><span class=\"syntax-number\">1</span><span class=\"syntax-comma\">, </span><span class=\"syntax-number\">2</span><span class=\"syntax-comma\">, </span><span class=\"syntax-number\">3</span><span class=\"syntax-bracket\"> ]</span>\n\n",
+            "<span class=\"syntax-value\">main</span><span class=\"syntax-operator\"> = </span><span class=\"syntax-bracket\">[ </span><span class=\"syntax-number\">1</span><span class=\"syntax-comma\">, </span><span class=\"syntax-number\">2</span><span class=\"syntax-comma\">, </span><span class=\"syntax-number\">3</span><span class=\"syntax-bracket\"> ]</span>\n\n",
+        );
+    }
+
+    #[test]
+    fn function() {
+        expect_html_def(
+            r#"myId = \something ->
+                something"#,
+            "<span class=\"syntax-value\">myId</span><span class=\"syntax-operator\"> = </span><span class=\"syntax-operator\">\\</span><span class=\"syntax-function-arg-name\">something</span><span class=\"syntax-operator\"> -> </span>\n<span class=\"syntax-indent\">    </span><span class=\"syntax-value\">something</span>\n\n",
         );
     }
 }

editor/src/editor/code_lines.rs

@@ -22,7 +22,8 @@ impl CodeLines {
     ) -> UIResult<()> {
         let nr_of_lines = self.lines.len();
 
-        if index == 17 { // TODO remove me
+        if index == 17 {
+            // TODO remove me
             dbg!("breakpoint here");
         }
 

editor/src/editor/mvc/ed_update.rs

@@ -280,7 +280,6 @@ impl<'a> EdModel<'a> {
                 code_lines,
             )?;
 
-
             *col_nr += node_content.len();
         }
 

editor/src/editor/render_ast.rs

@@ -3,7 +3,7 @@ use crate::editor::{ed_error::EdResult, theme::EdTheme, util::map_get};
 use crate::graphics::primitives::rect::Rect;
 use crate::graphics::primitives::text as gr_text;
 use cgmath::Vector2;
-use roc_code_markup::markup::nodes::{MarkupNode, BLANK_PLACEHOLDER, SINGLE_INDENT};
+use roc_code_markup::markup::nodes::{MarkupNode, BLANK_PLACEHOLDER};
 use roc_code_markup::slow_pool::{MarkNodeId, SlowPool};
 use roc_code_markup::syntax_highlight::HighlightStyle;
 use winit::dpi::PhysicalSize;