language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-27 13:59:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

nodes without ast_node_id

Browse source
This commit is contained in:
Anton-4 2022-03-02 17:14:51 +01:00
parent bddab60e6b
commit 853badf777
No known key found for this signature in database
GPG key ID: C954D6E0F9C0ABFD
21 changed files with 337 additions and 252 deletions
Download patch file Download diff file Expand all files Collapse all files

68
code_markup/src/markup/common_nodes.rs
View file

@ -1,124 +1,104 @@
use roc_ast::lang::core::{ast::ASTNodeId, expr::expr2::ExprId}; use crate::{syntax_highlight::HighlightStyle};
use crate::{slow_pool::MarkNodeId, syntax_highlight::HighlightStyle};
use super::{attribute::Attributes, nodes, nodes::MarkupNode}; use super::{attribute::Attributes, nodes, nodes::MarkupNode};
pub fn new_equals_mn(ast_node_id: ASTNodeId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode { pub fn new_equals_mn() -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content: nodes::EQUALS.to_owned(), content: nodes::EQUALS.to_owned(),
ast_node_id,
syn_high_style: HighlightStyle::Operator, syn_high_style: HighlightStyle::Operator,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
} }
} }
pub fn new_comma_mn(expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode { pub fn new_comma_mn() -> 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 { MarkupNode::Text {
content: nodes::COMMA.to_owned(), content: nodes::COMMA.to_owned(),
ast_node_id,
syn_high_style: HighlightStyle::Comma, syn_high_style: HighlightStyle::Comma,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
} }
} }
pub fn new_blank_mn(ast_node_id: ASTNodeId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode { pub fn new_blank_mn() -> MarkupNode {
MarkupNode::Blank { MarkupNode::Blank {
ast_node_id,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
} }
} }
pub fn new_blank_mn_w_nls( pub fn new_blank_mn_w_nls(
ast_node_id: ASTNodeId,
parent_id_opt: Option<MarkNodeId>,
nr_of_newlines: usize, nr_of_newlines: usize,
) -> MarkupNode { ) -> MarkupNode {
MarkupNode::Blank { MarkupNode::Blank {
ast_node_id,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt: None,
newlines_at_end: nr_of_newlines, newlines_at_end: nr_of_newlines,
} }
} }
pub fn new_colon_mn(expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode { pub fn new_colon_mn() -> MarkupNode {
new_operator_mn(nodes::COLON.to_owned(), expr_id, parent_id_opt) new_operator_mn(nodes::COLON.to_owned())
} }
pub fn new_operator_mn( pub fn new_operator_mn(
content: String, content: String,
expr_id: ExprId,
parent_id_opt: Option<MarkNodeId>,
) -> MarkupNode { ) -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content, content,
ast_node_id: ASTNodeId::AExprId(expr_id),
syn_high_style: HighlightStyle::Operator, syn_high_style: HighlightStyle::Operator,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
} }
} }
pub fn new_left_accolade_mn(expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode { pub fn new_left_accolade_mn() -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content: nodes::LEFT_ACCOLADE.to_owned(), content: nodes::LEFT_ACCOLADE.to_owned(),
ast_node_id: ASTNodeId::AExprId(expr_id),
syn_high_style: HighlightStyle::Bracket, syn_high_style: HighlightStyle::Bracket,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
} }
} }
pub fn new_right_accolade_mn(expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode { pub fn new_right_accolade_mn() -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content: nodes::RIGHT_ACCOLADE.to_owned(), content: nodes::RIGHT_ACCOLADE.to_owned(),
ast_node_id: ASTNodeId::AExprId(expr_id),
syn_high_style: HighlightStyle::Bracket, syn_high_style: HighlightStyle::Bracket,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
} }
} }
pub fn new_left_square_mn(expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode { pub fn new_left_square_mn() -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content: nodes::LEFT_SQUARE_BR.to_owned(), content: nodes::LEFT_SQUARE_BR.to_owned(),
ast_node_id: ASTNodeId::AExprId(expr_id),
syn_high_style: HighlightStyle::Bracket, syn_high_style: HighlightStyle::Bracket,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
} }
} }
pub fn new_right_square_mn(expr_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode { pub fn new_right_square_mn() -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content: nodes::RIGHT_SQUARE_BR.to_owned(), content: nodes::RIGHT_SQUARE_BR.to_owned(),
ast_node_id: ASTNodeId::AExprId(expr_id),
syn_high_style: HighlightStyle::Bracket, syn_high_style: HighlightStyle::Bracket,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
} }
} }
pub fn new_func_name_mn(content: String, expr_id: ExprId) -> MarkupNode { pub fn new_func_name_mn(content: String) -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content, content,
ast_node_id: ASTNodeId::AExprId(expr_id),
syn_high_style: HighlightStyle::FunctionName, syn_high_style: HighlightStyle::FunctionName,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,
@ -126,10 +106,9 @@ pub fn new_func_name_mn(content: String, expr_id: ExprId) -> MarkupNode {
} }
} }
pub fn new_arg_name_mn(content: String, expr_id: ExprId) -> MarkupNode { pub fn new_arg_name_mn(content: String) -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content, content,
ast_node_id: ASTNodeId::AExprId(expr_id),
syn_high_style: HighlightStyle::FunctionArgName, syn_high_style: HighlightStyle::FunctionArgName,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,
@ -137,10 +116,9 @@ pub fn new_arg_name_mn(content: String, expr_id: ExprId) -> MarkupNode {
} }
} }
pub fn new_arrow_mn(ast_node_id: ASTNodeId, newlines_at_end: usize) -> MarkupNode { pub fn new_arrow_mn(newlines_at_end: usize) -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content: nodes::ARROW.to_owned(), content: nodes::ARROW.to_owned(),
ast_node_id,
syn_high_style: HighlightStyle::Operator, syn_high_style: HighlightStyle::Operator,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,
@ -150,12 +128,10 @@ pub fn new_arrow_mn(ast_node_id: ASTNodeId, newlines_at_end: usize) -> MarkupNod
pub fn new_comments_mn( pub fn new_comments_mn(
comments: String, comments: String,
ast_node_id: ASTNodeId,
newlines_at_end: usize, newlines_at_end: usize,
) -> MarkupNode { ) -> MarkupNode {
MarkupNode::Text { MarkupNode::Text {
content: comments, content: comments,
ast_node_id,
syn_high_style: HighlightStyle::Comment, syn_high_style: HighlightStyle::Comment,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,

10
code_markup/src/markup/convert/from_ast.rs
View file

@ -8,6 +8,7 @@ use crate::{
markup::{ markup::{
convert::{from_def2::def2_to_markup, from_header::header_to_markup}, convert::{from_def2::def2_to_markup, from_header::header_to_markup},
nodes::set_parent_for_all, nodes::set_parent_for_all,
mark_id_ast_id_map::MarkIdAstIdMap
}, },
slow_pool::{MarkNodeId, SlowPool}, slow_pool::{MarkNodeId, SlowPool},
}; };
@ -17,8 +18,9 @@ pub fn ast_to_mark_nodes<'a>(
ast: &AST, ast: &AST,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
interns: &Interns, interns: &Interns,
) -> ASTResult<Vec<MarkNodeId>> { ) -> ASTResult<(Vec<MarkNodeId>, MarkIdAstIdMap)> {
let mut all_mark_node_ids = vec![header_to_markup(&ast.header, mark_node_pool)]; let mut mark_id_ast_id_map = MarkIdAstIdMap::default();
let mut all_mark_node_ids = vec![header_to_markup(&ast.header, mark_node_pool, &mut mark_id_ast_id_map)];
for &def_id in ast.def_ids.iter() { for &def_id in ast.def_ids.iter() {
// for debugging // for debugging
@ -26,12 +28,12 @@ pub fn ast_to_mark_nodes<'a>(
let def2 = env.pool.get(def_id); let def2 = env.pool.get(def_id);
let expr2_markup_id = def2_to_markup(env, def2, def_id, mark_node_pool, interns)?; let expr2_markup_id = def2_to_markup(env, def2, def_id, mark_node_pool, &mut mark_id_ast_id_map, interns)?;
set_parent_for_all(expr2_markup_id, mark_node_pool); set_parent_for_all(expr2_markup_id, mark_node_pool);
all_mark_node_ids.push(expr2_markup_id); all_mark_node_ids.push(expr2_markup_id);
} }
Ok(all_mark_node_ids) Ok((all_mark_node_ids, mark_id_ast_id_map))
} }

40
code_markup/src/markup/convert/from_def2.rs
View file

@ -1,7 +1,7 @@
use crate::{ use crate::{
markup::{ markup::{
common_nodes::new_blank_mn_w_nls, common_nodes::new_blank_mn_w_nls,
top_level_def::{tld_mark_node, tld_w_comments_mark_node}, top_level_def::{tld_mark_node, tld_w_comments_mark_node}, mark_id_ast_id_map::MarkIdAstIdMap, nodes::MarkupNode,
}, },
slow_pool::{MarkNodeId, SlowPool}, slow_pool::{MarkNodeId, SlowPool},
}; };
@ -20,11 +20,25 @@ use roc_ast::{
}; };
use roc_module::symbol::Interns; use roc_module::symbol::Interns;
pub fn add_node(
mark_node: MarkupNode,
ast_node_id: ASTNodeId,
mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap,
) -> MarkNodeId {
let mark_node_id = mark_node_pool.add(mark_node);
mark_id_ast_id_map.insert(mark_node_id, ast_node_id);
mark_node_id
}
pub fn def2_to_markup<'a>( pub fn def2_to_markup<'a>(
env: &mut Env<'a>, env: &mut Env<'a>,
def2: &Def2, def2: &Def2,
def2_node_id: DefId, def2_node_id: DefId,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap,
interns: &Interns, interns: &Interns,
) -> ASTResult<MarkNodeId> { ) -> ASTResult<MarkNodeId> {
let ast_node_id = ASTNodeId::ADefId(def2_node_id); let ast_node_id = ASTNodeId::ADefId(def2_node_id);
@ -39,45 +53,55 @@ pub fn def2_to_markup<'a>(
env.pool.get(*expr_id), env.pool.get(*expr_id),
*expr_id, *expr_id,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
interns, interns,
0, 0,
)?; )?;
let tld_mn = let tld_mn =
tld_mark_node(*identifier_id, expr_mn_id, ast_node_id, mark_node_pool, env)?; tld_mark_node(*identifier_id, expr_mn_id, ast_node_id, mark_node_pool, mark_id_ast_id_map, env)?;
mark_node_pool.add(tld_mn) add_node(tld_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
Def2::Blank => mark_node_pool.add(new_blank_mn_w_nls(ast_node_id, None, 2)), Def2::Blank => {
add_node(
new_blank_mn_w_nls(2),
ast_node_id,
mark_node_pool,
mark_id_ast_id_map
)
},
Def2::CommentsBefore { comments, def_id } => { Def2::CommentsBefore { comments, def_id } => {
let inner_def = env.pool.get(*def_id); let inner_def = env.pool.get(*def_id);
let inner_def_mark_node_id = let inner_def_mark_node_id =
def2_to_markup(env, inner_def, *def_id, mark_node_pool, interns)?; def2_to_markup(env, inner_def, *def_id, mark_node_pool, mark_id_ast_id_map, interns)?;
let full_mark_node = tld_w_comments_mark_node( let full_mark_node = tld_w_comments_mark_node(
comments.clone(), comments.clone(),
inner_def_mark_node_id, inner_def_mark_node_id,
ast_node_id, ast_node_id,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
true, true,
)?; )?;
mark_node_pool.add(full_mark_node) add_node(full_mark_node, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
Def2::CommentsAfter { def_id, comments } => { Def2::CommentsAfter { def_id, comments } => {
let inner_def = env.pool.get(*def_id); let inner_def = env.pool.get(*def_id);
let inner_def_mark_node_id = let inner_def_mark_node_id =
def2_to_markup(env, inner_def, *def_id, mark_node_pool, interns)?; def2_to_markup(env, inner_def, *def_id, mark_node_pool, mark_id_ast_id_map, interns)?;
let full_mark_node = tld_w_comments_mark_node( let full_mark_node = tld_w_comments_mark_node(
comments.clone(), comments.clone(),
inner_def_mark_node_id, inner_def_mark_node_id,
ast_node_id, ast_node_id,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
false, false,
)?; )?;
mark_node_pool.add(full_mark_node) add_node(full_mark_node, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
}; };

127
code_markup/src/markup/convert/from_expr2.rs
View file

@ -8,7 +8,7 @@ use crate::{
}, },
nodes::{ nodes::{
get_string, join_mark_nodes_commas, join_mark_nodes_spaces, new_markup_node, MarkupNode, get_string, join_mark_nodes_commas, join_mark_nodes_spaces, new_markup_node, MarkupNode,
}, }, mark_id_ast_id_map::MarkIdAstIdMap,
}, },
slow_pool::{MarkNodeId, SlowPool}, slow_pool::{MarkNodeId, SlowPool},
syntax_highlight::HighlightStyle, syntax_highlight::HighlightStyle,
@ -32,12 +32,15 @@ use roc_ast::{
}; };
use roc_module::{module_err::ModuleResult, symbol::Interns}; use roc_module::{module_err::ModuleResult, symbol::Interns};
use super::from_def2::add_node;
// make Markup Nodes: generate String representation, assign Highlighting Style // make Markup Nodes: generate String representation, assign Highlighting Style
pub fn expr2_to_markup<'a>( pub fn expr2_to_markup<'a>(
env: &Env<'a>, env: &Env<'a>,
expr2: &Expr2, expr2: &Expr2,
expr2_node_id: ExprId, expr2_node_id: ExprId,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap,
interns: &Interns, interns: &Interns,
indent_level: usize, indent_level: usize,
) -> ASTResult<MarkNodeId> { ) -> ASTResult<MarkNodeId> {
@ -58,30 +61,32 @@ pub fn expr2_to_markup<'a>(
ast_node_id, ast_node_id,
HighlightStyle::Number, HighlightStyle::Number,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
indent_level, indent_level,
) )
} }
Expr2::Str(text) => { Expr2::Str(text) => {
let content = format!("\"{}\"", text.as_str(env.pool)); let content = format!("\"{}\"", text.as_str(env.pool));
string_mark_node(&content, indent_level, ast_node_id, mark_node_pool) string_mark_node(&content, indent_level, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
Expr2::SmallStr(array_str) => { Expr2::SmallStr(array_str) => {
let content = format!("\"{}\"", array_str.as_str()); let content = format!("\"{}\"", array_str.as_str());
string_mark_node(&content, indent_level, ast_node_id, mark_node_pool) string_mark_node(&content, indent_level, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
Expr2::GlobalTag { name, .. } => new_markup_node( Expr2::GlobalTag { name, .. } => new_markup_node(
with_indent(indent_level, &get_string(env, name)), with_indent(indent_level, &get_string(env, name)),
ast_node_id, ast_node_id,
HighlightStyle::Type, HighlightStyle::Type,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
indent_level, indent_level,
), ),
Expr2::Call { args, expr_id, .. } => { Expr2::Call { args, expr_id, .. } => {
let expr = env.pool.get(*expr_id); let expr = env.pool.get(*expr_id);
let fun_call_mark_id = let fun_call_mark_id =
expr2_to_markup(env, expr, *expr_id, mark_node_pool, interns, indent_level)?; expr2_to_markup(env, expr, *expr_id, mark_node_pool, mark_id_ast_id_map, interns, indent_level)?;
let arg_expr_ids: Vec<ExprId> = let arg_expr_ids: Vec<ExprId> =
args.iter(env.pool).map(|(_, arg_id)| *arg_id).collect(); args.iter(env.pool).map(|(_, arg_id)| *arg_id).collect();
@ -91,24 +96,23 @@ pub fn expr2_to_markup<'a>(
.map(|arg_id| { .map(|arg_id| {
let arg_expr = env.pool.get(*arg_id); let arg_expr = env.pool.get(*arg_id);
expr2_to_markup(env, arg_expr, *arg_id, mark_node_pool, interns, 0) expr2_to_markup(env, arg_expr, *arg_id, mark_node_pool, mark_id_ast_id_map, interns, 0)
}) })
.collect::<ASTResult<Vec<MarkNodeId>>>()?; .collect::<ASTResult<Vec<MarkNodeId>>>()?;
let mut args_with_sapces = let mut args_with_sapces =
join_mark_nodes_spaces(arg_call_mark_ids, true, ast_node_id, mark_node_pool); join_mark_nodes_spaces(arg_call_mark_ids, true, mark_node_pool);
let mut children_ids = vec![fun_call_mark_id]; let mut children_ids = vec![fun_call_mark_id];
children_ids.append(&mut args_with_sapces); children_ids.append(&mut args_with_sapces);
let call_node = MarkupNode::Nested { let call_node = MarkupNode::Nested {
ast_node_id,
children_ids, children_ids,
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
mark_node_pool.add(call_node) add_node(call_node, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
Expr2::Var(symbol) => { Expr2::Var(symbol) => {
let text = symbol.fully_qualified(interns, env.home); let text = symbol.fully_qualified(interns, env.home);
@ -118,12 +122,20 @@ pub fn expr2_to_markup<'a>(
ast_node_id, ast_node_id,
HighlightStyle::Value, HighlightStyle::Value,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
indent_level, indent_level,
) )
} }
Expr2::List { elems, .. } => { Expr2::List { elems, .. } => {
let mut children_ids = let mut children_ids =
vec![mark_node_pool.add(new_left_square_mn(expr2_node_id, None))]; vec![
add_node(
new_left_square_mn(),
ast_node_id,
mark_node_pool,
mark_id_ast_id_map
)
];
let indexed_node_ids: Vec<(usize, ExprId)> = let indexed_node_ids: Vec<(usize, ExprId)> =
elems.iter(env.pool).copied().enumerate().collect(); elems.iter(env.pool).copied().enumerate().collect();
@ -136,43 +148,58 @@ pub fn expr2_to_markup<'a>(
sub_expr2, sub_expr2,
*node_id, *node_id,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
interns, interns,
indent_level, indent_level,
)?); )?);
if idx + 1 < elems.len() { if idx + 1 < elems.len() {
children_ids.push(mark_node_pool.add(new_comma_mn(expr2_node_id, None))); children_ids.push(
add_node(
new_comma_mn(),
ast_node_id,
mark_node_pool,
mark_id_ast_id_map
)
);
} }
} }
children_ids.push(mark_node_pool.add(new_right_square_mn(expr2_node_id, None))); children_ids.push(
add_node(
new_right_square_mn(),
ast_node_id,
mark_node_pool,
mark_id_ast_id_map
)
);
let list_node = MarkupNode::Nested { let list_mn = MarkupNode::Nested {
ast_node_id,
children_ids, children_ids,
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
mark_node_pool.add(list_node) add_node(list_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
Expr2::EmptyRecord => { Expr2::EmptyRecord => {
let children_ids = vec![ let children_ids = vec![
mark_node_pool.add(new_left_accolade_mn(expr2_node_id, None)), add_node(new_left_accolade_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map),
mark_node_pool.add(new_right_accolade_mn(expr2_node_id, None)), add_node(new_right_accolade_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map),
]; ];
let record_node = MarkupNode::Nested { let record_mn = MarkupNode::Nested {
ast_node_id,
children_ids, children_ids,
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
mark_node_pool.add(record_node) add_node(record_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
Expr2::Record { fields, .. } => { Expr2::Record { fields, .. } => {
let mut children_ids = let mut children_ids =
vec![mark_node_pool.add(new_left_accolade_mn(expr2_node_id, None))]; vec![
add_node(new_left_accolade_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map)
];
for (idx, field_node_id) in fields.iter_node_ids().enumerate() { for (idx, field_node_id) in fields.iter_node_ids().enumerate() {
let record_field = env.pool.get(field_node_id); let record_field = env.pool.get(field_node_id);
@ -184,6 +211,7 @@ pub fn expr2_to_markup<'a>(
ast_node_id, ast_node_id,
HighlightStyle::RecordField, HighlightStyle::RecordField,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
indent_level, indent_level,
)); ));
@ -191,7 +219,9 @@ pub fn expr2_to_markup<'a>(
RecordField::InvalidLabelOnly(_, _) => (), RecordField::InvalidLabelOnly(_, _) => (),
RecordField::LabelOnly(_, _, _) => (), RecordField::LabelOnly(_, _, _) => (),
RecordField::LabeledValue(_, _, sub_expr2_node_id) => { RecordField::LabeledValue(_, _, sub_expr2_node_id) => {
children_ids.push(mark_node_pool.add(new_colon_mn(expr2_node_id, None))); children_ids.push(
add_node(new_colon_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map)
);
let sub_expr2 = env.pool.get(*sub_expr2_node_id); let sub_expr2 = env.pool.get(*sub_expr2_node_id);
children_ids.push(expr2_to_markup( children_ids.push(expr2_to_markup(
@ -199,6 +229,7 @@ pub fn expr2_to_markup<'a>(
sub_expr2, sub_expr2,
*sub_expr2_node_id, *sub_expr2_node_id,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
interns, interns,
indent_level, indent_level,
)?); )?);
@ -206,22 +237,25 @@ pub fn expr2_to_markup<'a>(
} }
if idx + 1 < fields.len() { if idx + 1 < fields.len() {
children_ids.push(mark_node_pool.add(new_comma_mn(expr2_node_id, None))); children_ids.push(
add_node(new_comma_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map)
);
} }
} }
children_ids.push(mark_node_pool.add(new_right_accolade_mn(expr2_node_id, None))); children_ids.push(
add_node(new_right_accolade_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map)
);
let record_node = MarkupNode::Nested { let record_mn = MarkupNode::Nested {
ast_node_id,
children_ids, children_ids,
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
mark_node_pool.add(record_node) add_node(record_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
Expr2::Blank => mark_node_pool.add(new_blank_mn(ast_node_id, None)), Expr2::Blank => add_node(new_blank_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map),
Expr2::LetValue { Expr2::LetValue {
def_id, def_id,
body_id: _, body_id: _,
@ -235,16 +269,15 @@ pub fn expr2_to_markup<'a>(
let val_name_mn = MarkupNode::Text { let val_name_mn = MarkupNode::Text {
content: val_name, content: val_name,
ast_node_id,
syn_high_style: HighlightStyle::Value, syn_high_style: HighlightStyle::Value,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
let val_name_mn_id = mark_node_pool.add(val_name_mn); let val_name_mn_id = add_node(val_name_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map);
let equals_mn_id = mark_node_pool.add(new_equals_mn(ast_node_id, None)); let equals_mn_id = add_node(new_equals_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let value_def = env.pool.get(*def_id); let value_def = env.pool.get(*def_id);
@ -259,6 +292,7 @@ pub fn expr2_to_markup<'a>(
env.pool.get(*expr_id), env.pool.get(*expr_id),
*expr_id, *expr_id,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
interns, interns,
indent_level, indent_level,
)?; )?;
@ -266,14 +300,13 @@ pub fn expr2_to_markup<'a>(
let body_mn = mark_node_pool.get_mut(body_mn_id); let body_mn = mark_node_pool.get_mut(body_mn_id);
body_mn.add_newline_at_end(); body_mn.add_newline_at_end();
let full_let_node = MarkupNode::Nested { let full_let_mn = MarkupNode::Nested {
ast_node_id,
children_ids: vec![val_name_mn_id, equals_mn_id, body_mn_id], children_ids: vec![val_name_mn_id, equals_mn_id, body_mn_id],
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 1, newlines_at_end: 1,
}; };
mark_node_pool.add(full_let_node) add_node(full_let_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
other => { other => {
unimplemented!( unimplemented!(
@ -291,8 +324,8 @@ pub fn expr2_to_markup<'a>(
body_id, body_id,
extra: _, extra: _,
} => { } => {
let backslash_mn = new_operator_mn("\\".to_string(), expr2_node_id, None); let backslash_mn = new_operator_mn("\\".to_string());
let backslash_mn_id = mark_node_pool.add(backslash_mn); let backslash_mn_id = add_node(backslash_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map);
let arg_names: Vec<&str> = args let arg_names: Vec<&str> = args
.iter(env.pool) .iter(env.pool)
@ -320,31 +353,32 @@ pub fn expr2_to_markup<'a>(
let arg_mark_nodes = arg_names let arg_mark_nodes = arg_names
.iter() .iter()
.map(|arg_name| new_arg_name_mn(arg_name.to_string(), expr2_node_id)) .map(|arg_name| new_arg_name_mn(arg_name.to_string()))
.collect_vec(); .collect_vec();
let args_with_commas: Vec<MarkupNode> = let args_with_commas: Vec<MarkupNode> =
join_mark_nodes_commas(arg_mark_nodes, ASTNodeId::AExprId(expr2_node_id)); join_mark_nodes_commas(arg_mark_nodes);
let mut args_with_commas_ids: Vec<MarkNodeId> = args_with_commas let mut args_with_commas_ids: Vec<MarkNodeId> = args_with_commas
.into_iter() .into_iter()
.map(|mark_node| mark_node_pool.add(mark_node)) .map(|mark_node| {
add_node(mark_node, ast_node_id, mark_node_pool, mark_id_ast_id_map)
})
.collect(); .collect();
let arrow_mn = new_arrow_mn(ASTNodeId::AExprId(expr2_node_id), 1); let arrow_mn = new_arrow_mn(1);
let arrow_mn_id = mark_node_pool.add(arrow_mn); let arrow_mn_id = add_node(arrow_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map);
let mut children_ids = vec![backslash_mn_id]; let mut children_ids = vec![backslash_mn_id];
children_ids.append(&mut args_with_commas_ids); children_ids.append(&mut args_with_commas_ids);
children_ids.push(arrow_mn_id); children_ids.push(arrow_mn_id);
let args_mn = MarkupNode::Nested { let args_mn = MarkupNode::Nested {
ast_node_id: ASTNodeId::AExprId(expr2_node_id),
children_ids, children_ids,
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
let args_mn_id = mark_node_pool.add(args_mn); let args_mn_id = add_node(args_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map);
let body_expr = env.pool.get(*body_id); let body_expr = env.pool.get(*body_id);
let body_mn_id = expr2_to_markup( let body_mn_id = expr2_to_markup(
@ -352,24 +386,25 @@ pub fn expr2_to_markup<'a>(
body_expr, body_expr,
*body_id, *body_id,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
interns, interns,
indent_level + 1, indent_level + 1,
)?; )?;
let function_node = MarkupNode::Nested { let function_mn = MarkupNode::Nested {
ast_node_id,
children_ids: vec![args_mn_id, body_mn_id], children_ids: vec![args_mn_id, body_mn_id],
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
mark_node_pool.add(function_node) add_node(function_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
Expr2::RuntimeError() => new_markup_node( Expr2::RuntimeError() => new_markup_node(
"RunTimeError".to_string(), "RunTimeError".to_string(),
ast_node_id, ast_node_id,
HighlightStyle::Blank, HighlightStyle::Blank,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
indent_level, indent_level,
), ),
rest => todo!("implement expr2_to_markup for {:?}", rest), rest => todo!("implement expr2_to_markup for {:?}", rest),
@ -392,12 +427,14 @@ fn string_mark_node(
indent_level: usize, indent_level: usize,
ast_node_id: ASTNodeId, ast_node_id: ASTNodeId,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap,
) -> MarkNodeId { ) -> MarkNodeId {
new_markup_node( new_markup_node(
with_indent(indent_level, content), with_indent(indent_level, content),
ast_node_id, ast_node_id,
HighlightStyle::String, HighlightStyle::String,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
indent_level, indent_level,
) )
} }

86
code_markup/src/markup/convert/from_header.rs
View file

@ -1,4 +1,4 @@
use roc_ast::lang::core::{ast::ASTNodeId, expr::expr2::ExprId, header::AppHeader}; use roc_ast::lang::core::{ast::ASTNodeId, header::AppHeader};
use crate::{ use crate::{
markup::{ markup::{
@ -8,53 +8,57 @@ use crate::{
new_right_square_mn, new_right_square_mn,
}, },
nodes::{set_parent_for_all, MarkupNode}, nodes::{set_parent_for_all, MarkupNode},
mark_id_ast_id_map::MarkIdAstIdMap
}, },
slow_pool::{MarkNodeId, SlowPool}, slow_pool::{MarkNodeId, SlowPool},
syntax_highlight::HighlightStyle, syntax_highlight::HighlightStyle,
}; };
pub fn header_to_markup(app_header: &AppHeader, mark_node_pool: &mut SlowPool) -> MarkNodeId { use super::from_def2::add_node;
pub fn header_to_markup(app_header: &AppHeader, mark_node_pool: &mut SlowPool, mark_id_ast_id_map: &mut MarkIdAstIdMap) -> MarkNodeId {
let expr_id = app_header.ast_node_id; let expr_id = app_header.ast_node_id;
let ast_node_id = ASTNodeId::AExprId(expr_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_node_id = header_mn("app ".to_owned(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let app_name_node_id = header_val_mn( let app_name_node_id = header_val_mn(
app_header.app_name.clone(), app_header.app_name.clone(),
expr_id, ast_node_id,
HighlightStyle::String, HighlightStyle::String,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map
); );
let full_app_node = MarkupNode::Nested { let full_app_node = MarkupNode::Nested {
ast_node_id,
children_ids: vec![app_node_id, app_name_node_id], children_ids: vec![app_node_id, app_name_node_id],
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 1, newlines_at_end: 1,
}; };
let packages_node_id = header_mn(" packages ".to_owned(), expr_id, mark_node_pool); let packages_node_id = header_mn(" packages ".to_owned(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let pack_left_acc_node_id = mark_node_pool.add(new_left_accolade_mn(expr_id, None)); let pack_left_acc_node_id = add_node(new_left_accolade_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let pack_base_node_id = header_val_mn( let pack_base_node_id = header_val_mn(
"base: ".to_owned(), "base: ".to_owned(),
expr_id, ast_node_id,
HighlightStyle::RecordField, HighlightStyle::RecordField,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map
); );
let pack_val_node_id = header_val_mn( let pack_val_node_id = header_val_mn(
app_header.packages_base.clone(), app_header.packages_base.clone(),
expr_id, ast_node_id,
HighlightStyle::String, HighlightStyle::String,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map
); );
let pack_right_acc_node_id = mark_node_pool.add(new_right_accolade_mn(expr_id, None)); let pack_right_acc_node_id = add_node(new_right_accolade_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let full_packages_node = MarkupNode::Nested { let full_packages_node = MarkupNode::Nested {
ast_node_id,
children_ids: vec![ children_ids: vec![
packages_node_id, packages_node_id,
pack_left_acc_node_id, pack_left_acc_node_id,
@ -66,18 +70,19 @@ pub fn header_to_markup(app_header: &AppHeader, mark_node_pool: &mut SlowPool) -
newlines_at_end: 1, newlines_at_end: 1,
}; };
let imports_node_id = header_mn(" imports ".to_owned(), expr_id, mark_node_pool); let imports_node_id = header_mn(" imports ".to_owned(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let imports_left_square_node_id = mark_node_pool.add(new_left_square_mn(expr_id, None)); let imports_left_square_node_id = add_node(new_left_square_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let mut import_child_ids: Vec<MarkNodeId> = add_header_mn_list( let mut import_child_ids: Vec<MarkNodeId> = add_header_mn_list(
&app_header.imports, &app_header.imports,
expr_id, ast_node_id,
HighlightStyle::Import, HighlightStyle::Import,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
); );
let imports_right_square_node_id = mark_node_pool.add(new_right_square_mn(expr_id, None)); let imports_right_square_node_id = add_node(new_right_square_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let mut full_import_children = vec![imports_node_id, imports_left_square_node_id]; let mut full_import_children = vec![imports_node_id, imports_left_square_node_id];
@ -85,26 +90,26 @@ pub fn header_to_markup(app_header: &AppHeader, mark_node_pool: &mut SlowPool) -
full_import_children.push(imports_right_square_node_id); full_import_children.push(imports_right_square_node_id);
let full_import_node = MarkupNode::Nested { let full_import_node = MarkupNode::Nested {
ast_node_id,
children_ids: full_import_children, children_ids: full_import_children,
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 1, newlines_at_end: 1,
}; };
let provides_node_id = header_mn(" provides ".to_owned(), expr_id, mark_node_pool); let provides_node_id = header_mn(" provides ".to_owned(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let provides_left_square_node_id = mark_node_pool.add(new_left_square_mn(expr_id, None)); let provides_left_square_node_id = add_node(new_left_square_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let mut provides_val_node_ids: Vec<MarkNodeId> = add_header_mn_list( let mut provides_val_node_ids: Vec<MarkNodeId> = add_header_mn_list(
&app_header.provides, &app_header.provides,
expr_id, ast_node_id,
HighlightStyle::Provides, HighlightStyle::Provides,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
); );
let provides_right_square_node_id = mark_node_pool.add(new_right_square_mn(expr_id, None)); let provides_right_square_node_id = add_node(new_right_square_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let provides_end_node_id = header_mn(" to base".to_owned(), expr_id, mark_node_pool); let provides_end_node_id = header_mn(" to base".to_owned(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let mut full_provides_children = vec![provides_node_id, provides_left_square_node_id]; let mut full_provides_children = vec![provides_node_id, provides_left_square_node_id];
@ -113,19 +118,17 @@ pub fn header_to_markup(app_header: &AppHeader, mark_node_pool: &mut SlowPool) -
full_provides_children.push(provides_end_node_id); full_provides_children.push(provides_end_node_id);
let full_provides_node = MarkupNode::Nested { let full_provides_node = MarkupNode::Nested {
ast_node_id,
children_ids: full_provides_children, children_ids: full_provides_children,
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 1, newlines_at_end: 1,
}; };
let full_app_node_id = mark_node_pool.add(full_app_node); let full_app_node_id = add_node(full_app_node, ast_node_id, mark_node_pool, mark_id_ast_id_map);
let full_packages_node = mark_node_pool.add(full_packages_node); let full_packages_node = add_node(full_packages_node, ast_node_id, mark_node_pool, mark_id_ast_id_map);
let full_import_node_id = mark_node_pool.add(full_import_node); let full_import_node_id = add_node(full_import_node, ast_node_id, mark_node_pool, mark_id_ast_id_map);
let full_provides_node_id = mark_node_pool.add(full_provides_node); let full_provides_node_id = add_node(full_provides_node, ast_node_id, mark_node_pool, mark_id_ast_id_map);
let header_mark_node = MarkupNode::Nested { let header_mark_node = MarkupNode::Nested {
ast_node_id,
children_ids: vec![ children_ids: vec![
full_app_node_id, full_app_node_id,
full_packages_node, full_packages_node,
@ -136,7 +139,7 @@ pub fn header_to_markup(app_header: &AppHeader, mark_node_pool: &mut SlowPool) -
newlines_at_end: 1, newlines_at_end: 1,
}; };
let header_mn_id = mark_node_pool.add(header_mark_node); let header_mn_id = add_node(header_mark_node, ast_node_id, mark_node_pool, mark_id_ast_id_map);
set_parent_for_all(header_mn_id, mark_node_pool); set_parent_for_all(header_mn_id, mark_node_pool);
@ -146,9 +149,10 @@ pub fn header_to_markup(app_header: &AppHeader, mark_node_pool: &mut SlowPool) -
// Used for provides and imports // Used for provides and imports
fn add_header_mn_list( fn add_header_mn_list(
str_vec: &[String], str_vec: &[String],
expr_id: ExprId, ast_node_id: ASTNodeId,
highlight_style: HighlightStyle, highlight_style: HighlightStyle,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap,
) -> Vec<MarkNodeId> { ) -> Vec<MarkNodeId> {
let nr_of_elts = str_vec.len(); let nr_of_elts = str_vec.len();
@ -158,13 +162,17 @@ fn add_header_mn_list(
.map(|(indx, provide_str)| { .map(|(indx, provide_str)| {
let provide_str = header_val_mn( let provide_str = header_val_mn(
provide_str.to_owned(), provide_str.to_owned(),
expr_id, ast_node_id,
highlight_style, highlight_style,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
); );
if indx != nr_of_elts - 1 { if indx != nr_of_elts - 1 {
vec![provide_str, mark_node_pool.add(new_comma_mn(expr_id, None))] vec![
provide_str,
add_node(new_comma_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map)
]
} else { } else {
vec![provide_str] vec![provide_str]
} }
@ -173,33 +181,37 @@ fn add_header_mn_list(
.collect() .collect()
} }
fn header_mn(content: String, expr_id: ExprId, mark_node_pool: &mut SlowPool) -> MarkNodeId { fn header_mn(
content: String,
ast_node_id: ASTNodeId,
mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap
) -> MarkNodeId {
let mark_node = MarkupNode::Text { let mark_node = MarkupNode::Text {
content, content,
ast_node_id: ASTNodeId::AExprId(expr_id),
syn_high_style: HighlightStyle::PackageRelated, syn_high_style: HighlightStyle::PackageRelated,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
mark_node_pool.add(mark_node) add_node(mark_node, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }
fn header_val_mn( fn header_val_mn(
content: String, content: String,
expr_id: ExprId, ast_node_id: ASTNodeId,
highlight_style: HighlightStyle, highlight_style: HighlightStyle,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap,
) -> MarkNodeId { ) -> MarkNodeId {
let mark_node = MarkupNode::Text { let mark_node = MarkupNode::Text {
content, content,
ast_node_id: ASTNodeId::AExprId(expr_id),
syn_high_style: highlight_style, syn_high_style: highlight_style,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
mark_node_pool.add(mark_node) add_node(mark_node, ast_node_id, mark_node_pool, mark_id_ast_id_map)
} }

34
code_markup/src/markup/mark_id_ast_id_map.rs Normal file
View file

@ -0,0 +1,34 @@
use std::collections::HashMap;
use roc_ast::lang::core::ast::ASTNodeId;
use crate::{slow_pool::MarkNodeId, markup_error::MarkResult};
use crate::markup_error::MarkNodeIdWithoutCorrespondingASTNodeId;
/// A hashmap is wrapped to allow for an easy swap out with more performant alternatives
#[derive(Debug)]
pub struct MarkIdAstIdMap{
map: HashMap<MarkNodeId, ASTNodeId>
}
impl MarkIdAstIdMap {
pub fn insert(&mut self, mn_id: MarkNodeId, ast_id: ASTNodeId) {
self.map.insert(mn_id, ast_id);
}
pub fn get(&self, mn_id: MarkNodeId) -> MarkResult<ASTNodeId> {
match self.map.get(&mn_id) {
Some(ast_node_id) => Ok(*ast_node_id),
None => MarkNodeIdWithoutCorrespondingASTNodeId { node_id: mn_id, keys_str: format!("{:?}", self.map.keys()) }.fail()
}
}
}
impl Default for MarkIdAstIdMap {
fn default() -> Self {
Self {
map: HashMap::new()
}
}
}

1
code_markup/src/markup/mod.rs
View file

@ -3,3 +3,4 @@ pub mod common_nodes;
pub mod convert; pub mod convert;
pub mod nodes; pub mod nodes;
pub mod top_level_def; pub mod top_level_def;
pub mod mark_id_ast_id_map;

45
code_markup/src/markup/nodes.rs
View file

@ -4,7 +4,7 @@ use crate::{
syntax_highlight::HighlightStyle, syntax_highlight::HighlightStyle,
}; };
use super::{attribute::Attributes, common_nodes::new_comma_mn_ast}; use super::{attribute::Attributes, common_nodes::new_comma_mn, mark_id_ast_id_map::{MarkIdAstIdMap}, convert::from_def2::add_node};
use crate::markup_error::{ExpectedTextNode, NestedNodeMissingChild, NestedNodeRequired}; use crate::markup_error::{ExpectedTextNode, NestedNodeMissingChild, NestedNodeRequired};
use itertools::Itertools; use itertools::Itertools;
@ -18,42 +18,29 @@ use std::fmt;
#[derive(Debug)] #[derive(Debug)]
pub enum MarkupNode { pub enum MarkupNode {
Nested { Nested {
ast_node_id: ASTNodeId,
children_ids: Vec<MarkNodeId>, children_ids: Vec<MarkNodeId>,
parent_id_opt: Option<MarkNodeId>, parent_id_opt: Option<MarkNodeId>,
newlines_at_end: usize, newlines_at_end: usize,
}, },
Text { Text {
content: String, content: String,
ast_node_id: ASTNodeId,
syn_high_style: HighlightStyle, syn_high_style: HighlightStyle,
attributes: Attributes, attributes: Attributes,
parent_id_opt: Option<MarkNodeId>, parent_id_opt: Option<MarkNodeId>,
newlines_at_end: usize, newlines_at_end: usize,
}, },
Blank { Blank {
ast_node_id: ASTNodeId,
attributes: Attributes, attributes: Attributes,
parent_id_opt: Option<MarkNodeId>, parent_id_opt: Option<MarkNodeId>,
newlines_at_end: usize, newlines_at_end: usize,
}, },
Indent { Indent {
ast_node_id: ASTNodeId,
indent_level: usize, indent_level: usize,
parent_id_opt: Option<MarkNodeId>, parent_id_opt: Option<MarkNodeId>,
}, },
} }
impl MarkupNode { impl MarkupNode {
pub fn get_ast_node_id(&self) -> ASTNodeId {
match self {
MarkupNode::Nested { ast_node_id, .. } => *ast_node_id,
MarkupNode::Text { ast_node_id, .. } => *ast_node_id,
MarkupNode::Blank { ast_node_id, .. } => *ast_node_id,
MarkupNode::Indent { ast_node_id, .. } => *ast_node_id,
}
}
pub fn get_parent_id_opt(&self) -> Option<MarkNodeId> { pub fn get_parent_id_opt(&self) -> Option<MarkNodeId> {
match self { match self {
MarkupNode::Nested { parent_id_opt, .. } => *parent_id_opt, MarkupNode::Nested { parent_id_opt, .. } => *parent_id_opt,
@ -85,24 +72,24 @@ impl MarkupNode {
// return (index of child in list of children, closest ast index of child corresponding to ast node) // return (index of child in list of children, closest ast index of child corresponding to ast node)
pub fn get_child_indices( pub fn get_child_indices(
&self, &self,
child_id: MarkNodeId, mark_node_id: MarkNodeId,
mark_node_pool: &SlowPool, ast_node_id: ASTNodeId,
mark_id_ast_id_map: &MarkIdAstIdMap
) -> MarkResult<(usize, usize)> { ) -> MarkResult<(usize, usize)> {
match self { match self {
MarkupNode::Nested { children_ids, .. } => { MarkupNode::Nested { children_ids, .. } => {
let mut mark_child_index_opt: Option<usize> = None; let mut mark_child_index_opt: Option<usize> = None;
let mut child_ids_with_ast: Vec<MarkNodeId> = Vec::new(); let mut child_ids_with_ast: Vec<MarkNodeId> = Vec::new();
let self_ast_id = self.get_ast_node_id();
for (indx, &mark_child_id) in children_ids.iter().enumerate() { for (indx, &mark_child_id) in children_ids.iter().enumerate() {
if mark_child_id == child_id { if mark_child_id == mark_node_id {
mark_child_index_opt = Some(indx); mark_child_index_opt = Some(indx);
} }
let child_mark_node = mark_node_pool.get(mark_child_id); let child_ast_node_id = mark_id_ast_id_map.get(mark_child_id)?;
// a node that points to the same ast_node as the parent is a ',', '[', ']' // a node that points to the same ast_node as the parent is a ',', '[', ']'
// those are not "real" ast children // those are not "real" ast children
if child_mark_node.get_ast_node_id() != self_ast_id { if child_ast_node_id != ast_node_id {
child_ids_with_ast.push(mark_child_id) child_ids_with_ast.push(mark_child_id)
} }
} }
@ -145,7 +132,7 @@ impl MarkupNode {
} }
} else { } else {
NestedNodeMissingChild { NestedNodeMissingChild {
node_id: child_id, node_id: mark_node_id,
children_ids: children_ids.clone(), children_ids: children_ids.clone(),
} }
.fail() .fail()
@ -279,36 +266,34 @@ pub fn new_markup_node(
node_id: ASTNodeId, node_id: ASTNodeId,
highlight_style: HighlightStyle, highlight_style: HighlightStyle,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap,
indent_level: usize, indent_level: usize,
) -> MarkNodeId { ) -> MarkNodeId {
let content_node = MarkupNode::Text { let content_node = MarkupNode::Text {
content: text, content: text,
ast_node_id: node_id,
syn_high_style: highlight_style, syn_high_style: highlight_style,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
let content_node_id = mark_node_pool.add(content_node); let content_node_id = add_node(content_node, node_id, mark_node_pool, mark_id_ast_id_map);
if indent_level > 0 { if indent_level > 0 {
let indent_node = MarkupNode::Indent { let indent_node = MarkupNode::Indent {
ast_node_id: node_id,
indent_level, indent_level,
parent_id_opt: None, parent_id_opt: None,
}; };
let indent_node_id = mark_node_pool.add(indent_node); let indent_node_id = add_node(indent_node, node_id, mark_node_pool, mark_id_ast_id_map);
let nested_node = MarkupNode::Nested { let nested_node = MarkupNode::Nested {
ast_node_id: node_id,
children_ids: vec![indent_node_id, content_node_id], children_ids: vec![indent_node_id, content_node_id],
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
mark_node_pool.add(nested_node) add_node(nested_node, node_id, mark_node_pool, mark_id_ast_id_map)
} else { } else {
content_node_id content_node_id
} }
@ -318,7 +303,6 @@ pub fn set_parent_for_all(markup_node_id: MarkNodeId, mark_node_pool: &mut SlowP
let node = mark_node_pool.get(markup_node_id); let node = mark_node_pool.get(markup_node_id);
if let MarkupNode::Nested { if let MarkupNode::Nested {
ast_node_id: _,
children_ids, children_ids,
parent_id_opt: _, parent_id_opt: _,
newlines_at_end: _, newlines_at_end: _,
@ -426,7 +410,6 @@ pub fn get_root_mark_node_id(mark_node_id: MarkNodeId, mark_node_pool: &SlowPool
pub fn join_mark_nodes_spaces( pub fn join_mark_nodes_spaces(
mark_nodes_ids: Vec<MarkNodeId>, mark_nodes_ids: Vec<MarkNodeId>,
with_prepend: bool, with_prepend: bool,
ast_node_id: ASTNodeId,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
) -> Vec<MarkNodeId> { ) -> Vec<MarkNodeId> {
let space_range_max = if with_prepend { let space_range_max = if with_prepend {
@ -439,7 +422,6 @@ pub fn join_mark_nodes_spaces(
.map(|_| { .map(|_| {
let space_node = MarkupNode::Text { let space_node = MarkupNode::Text {
content: " ".to_string(), content: " ".to_string(),
ast_node_id,
syn_high_style: HighlightStyle::Blank, syn_high_style: HighlightStyle::Blank,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,
@ -460,10 +442,9 @@ pub fn join_mark_nodes_spaces(
// put comma mark nodes between each node in mark_nodes // put comma mark nodes between each node in mark_nodes
pub fn join_mark_nodes_commas( pub fn join_mark_nodes_commas(
mark_nodes: Vec<MarkupNode>, mark_nodes: Vec<MarkupNode>,
ast_node_id: ASTNodeId,
) -> Vec<MarkupNode> { ) -> Vec<MarkupNode> {
let join_nodes: Vec<MarkupNode> = (0..(mark_nodes.len() - 1)) let join_nodes: Vec<MarkupNode> = (0..(mark_nodes.len() - 1))
.map(|_| new_comma_mn_ast(ast_node_id, None)) .map(|_| new_comma_mn())
.collect(); .collect();
mark_nodes.into_iter().interleave(join_nodes).collect() mark_nodes.into_iter().interleave(join_nodes).collect()

18
code_markup/src/markup/top_level_def.rs
View file

@ -14,31 +14,32 @@ use crate::{
syntax_highlight::HighlightStyle, syntax_highlight::HighlightStyle,
}; };
use super::{mark_id_ast_id_map::MarkIdAstIdMap, convert::from_def2::add_node};
// Top Level Defined Value. example: `main = "Hello, World!"` // Top Level Defined Value. example: `main = "Hello, World!"`
pub fn tld_mark_node<'a>( pub fn tld_mark_node<'a>(
identifier_id: IdentId, identifier_id: IdentId,
expr_mark_node_id: MarkNodeId, expr_mark_node_id: MarkNodeId,
ast_node_id: ASTNodeId, ast_node_id: ASTNodeId,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap,
env: &Env<'a>, env: &Env<'a>,
) -> ASTResult<MarkupNode> { ) -> ASTResult<MarkupNode> {
let val_name = env.ident_ids.get_name_str_res(identifier_id)?; let val_name = env.ident_ids.get_name_str_res(identifier_id)?;
let val_name_mn = MarkupNode::Text { let val_name_mn = MarkupNode::Text {
content: val_name.to_owned(), content: val_name.to_owned(),
ast_node_id,
syn_high_style: HighlightStyle::Value, syn_high_style: HighlightStyle::Value,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 0, newlines_at_end: 0,
}; };
let val_name_mn_id = mark_node_pool.add(val_name_mn); let val_name_mn_id = add_node(val_name_mn, ast_node_id, mark_node_pool, mark_id_ast_id_map);
let equals_mn_id = mark_node_pool.add(new_equals_mn(ast_node_id, None)); let equals_mn_id = add_node(new_equals_mn(), ast_node_id, mark_node_pool, mark_id_ast_id_map);
let full_let_node = MarkupNode::Nested { let full_let_node = MarkupNode::Nested {
ast_node_id,
children_ids: vec![val_name_mn_id, equals_mn_id, expr_mark_node_id], children_ids: vec![val_name_mn_id, equals_mn_id, expr_mark_node_id],
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 3, newlines_at_end: 3,
@ -52,9 +53,15 @@ pub fn tld_w_comments_mark_node(
def_mark_node_id: MarkNodeId, def_mark_node_id: MarkNodeId,
ast_node_id: ASTNodeId, ast_node_id: ASTNodeId,
mark_node_pool: &mut SlowPool, mark_node_pool: &mut SlowPool,
mark_id_ast_id_map: &mut MarkIdAstIdMap,
comments_before: bool, comments_before: bool,
) -> ASTResult<MarkupNode> { ) -> ASTResult<MarkupNode> {
let comment_mn_id = mark_node_pool.add(new_comments_mn(comments, ast_node_id, 1)); let comment_mn_id = add_node(
new_comments_mn(comments, 1),
ast_node_id,
mark_node_pool,
mark_id_ast_id_map
);
let children_ids = if comments_before { let children_ids = if comments_before {
vec![comment_mn_id, def_mark_node_id] vec![comment_mn_id, def_mark_node_id]
@ -63,7 +70,6 @@ pub fn tld_w_comments_mark_node(
}; };
let tld_w_comment_node = MarkupNode::Nested { let tld_w_comment_node = MarkupNode::Nested {
ast_node_id,
children_ids, children_ids,
parent_id_opt: None, parent_id_opt: None,
newlines_at_end: 2, newlines_at_end: 2,

10
code_markup/src/markup_error.rs
View file

@ -24,6 +24,16 @@ pub enum MarkError {
node_type: String, node_type: String,
backtrace: Backtrace, backtrace: Backtrace,
}, },
#[snafu(display(
"MarkNodeIdWithoutCorrespondingASTNodeId: MarkupNode with id {} was not found in MarkIdAstIdMap, available keys are: {}.",
node_id,
keys_str
))]
MarkNodeIdWithoutCorrespondingASTNodeId {
node_id: MarkNodeId,
keys_str: String,
backtrace: Backtrace,
},
#[snafu(display("NestedNodeMissingChild: expected to find child with id {} in Nested MarkupNode, but it was missing. Id's of the children are {:?}.", node_id, children_ids))] #[snafu(display("NestedNodeMissingChild: expected to find child with id {} in Nested MarkupNode, but it was missing. Id's of the children are {:?}.", node_id, children_ids))]
NestedNodeMissingChild { NestedNodeMissingChild {
node_id: MarkNodeId, node_id: MarkNodeId,

39
code_markup/src/slow_pool.rs
View file

@ -1,6 +1,4 @@
use std::fmt; use crate::markup::{nodes::MarkupNode, mark_id_ast_id_map::MarkIdAstIdMap};
use crate::markup::nodes::MarkupNode;
pub type MarkNodeId = usize; pub type MarkNodeId = usize;
@ -34,14 +32,16 @@ impl SlowPool {
// TODO delete children of old node, this requires SlowPool to be changed to // TODO delete children of old node, this requires SlowPool to be changed to
// make sure the indexes still make sense after removal/compaction // make sure the indexes still make sense after removal/compaction
} }
}
impl fmt::Display for SlowPool { pub fn debug_string(&self, mark_id_ast_id_map: &MarkIdAstIdMap) -> String {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { let mut ret_str = String::new();
write!(f, "\n\n(mark_node_pool)\n")?;
for (index, node) in self.nodes.iter().enumerate() { for (mark_node_id, node) in self.nodes.iter().enumerate() {
let ast_node_id_str = format!("{:?}", node.get_ast_node_id()); let ast_node_id_str =
match mark_id_ast_id_map.get(mark_node_id) {
Ok(ast_id) => format!("{:?}", ast_id),
Err(err) => format!("{:?}", err)
};
let ast_node_id: String = ast_node_id_str let ast_node_id: String = ast_node_id_str
.chars() .chars()
.filter(|c| c.is_ascii_digit()) .filter(|c| c.is_ascii_digit())
@ -55,17 +55,18 @@ impl fmt::Display for SlowPool {
child_str = format!("children: {:?}", node_children); child_str = format!("children: {:?}", node_children);
} }
writeln!( ret_str.push_str(
f, &format!(
"{}: {} ({}) ast_id {:?} {}", "{}: {} ({}) ast_id {:?} {}",
index, mark_node_id,
node.node_type_as_string(), node.node_type_as_string(),
node.get_content(), node.get_content(),
ast_node_id.parse::<usize>().unwrap(), ast_node_id.parse::<usize>().unwrap(),
child_str child_str
)?; )
);
} }
Ok(()) ret_str
} }
} }

45
editor/src/editor/grid_node_map.rs
View file

@ -9,6 +9,7 @@ use crate::ui::text::text_pos::TextPos;
use crate::ui::ui_error::{LineInsertionFailed, OutOfBounds, UIResult}; use crate::ui::ui_error::{LineInsertionFailed, OutOfBounds, UIResult};
use crate::ui::util::{slice_get, slice_get_mut}; use crate::ui::util::{slice_get, slice_get_mut};
use roc_ast::lang::core::ast::ASTNodeId; use roc_ast::lang::core::ast::ASTNodeId;
use roc_code_markup::markup::mark_id_ast_id_map::MarkIdAstIdMap;
use roc_code_markup::markup::nodes::get_root_mark_node_id; use roc_code_markup::markup::nodes::get_root_mark_node_id;
use roc_code_markup::slow_pool::MarkNodeId; use roc_code_markup::slow_pool::MarkNodeId;
use roc_code_markup::slow_pool::SlowPool; use roc_code_markup::slow_pool::SlowPool;
@ -210,18 +211,18 @@ impl GridNodeMap {
ed_model: &EdModel, ed_model: &EdModel,
) -> EdResult<(TextPos, TextPos, ASTNodeId, MarkNodeId)> { ) -> EdResult<(TextPos, TextPos, ASTNodeId, MarkNodeId)> {
let line = slice_get(caret_pos.line, &self.lines)?; let line = slice_get(caret_pos.line, &self.lines)?;
let node_id = slice_get(caret_pos.column, line)?; let node_id = *slice_get(caret_pos.column, line)?;
let node = ed_model.mark_node_pool.get(*node_id); let node = ed_model.mark_node_pool.get(node_id);
if node.is_nested() { if node.is_nested() {
let (start_pos, end_pos) = self.get_nested_start_end_pos(*node_id, ed_model)?; let (start_pos, end_pos) = self.get_nested_start_end_pos(node_id, ed_model)?;
Ok((start_pos, end_pos, node.get_ast_node_id(), *node_id)) Ok((start_pos, end_pos, ed_model.mark_id_ast_id_map.get(node_id)?, node_id))
} else { } else {
let (first_node_index, last_node_index) = first_last_index_of(*node_id, line)?; let (first_node_index, last_node_index) = first_last_index_of(node_id, line)?;
let curr_node_id = slice_get(first_node_index, line)?; let curr_node_id = *slice_get(first_node_index, line)?;
let curr_ast_node_id = ed_model.mark_node_pool.get(*curr_node_id).get_ast_node_id(); let curr_ast_node_id = ed_model.mark_id_ast_id_map.get(curr_node_id)?;
let mut expr_start_index = first_node_index; let mut expr_start_index = first_node_index;
let mut expr_end_index = last_node_index; let mut expr_end_index = last_node_index;
@ -230,11 +231,10 @@ impl GridNodeMap {
let mut pos_extra_subtract = 0; let mut pos_extra_subtract = 0;
for i in (0..first_node_index).rev() { for i in (0..first_node_index).rev() {
let prev_pos_node_id = slice_get(i, line)?; let prev_pos_node_id = *slice_get(i, line)?;
let prev_ast_node_id = ed_model let prev_ast_node_id = ed_model
.mark_node_pool .mark_id_ast_id_map
.get(*prev_pos_node_id) .get(prev_pos_node_id)?;
.get_ast_node_id();
if prev_ast_node_id == curr_ast_node_id { if prev_ast_node_id == curr_ast_node_id {
if pos_extra_subtract > 0 { if pos_extra_subtract > 0 {
@ -254,9 +254,8 @@ impl GridNodeMap {
for i in last_node_index..line.len() { for i in last_node_index..line.len() {
let next_pos_node_id = slice_get(i, line)?; let next_pos_node_id = slice_get(i, line)?;
let next_ast_node_id = ed_model let next_ast_node_id = ed_model
.mark_node_pool .mark_id_ast_id_map
.get(*next_pos_node_id) .get(*next_pos_node_id)?;
.get_ast_node_id();
if next_ast_node_id == curr_ast_node_id { if next_ast_node_id == curr_ast_node_id {
if pos_extra_add > 0 { if pos_extra_add > 0 {
@ -271,7 +270,7 @@ impl GridNodeMap {
} }
let correct_mark_node_id = let correct_mark_node_id =
GridNodeMap::get_top_node_with_expr_id(*curr_node_id, &ed_model.mark_node_pool); GridNodeMap::get_top_node_with_expr_id(curr_node_id, &ed_model.mark_node_pool, &ed_model.mark_id_ast_id_map)?;
Ok(( Ok((
TextPos { TextPos {
@ -293,19 +292,18 @@ impl GridNodeMap {
fn get_top_node_with_expr_id( fn get_top_node_with_expr_id(
curr_node_id: MarkNodeId, curr_node_id: MarkNodeId,
mark_node_pool: &SlowPool, mark_node_pool: &SlowPool,
) -> MarkNodeId { mark_id_ast_id_map: &MarkIdAstIdMap,
) -> EdResult<MarkNodeId> {
let curr_node = mark_node_pool.get(curr_node_id); let curr_node = mark_node_pool.get(curr_node_id);
if let Some(parent_id) = curr_node.get_parent_id_opt() { if let Some(parent_id) = curr_node.get_parent_id_opt() {
let parent = mark_node_pool.get(parent_id); if mark_id_ast_id_map.get(parent_id)? == mark_id_ast_id_map.get(curr_node_id)? {
Ok(parent_id)
if parent.get_ast_node_id() == curr_node.get_ast_node_id() {
parent_id
} else { } else {
curr_node_id Ok(curr_node_id)
} }
} else { } else {
curr_node_id Ok(curr_node_id)
} }
} }
@ -388,6 +386,7 @@ impl GridNodeMap {
&self, &self,
line_nr: usize, line_nr: usize,
mark_node_pool: &SlowPool, mark_node_pool: &SlowPool,
mark_id_ast_id_map: &MarkIdAstIdMap,
) -> EdResult<MarkNodeId> { ) -> EdResult<MarkNodeId> {
for curr_line_nr in (0..line_nr).rev() { for curr_line_nr in (0..line_nr).rev() {
let first_col_pos = TextPos { let first_col_pos = TextPos {
@ -399,7 +398,7 @@ impl GridNodeMap {
let mark_node_id = self.get_id_at_row_col(first_col_pos)?; let mark_node_id = self.get_id_at_row_col(first_col_pos)?;
let root_mark_node_id = get_root_mark_node_id(mark_node_id, mark_node_pool); let root_mark_node_id = get_root_mark_node_id(mark_node_id, mark_node_pool);
let ast_node_id = mark_node_pool.get(root_mark_node_id).get_ast_node_id(); let ast_node_id = mark_id_ast_id_map.get(root_mark_node_id)?;
if let ASTNodeId::ADefId(_) = ast_node_id { if let ASTNodeId::ADefId(_) = ast_node_id {
return Ok(root_mark_node_id); return Ok(root_mark_node_id);

2
editor/src/editor/mvc/break_line.rs
View file

@ -52,7 +52,7 @@ pub fn insert_new_blank(ed_model: &mut EdModel, insert_on_line_nr: usize) -> EdR
// find position of the previous ASTNode to figure out where to add this new Blank ASTNode // find position of the previous ASTNode to figure out where to add this new Blank ASTNode
let def_mark_node_id = ed_model let def_mark_node_id = ed_model
.grid_node_map .grid_node_map
.get_def_mark_node_id_before_line(insert_on_line_nr, &ed_model.mark_node_pool)?; .get_def_mark_node_id_before_line(insert_on_line_nr, &ed_model.mark_node_pool, &ed_model.mark_id_ast_id_map)?;
let new_line_blank = Def2::Blank; let new_line_blank = Def2::Blank;
let new_line_blank_id = ed_model.module.env.pool.add(new_line_blank); let new_line_blank_id = ed_model.module.env.pool.add(new_line_blank);

8
editor/src/editor/mvc/ed_model.rs
View file

@ -16,6 +16,7 @@ use roc_ast::lang::env::Env;
use roc_ast::mem_pool::pool_str::PoolStr; use roc_ast::mem_pool::pool_str::PoolStr;
use roc_ast::parse::parse_ast; use roc_ast::parse::parse_ast;
use roc_code_markup::markup::convert::from_ast::ast_to_mark_nodes; use roc_code_markup::markup::convert::from_ast::ast_to_mark_nodes;
use roc_code_markup::markup::mark_id_ast_id_map::MarkIdAstIdMap;
use roc_code_markup::markup::nodes; use roc_code_markup::markup::nodes;
use roc_code_markup::slow_pool::{MarkNodeId, SlowPool}; use roc_code_markup::slow_pool::{MarkNodeId, SlowPool};
use roc_load::file::LoadedModule; use roc_load::file::LoadedModule;
@ -31,6 +32,7 @@ pub struct EdModel<'a> {
pub grid_node_map: GridNodeMap, // allows us to map window coordinates to MarkNodeId's pub grid_node_map: GridNodeMap, // allows us to map window coordinates to MarkNodeId's
pub markup_ids: Vec<MarkNodeId>, // one root node for every top level definition pub markup_ids: Vec<MarkNodeId>, // one root node for every top level definition
pub mark_node_pool: SlowPool, // all MarkupNodes for this file are saved into this pool and can be retrieved using their MarkNodeId pub mark_node_pool: SlowPool, // all MarkupNodes for this file are saved into this pool and can be retrieved using their MarkNodeId
pub mark_id_ast_id_map: MarkIdAstIdMap, // To find the ASTNode that is represented by a MarkNode
pub glyph_dim_rect_opt: Option<Rect>, // represents the width and height of single monospace glyph(char) pub glyph_dim_rect_opt: Option<Rect>, // represents the width and height of single monospace glyph(char)
pub has_focus: bool, pub has_focus: bool,
pub caret_w_select_vec: NonEmpty<(CaretWSelect, Option<MarkNodeId>)>, // the editor supports multiple carets/cursors and multiple selections pub caret_w_select_vec: NonEmpty<(CaretWSelect, Option<MarkNodeId>)>, // the editor supports multiple carets/cursors and multiple selections
@ -64,7 +66,7 @@ pub fn init_model<'a>(
let mut mark_node_pool = SlowPool::default(); let mut mark_node_pool = SlowPool::default();
let markup_ids = if code_str.is_empty() { let (markup_ids, mark_id_ast_id_map) = if code_str.is_empty() {
EmptyCodeString {}.fail() EmptyCodeString {}.fail()
} else { } else {
Ok(ast_to_mark_nodes( Ok(ast_to_mark_nodes(
@ -107,6 +109,7 @@ pub fn init_model<'a>(
grid_node_map, grid_node_map,
markup_ids, markup_ids,
mark_node_pool, mark_node_pool,
mark_id_ast_id_map,
glyph_dim_rect_opt: None, glyph_dim_rect_opt: None,
has_focus: true, has_focus: true,
caret_w_select_vec: NonEmpty::new((caret, None)), caret_w_select_vec: NonEmpty::new((caret, None)),
@ -160,7 +163,8 @@ impl<'a> EdModel<'a> {
if let Some(parent_id) = curr_mark_node.get_parent_id_opt() { if let Some(parent_id) = curr_mark_node.get_parent_id_opt() {
let parent = self.mark_node_pool.get(parent_id); let parent = self.mark_node_pool.get(parent_id);
Ok(parent.get_child_indices(curr_mark_node_id, &self.mark_node_pool)?) let ast_node_id = self.mark_id_ast_id_map.get(curr_mark_node_id)?;
Ok(parent.get_child_indices(curr_mark_node_id, ast_node_id, &self.mark_id_ast_id_map)?)
} else { } else {
MissingParent { MissingParent {
node_id: curr_mark_node_id, node_id: curr_mark_node_id,

33
editor/src/editor/mvc/ed_update.rs
View file

@ -377,8 +377,7 @@ impl<'a> EdModel<'a> {
let expr2_level_mark_node = self.mark_node_pool.get(selected_block.mark_node_id); let expr2_level_mark_node = self.mark_node_pool.get(selected_block.mark_node_id);
if let Some(parent_id) = expr2_level_mark_node.get_parent_id_opt() { if let Some(parent_id) = expr2_level_mark_node.get_parent_id_opt() {
let parent_mark_node = self.mark_node_pool.get(parent_id); let ast_node_id = self.mark_id_ast_id_map.get(parent_id)?;
let ast_node_id = parent_mark_node.get_ast_node_id();
let (expr_start_pos, expr_end_pos) = self let (expr_start_pos, expr_end_pos) = self
.grid_node_map .grid_node_map
@ -568,7 +567,6 @@ impl<'a> EdModel<'a> {
let newlines_at_end = expr2_level_mark_node.get_newlines_at_end(); let newlines_at_end = expr2_level_mark_node.get_newlines_at_end();
let blank_replacement = MarkupNode::Blank { let blank_replacement = MarkupNode::Blank {
ast_node_id: sel_block.ast_node_id,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt: expr2_level_mark_node.get_parent_id_opt(), parent_id_opt: expr2_level_mark_node.get_parent_id_opt(),
newlines_at_end, newlines_at_end,
@ -658,13 +656,16 @@ impl<'a> EdModel<'a> {
fn post_process_ast_update(&mut self) -> EdResult<()> { fn post_process_ast_update(&mut self) -> EdResult<()> {
//dbg!("{}",self.module.ast.ast_to_string(self.module.env.pool)); //dbg!("{}",self.module.ast.ast_to_string(self.module.env.pool));
self.markup_ids = ast_to_mark_nodes( let markup_ids_tup = ast_to_mark_nodes(
&mut self.module.env, &mut self.module.env,
&self.module.ast, &self.module.ast,
&mut self.mark_node_pool, &mut self.mark_node_pool,
&self.loaded_module.interns, &self.loaded_module.interns,
)?; )?;
self.markup_ids = markup_ids_tup.0;
self.mark_id_ast_id_map = markup_ids_tup.1;
self.code_lines = CodeLines::from_str(&nodes::mark_nodes_to_string( self.code_lines = CodeLines::from_str(&nodes::mark_nodes_to_string(
&self.markup_ids, &self.markup_ids,
&self.mark_node_pool, &self.mark_node_pool,
@ -839,7 +840,7 @@ pub fn get_node_context<'a>(ed_model: &'a EdModel) -> EdResult<NodeContext<'a>>
.get_id_at_row_col(ed_model.get_caret())?; .get_id_at_row_col(ed_model.get_caret())?;
let curr_mark_node = ed_model.mark_node_pool.get(curr_mark_node_id); let curr_mark_node = ed_model.mark_node_pool.get(curr_mark_node_id);
let parent_id_opt = curr_mark_node.get_parent_id_opt(); let parent_id_opt = curr_mark_node.get_parent_id_opt();
let ast_node_id = curr_mark_node.get_ast_node_id(); let ast_node_id = ed_model.mark_id_ast_id_map.get(curr_mark_node_id)?;
Ok(NodeContext { Ok(NodeContext {
old_caret_pos, old_caret_pos,
@ -1003,9 +1004,8 @@ pub fn handle_new_char_expr(
Expr2::SmallInt { .. } => update_int(ed_model, curr_mark_node_id, ch)?, Expr2::SmallInt { .. } => update_int(ed_model, curr_mark_node_id, ch)?,
_ => { _ => {
let prev_ast_node_id = ed_model let prev_ast_node_id = ed_model
.mark_node_pool .mark_id_ast_id_map
.get(prev_mark_node_id) .get(prev_mark_node_id)?;
.get_ast_node_id();
match prev_ast_node_id { match prev_ast_node_id {
ASTNodeId::ADefId(_) => InputOutcome::Ignored, ASTNodeId::ADefId(_) => InputOutcome::Ignored,
@ -1027,9 +1027,8 @@ pub fn handle_new_char_expr(
if let Some(mark_parent_id) = mark_parent_id_opt { if let Some(mark_parent_id) = mark_parent_id_opt {
let parent_ast_id = ed_model let parent_ast_id = ed_model
.mark_node_pool .mark_id_ast_id_map
.get(mark_parent_id) .get(mark_parent_id)?;
.get_ast_node_id();
match parent_ast_id { match parent_ast_id {
ASTNodeId::ADefId(_) => InputOutcome::Ignored, ASTNodeId::ADefId(_) => InputOutcome::Ignored,
@ -1048,9 +1047,8 @@ pub fn handle_new_char_expr(
if let Some(mark_parent_id) = mark_parent_id_opt { if let Some(mark_parent_id) = mark_parent_id_opt {
let parent_ast_id = ed_model let parent_ast_id = ed_model
.mark_node_pool .mark_id_ast_id_map
.get(mark_parent_id) .get(mark_parent_id)?;
.get_ast_node_id();
match parent_ast_id { match parent_ast_id {
ASTNodeId::ADefId(_) => InputOutcome::Ignored, ASTNodeId::ADefId(_) => InputOutcome::Ignored,
@ -1215,8 +1213,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
let outcome = let outcome =
if ed_model.node_exists_at_caret() { if ed_model.node_exists_at_caret() {
let curr_mark_node_id = ed_model.get_curr_mark_node_id()?; let curr_mark_node_id = ed_model.get_curr_mark_node_id()?;
let curr_mark_node = ed_model.mark_node_pool.get(curr_mark_node_id); let ast_node_id = ed_model.mark_id_ast_id_map.get(curr_mark_node_id)?;
let ast_node_id = curr_mark_node.get_ast_node_id();
match ast_node_id { match ast_node_id {
ASTNodeId::ADefId(def_id) => { ASTNodeId::ADefId(def_id) => {
@ -1233,9 +1230,9 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
} else { } else {
let prev_mark_node_id_opt = ed_model.get_prev_mark_node_id()?; let prev_mark_node_id_opt = ed_model.get_prev_mark_node_id()?;
if let Some(prev_mark_node_id) = prev_mark_node_id_opt { if let Some(prev_mark_node_id) = prev_mark_node_id_opt {
let prev_mark_node = ed_model.mark_node_pool.get(prev_mark_node_id);
let prev_ast_node = ed_model.module.env.pool.get(prev_mark_node.get_ast_node_id().to_expr_id()?); let prev_ast_node_id = ed_model.mark_id_ast_id_map.get(prev_mark_node_id)?.to_expr_id()?;
let prev_ast_node = ed_model.module.env.pool.get(prev_ast_node_id);
match prev_ast_node { match prev_ast_node {
Expr2::SmallInt{ .. } => { Expr2::SmallInt{ .. } => {

2
editor/src/editor/mvc/int_update.rs
View file

@ -65,7 +65,7 @@ pub fn update_int(
.get_offset_to_node_id(old_caret_pos, int_mark_node_id)?; .get_offset_to_node_id(old_caret_pos, int_mark_node_id)?;
let int_mark_node = ed_model.mark_node_pool.get_mut(int_mark_node_id); let int_mark_node = ed_model.mark_node_pool.get_mut(int_mark_node_id);
let int_ast_node_id = int_mark_node.get_ast_node_id(); let int_ast_node_id = ed_model.mark_id_ast_id_map.get(int_mark_node_id)?;
let content_str_mut = int_mark_node.get_content_mut()?; let content_str_mut = int_mark_node.get_content_mut()?;

3
editor/src/editor/mvc/list_update.rs
View file

@ -58,9 +58,8 @@ pub fn add_blank_child(
let trip_result: EdResult<(ExprId, ExprId, MarkNodeId)> = if let Some(parent_id) = parent_id_opt let trip_result: EdResult<(ExprId, ExprId, MarkNodeId)> = if let Some(parent_id) = parent_id_opt
{ {
let parent = ed_model.mark_node_pool.get(parent_id);
let list_ast_node_id = parent.get_ast_node_id(); let list_ast_node_id = ed_model.mark_id_ast_id_map.get(parent_id)?;
let list_ast_node = ed_model.module.env.pool.get(list_ast_node_id.to_expr_id()?); let list_ast_node = ed_model.module.env.pool.get(list_ast_node_id.to_expr_id()?);
match list_ast_node { match list_ast_node {

5
editor/src/editor/mvc/record_update.rs
View file

@ -91,7 +91,6 @@ pub fn update_empty_record(
let record_field_node = MarkupNode::Text { let record_field_node = MarkupNode::Text {
content: new_input.to_owned(), content: new_input.to_owned(),
ast_node_id,
syn_high_style: HighlightStyle::RecordField, syn_high_style: HighlightStyle::RecordField,
attributes: Attributes::default(), attributes: Attributes::default(),
parent_id_opt, parent_id_opt,
@ -149,9 +148,9 @@ pub fn update_record_colon(
let prev_mark_node_id_opt = ed_model.get_prev_mark_node_id()?; let prev_mark_node_id_opt = ed_model.get_prev_mark_node_id()?;
if let Some(prev_mark_node_id) = prev_mark_node_id_opt { if let Some(prev_mark_node_id) = prev_mark_node_id_opt {
let prev_mark_node = ed_model.mark_node_pool.get(prev_mark_node_id); let prev_mn_ast_node_id = ed_model.mark_id_ast_id_map.get(prev_mark_node_id)?;
match prev_mark_node.get_ast_node_id() { match prev_mn_ast_node_id {
ASTNodeId::ADefId(_) => Ok(InputOutcome::Ignored), ASTNodeId::ADefId(_) => Ok(InputOutcome::Ignored),
ASTNodeId::AExprId(prev_expr_id) => { ASTNodeId::AExprId(prev_expr_id) => {
let prev_expr = ed_model.module.env.pool.get(prev_expr_id); let prev_expr = ed_model.module.env.pool.get(prev_expr_id);

3
editor/src/editor/render_ast.rs
View file

@ -105,7 +105,6 @@ fn markup_to_wgpu_helper<'a>(
match markup_node { match markup_node {
MarkupNode::Nested { MarkupNode::Nested {
ast_node_id: _,
children_ids, children_ids,
parent_id_opt: _, parent_id_opt: _,
newlines_at_end, newlines_at_end,
@ -131,7 +130,6 @@ fn markup_to_wgpu_helper<'a>(
} }
MarkupNode::Text { MarkupNode::Text {
content, content,
ast_node_id: _,
syn_high_style, syn_high_style,
attributes, attributes,
parent_id_opt: _, parent_id_opt: _,
@ -183,7 +181,6 @@ fn markup_to_wgpu_helper<'a>(
wgpu_texts.push(glyph_text); wgpu_texts.push(glyph_text);
} }
MarkupNode::Blank { MarkupNode::Blank {
ast_node_id: _,
attributes: _, attributes: _,
parent_id_opt: _, parent_id_opt: _,
newlines_at_end, newlines_at_end,

7
editor/src/editor/render_debug.rs
View file

@ -45,7 +45,12 @@ pub fn build_debug_graphics(
.with_color(colors::to_slice(from_hsb(266, 31, 96))) .with_color(colors::to_slice(from_hsb(266, 31, 96)))
.with_scale(config.debug_font_size); .with_scale(config.debug_font_size);
let mark_node_pool_text = glyph_brush::OwnedText::new(format!("{}", ed_model.mark_node_pool)) let mark_node_pool_text = glyph_brush::OwnedText::new(
format!(
"{}",
ed_model.mark_node_pool.debug_string(&ed_model.mark_id_ast_id_map)
)
)
.with_color(colors::to_slice(from_hsb(110, 45, 82))) .with_color(colors::to_slice(from_hsb(110, 45, 82)))
.with_scale(config.debug_font_size); .with_scale(config.debug_font_size);

3
highlight/src/highlight_parser.rs
View file

@ -1,4 +1,5 @@
use peg::error::ParseError; use peg::error::ParseError;
use roc_code_markup::markup::common_nodes::new_blank_mn;
use roc_code_markup::markup::nodes::MarkupNode; use roc_code_markup::markup::nodes::MarkupNode;
use crate::tokenizer::Token; use crate::tokenizer::Token;
@ -18,7 +19,7 @@ peg::parser!{
common_expr() common_expr()
rule common_expr() -> MarkupNode = rule common_expr() -> MarkupNode =
[T::Number] { new_blank_mn(None) } [T::Number] { new_blank_mn() }
} }
} }