language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-28 06:14:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

addes test to docs for function

Browse source
This commit is contained in:
Anton-4 2021-10-15 15:02:37 +02:00
parent 428b4574ae
commit d3f2b95f7a
17 changed files with 136 additions and 578 deletions
Download patch file Download diff file Expand all files Collapse all files

18
ast/src/lang/core/expr/expr2_to_string.rs
View file

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

7
ast/src/lang/core/expr/expr_to_expr2.rs
View file

@ -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!

1
ast/src/lang/env.rs
View file

@ -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,

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

@ -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(),

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

@ -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>(
arena: &'a Bump,
env: &mut Env<'b>,
pub fn ast_to_mark_nodes<'a>(
env: &mut Env<'a>,
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);

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

@ -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>(
arena: &'a Bump,
env: &mut Env<'b>,
pub fn def2_to_markup<'a>(
env: &mut Env<'a>,
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,

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

@ -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>(
arena: &'a Bump,
env: &mut Env<'b>,
pub fn expr2_to_markup<'a>(
env: &mut Env<'a>,
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(
arena,
env,
expr,
*expr_id,
mark_node_pool,
interns,
indent_level,
)?;
let fun_call_mark_id =
expr2_to_markup(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> =
arg_expr_ids.iter().map(
|arg_id|
{
let arg_call_mark_ids: Vec<MarkNodeId> = arg_expr_ids
.iter()
.map(|arg_id| {
let arg_expr = env.pool.get(*arg_id);
expr2_to_markup(
arena,
env,
arg_expr,
*arg_id,
mark_node_pool,
interns,
0,
)
}
).collect::<ASTResult<Vec<MarkNodeId>>>()?;
expr2_to_markup(env, arg_expr, *arg_id, mark_node_pool, interns, 0)
})
.collect::<ASTResult<Vec<MarkNodeId>>>()?;
let mut args_with_sapces = join_mark_nodes_spaces(arg_call_mark_ids, true, ast_node_id, mark_node_pool);
let mut 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 =
arg_names.map(|arg_name| new_arg_name_mn(arg_name.to_string(), expr2_node_id)).collect_vec();
let arg_mark_nodes = arg_names
.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,

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

@ -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, AST},
def::def2::{Def2, DefId},
expr::{
expr2::{Expr2, ExprId},
record_field::RecordField,
},
header::AppHeader,
pattern::get_identifier_string,
val_def::ValueDef,
},
env::Env,
},
lang::{core::ast::ASTNodeId, 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)
.take(*indent_level)
.collect(),
MarkupNode::Indent { indent_level, .. } => SINGLE_INDENT.repeat(*indent_level),
}
}
@ -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> {
let space_range_max =
if with_prepend {
pub fn join_mark_nodes_spaces(
mark_nodes_ids: Vec<MarkNodeId>,
with_prepend: bool,
ast_node_id: ASTNodeId,
mark_node_pool: &mut SlowPool,
) -> Vec<MarkNodeId> {
let space_range_max = if with_prepend {
mark_nodes_ids.len()
} else {
mark_nodes_ids.len() - 1
};
let join_nodes: Vec<MarkNodeId> =
(0..space_range_max)
let join_nodes: Vec<MarkNodeId> = (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> {
let join_nodes: Vec<MarkupNode> =
(0..(mark_nodes.len() - 1))
.map(|_| {
new_comma_mn_ast(ast_node_id, None)
})
pub fn join_mark_nodes_commas(
mark_nodes: Vec<MarkupNode>,
ast_node_id: ASTNodeId,
) -> Vec<MarkupNode> {
let join_nodes: Vec<MarkupNode> = (0..(mark_nodes.len() - 1))
.map(|_| new_comma_mn_ast(ast_node_id, None))
.collect();
mark_nodes.into_iter().interleave(join_nodes).collect()

4
docs/src/def.rs
View file

@ -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,
);

5
docs/src/expr.rs
View file

@ -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);

12
docs/src/html.rs
View file

@ -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 {

29
docs/src/lib.rs
View file

@ -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
)
{

22
docs/tests/insert_syntax_highlighting.rs
View file

@ -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",
);
}
}

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

@ -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");
}

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

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

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

@ -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;