language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-29 23:04:49 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

changes to work with combination of Def2 and Expr2

Browse source
This commit is contained in:
Anton-4 2021-08-28 18:54:09 +02:00
parent 41519fca96
commit 0135e7b9b1
20 changed files with 255 additions and 190 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/module/src/symbol.rs
View file

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

11
editor/src/editor/ed_error.rs
View file

@ -1,3 +1,4 @@
use crate::lang::parse::ASTNodeId;
use crate::ui::ui_error::UIResult;
use crate::{editor::slow_pool::MarkNodeId, ui::text::text_pos::TextPos};
use colored::*;
@ -11,6 +12,16 @@ use snafu::{Backtrace, ErrorCompat, NoneError, ResultExt, Snafu};
#[derive(Debug, Snafu)]
#[snafu(visibility(pub))]
pub enum EdError {
#[snafu(display(
"ASTNodeIdWithoutExprId: The expr_id_opt in ASTNode({:?}) was `None` but I was expexting `Some(ExprId)` .",
ast_node_id
))]
ASTNodeIdWithoutExprId {
ast_node_id: ASTNodeId,
backtrace: Backtrace,
},
#[snafu(display(
"CaretNotFound: No carets were found in the expected node with id {}",
node_id

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

@ -6,7 +6,7 @@ use crate::editor::slow_pool::MarkNodeId;
use crate::editor::slow_pool::SlowPool;
use crate::editor::util::first_last_index_of;
use crate::editor::util::index_of;
use crate::lang::ast::ExprId;
use crate::lang::parse::ASTNodeId;
use crate::ui::text::selection::Selection;
use crate::ui::text::text_pos::TextPos;
use crate::ui::ui_error::{OutOfBounds, UIResult};
@ -153,10 +153,10 @@ impl GridNodeMap {
&self,
caret_pos: TextPos,
ed_model: &EdModel,
) -> EdResult<(TextPos, TextPos, ExprId, MarkNodeId)> {
) -> EdResult<(TextPos, TextPos, ASTNodeId, MarkNodeId)> {
let line = slice_get(caret_pos.line, &self.lines)?;
let node_id = slice_get(caret_pos.column, line)?;
let node = ed_model.markup_node_pool.get(*node_id);
let node = ed_model.mark_node_pool.get(*node_id);
if node.is_nested() {
let (start_pos, end_pos) = self.get_nested_start_end_pos(*node_id, ed_model)?;
@ -167,7 +167,7 @@ impl GridNodeMap {
let curr_node_id = slice_get(first_node_index, line)?;
let curr_ast_node_id = ed_model
.markup_node_pool
.mark_node_pool
.get(*curr_node_id)
.get_ast_node_id();
@ -180,11 +180,11 @@ impl GridNodeMap {
for i in (0..first_node_index).rev() {
let prev_pos_node_id = slice_get(i, line)?;
let prev_ast_node_id = ed_model
.markup_node_pool
.mark_node_pool
.get(*prev_pos_node_id)
.get_ast_node_id();
if prev_ast_node_id == curr_ast_node_id {
if prev_ast_node_id.equals(&curr_ast_node_id) {
if pos_extra_subtract > 0 {
expr_start_index -= pos_extra_subtract + 1;
pos_extra_subtract = 0;
@ -202,11 +202,11 @@ impl GridNodeMap {
for i in last_node_index..line.len() {
let next_pos_node_id = slice_get(i, line)?;
let next_ast_node_id = ed_model
.markup_node_pool
.mark_node_pool
.get(*next_pos_node_id)
.get_ast_node_id();
if next_ast_node_id == curr_ast_node_id {
if next_ast_node_id.equals(&curr_ast_node_id) {
if pos_extra_add > 0 {
expr_end_index += pos_extra_add + 1;
pos_extra_add = 0;
@ -219,7 +219,7 @@ impl GridNodeMap {
}
let correct_mark_node_id =
GridNodeMap::get_top_node_with_expr_id(*curr_node_id, &ed_model.markup_node_pool);
GridNodeMap::get_top_node_with_expr_id(*curr_node_id, &ed_model.mark_node_pool);
Ok((
TextPos {
@ -240,14 +240,14 @@ impl GridNodeMap {
// `{` is not the entire Expr2
fn get_top_node_with_expr_id(
curr_node_id: MarkNodeId,
markup_node_pool: &SlowPool,
mark_node_pool: &SlowPool,
) -> MarkNodeId {
let curr_node = markup_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() {
let parent = markup_node_pool.get(parent_id);
let parent = mark_node_pool.get(parent_id);
if parent.get_ast_node_id() == curr_node.get_ast_node_id() {
if parent.get_ast_node_id().equals(&curr_node.get_ast_node_id()) {
parent_id
} else {
curr_node_id
@ -262,7 +262,7 @@ impl GridNodeMap {
nested_node_id: MarkNodeId,
ed_model: &EdModel,
) -> EdResult<(TextPos, TextPos)> {
let parent_mark_node = ed_model.markup_node_pool.get(nested_node_id);
let parent_mark_node = ed_model.mark_node_pool.get(nested_node_id);
let all_child_ids = parent_mark_node.get_children_ids();
let first_child_id = all_child_ids

9
editor/src/editor/markup/common_nodes.rs
View file

@ -1,7 +1,4 @@
use crate::{
editor::{slow_pool::MarkNodeId, syntax_highlight::HighlightStyle},
lang::ast::ExprId,
};
use crate::{editor::{slow_pool::MarkNodeId, syntax_highlight::HighlightStyle}, lang::{ast::{ExprId}, pool::NodeId}};
use super::{attribute::Attributes, nodes, nodes::MarkupNode};
@ -27,7 +24,7 @@ pub fn new_comma_mn(ast_node_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> M
}
}
pub fn new_blank_mn(ast_node_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode {
pub fn new_blank_mn<T>(ast_node_id: NodeId<T>, parent_id_opt: Option<MarkNodeId>) -> MarkupNode {
MarkupNode::Blank {
ast_node_id,
syn_high_style: HighlightStyle::Blank,
@ -37,7 +34,7 @@ pub fn new_blank_mn(ast_node_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> M
}
}
pub fn new_blank_mn_w_nl(ast_node_id: ExprId, parent_id_opt: Option<MarkNodeId>) -> MarkupNode {
pub fn new_blank_mn_w_nl<T>(ast_node_id: NodeId<T>, parent_id_opt: Option<MarkNodeId>) -> MarkupNode {
MarkupNode::Blank {
ast_node_id,
syn_high_style: HighlightStyle::Blank,

93
editor/src/editor/markup/nodes.rs
View file

@ -18,6 +18,7 @@ use crate::lang::ast::ExprId;
use crate::lang::ast::RecordField;
use crate::lang::ast::ValueDef;
use crate::lang::ast::expr2_to_string;
use crate::lang::parse::ASTNodeId;
use crate::lang::parse::{AppHeader, AST};
use crate::lang::pattern::get_identifier_string;
use crate::lang::{ast::Expr2, expr::Env, pool::PoolStr};
@ -29,21 +30,21 @@ use std::fmt;
#[derive(Debug)]
pub enum MarkupNode {
Nested {
ast_node_id: ExprId,
ast_node_id: ASTNodeId,
children_ids: Vec<MarkNodeId>,
parent_id_opt: Option<MarkNodeId>,
newline_at_end: bool,
},
Text {
content: String,
ast_node_id: ExprId,
ast_node_id: ASTNodeId,
syn_high_style: HighlightStyle,
attributes: Attributes,
parent_id_opt: Option<MarkNodeId>,
newline_at_end: bool,
},
Blank {
ast_node_id: ExprId,
ast_node_id: ASTNodeId,
attributes: Attributes,
syn_high_style: HighlightStyle, // TODO remove HighlightStyle, this is always HighlightStyle::Blank
parent_id_opt: Option<MarkNodeId>,
@ -52,7 +53,7 @@ pub enum MarkupNode {
}
impl MarkupNode {
pub fn get_ast_node_id(&self) -> ExprId {
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,
@ -76,9 +77,9 @@ impl MarkupNode {
}
}
pub fn get_sibling_ids(&self, markup_node_pool: &SlowPool) -> Vec<MarkNodeId> {
pub fn get_sibling_ids(&self, mark_node_pool: &SlowPool) -> Vec<MarkNodeId> {
if let Some(parent_id) = self.get_parent_id_opt() {
let parent_node = markup_node_pool.get(parent_id);
let parent_node = mark_node_pool.get(parent_id);
parent_node.get_children_ids()
} else {
@ -90,7 +91,7 @@ impl MarkupNode {
pub fn get_child_indices(
&self,
child_id: MarkNodeId,
markup_node_pool: &SlowPool,
mark_node_pool: &SlowPool,
) -> EdResult<(usize, usize)> {
match self {
MarkupNode::Nested { children_ids, .. } => {
@ -103,7 +104,7 @@ impl MarkupNode {
mark_child_index_opt = Some(indx);
}
let child_mark_node = markup_node_pool.get(mark_child_id);
let child_mark_node = mark_node_pool.get(mark_child_id);
// a node that points to the same ast_node as the parent is a ',', '[', ']'
// those are not "real" ast children
if child_mark_node.get_ast_node_id() != self_ast_id {
@ -259,7 +260,7 @@ fn new_markup_node(
text: String,
node_id: ExprId,
highlight_style: HighlightStyle,
markup_node_pool: &mut SlowPool,
mark_node_pool: &mut SlowPool,
) -> MarkNodeId {
let node = MarkupNode::Text {
content: text,
@ -270,7 +271,7 @@ fn new_markup_node(
newline_at_end: false,
};
markup_node_pool.add(node)
mark_node_pool.add(node)
}
// make Markup Nodes: generate String representation, assign Highlighting Style
@ -279,7 +280,7 @@ pub fn expr2_to_markup<'a, 'b>(
env: &mut Env<'b>,
expr2: &Expr2,
expr2_node_id: ExprId,
markup_node_pool: &mut SlowPool,
mark_node_pool: &mut SlowPool,
interns: &Interns,
) -> EdResult<MarkNodeId> {
dbg!(expr2_to_string(expr2_node_id, env.pool));
@ -295,24 +296,24 @@ pub fn expr2_to_markup<'a, 'b>(
num_str,
expr2_node_id,
HighlightStyle::Number,
markup_node_pool,
mark_node_pool,
)
}
Expr2::Str(text) => new_markup_node(
"\"".to_owned() + text.as_str(env.pool) + "\"",
expr2_node_id,
HighlightStyle::String,
markup_node_pool,
mark_node_pool,
),
Expr2::GlobalTag { name, .. } => new_markup_node(
get_string(env, name),
expr2_node_id,
HighlightStyle::Type,
markup_node_pool,
mark_node_pool,
),
Expr2::Call { expr: expr_id, .. } => {
let expr = env.pool.get(*expr_id);
expr2_to_markup(arena, env, expr, *expr_id, markup_node_pool, interns)?
expr2_to_markup(arena, env, expr, *expr_id, mark_node_pool, interns)?
}
Expr2::Var(symbol) => {
//TODO make bump_format with arena
@ -321,12 +322,12 @@ pub fn expr2_to_markup<'a, 'b>(
text,
expr2_node_id,
HighlightStyle::Variable,
markup_node_pool,
mark_node_pool,
)
}
Expr2::List { elems, .. } => {
let mut children_ids =
vec![markup_node_pool.add(new_left_square_mn(expr2_node_id, None))];
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();
@ -339,15 +340,15 @@ pub fn expr2_to_markup<'a, 'b>(
env,
sub_expr2,
*node_id,
markup_node_pool,
mark_node_pool,
interns,
)?);
if idx + 1 < elems.len() {
children_ids.push(markup_node_pool.add(new_comma_mn(expr2_node_id, None)));
children_ids.push(mark_node_pool.add(new_comma_mn(expr2_node_id, None)));
}
}
children_ids.push(markup_node_pool.add(new_right_square_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: expr2_node_id,
@ -356,12 +357,12 @@ pub fn expr2_to_markup<'a, 'b>(
newline_at_end: false,
};
markup_node_pool.add(list_node)
mark_node_pool.add(list_node)
}
Expr2::EmptyRecord => {
let children_ids = vec![
markup_node_pool.add(new_left_accolade_mn(expr2_node_id, None)),
markup_node_pool.add(new_right_accolade_mn(expr2_node_id, None)),
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 {
@ -371,11 +372,11 @@ pub fn expr2_to_markup<'a, 'b>(
newline_at_end: false,
};
markup_node_pool.add(record_node)
mark_node_pool.add(record_node)
}
Expr2::Record { fields, .. } => {
let mut children_ids =
vec![markup_node_pool.add(new_left_accolade_mn(expr2_node_id, None))];
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);
@ -386,14 +387,14 @@ pub fn expr2_to_markup<'a, 'b>(
field_name.as_str(env.pool).to_owned(),
expr2_node_id,
HighlightStyle::RecordField,
markup_node_pool,
mark_node_pool,
));
match record_field {
RecordField::InvalidLabelOnly(_, _) => (),
RecordField::LabelOnly(_, _, _) => (),
RecordField::LabeledValue(_, _, sub_expr2_node_id) => {
children_ids.push(markup_node_pool.add(new_colon_mn(expr2_node_id, None)));
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(
@ -401,18 +402,18 @@ pub fn expr2_to_markup<'a, 'b>(
env,
sub_expr2,
*sub_expr2_node_id,
markup_node_pool,
mark_node_pool,
interns,
)?);
}
}
if idx + 1 < fields.len() {
children_ids.push(markup_node_pool.add(new_comma_mn(expr2_node_id, None)));
children_ids.push(mark_node_pool.add(new_comma_mn(expr2_node_id, None)));
}
}
children_ids.push(markup_node_pool.add(new_right_accolade_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: expr2_node_id,
@ -421,9 +422,9 @@ pub fn expr2_to_markup<'a, 'b>(
newline_at_end: false,
};
markup_node_pool.add(record_node)
mark_node_pool.add(record_node)
}
Expr2::Blank => markup_node_pool.add(new_blank_mn(expr2_node_id, None)),
Expr2::Blank => mark_node_pool.add(new_blank_mn(expr2_node_id, None)),
Expr2::LetValue {
def_id,
body_id,
@ -436,7 +437,7 @@ pub fn expr2_to_markup<'a, 'b>(
let pattern_id = env.pool.get(*def_id).get_pattern_id();
let pattern2 = env.pool.get(pattern_id);
//dbg!(pattern2);
dbg!(pattern2);
let val_name = get_identifier_string(pattern2, interns)?;
let val_name_mn = MarkupNode::Text {
@ -448,9 +449,9 @@ pub fn expr2_to_markup<'a, 'b>(
newline_at_end: false,
};
let val_name_mn_id = markup_node_pool.add(val_name_mn);
let val_name_mn_id = mark_node_pool.add(val_name_mn);
let equals_mn_id = markup_node_pool.add(new_equals_mn(expr2_node_id, None));
let equals_mn_id = mark_node_pool.add(new_equals_mn(expr2_node_id, None));
let value_def = env.pool.get(*def_id);
@ -465,11 +466,11 @@ pub fn expr2_to_markup<'a, 'b>(
env,
env.pool.get(*expr_id),
*expr_id,
markup_node_pool,
mark_node_pool,
interns,
)?;
let body_mn = markup_node_pool.get_mut(body_mn_id);
let body_mn = mark_node_pool.get_mut(body_mn_id);
body_mn.add_newline_at_end();
let full_let_node = MarkupNode::Nested {
@ -479,7 +480,7 @@ pub fn expr2_to_markup<'a, 'b>(
newline_at_end: true,
};
markup_node_pool.add(full_let_node)
mark_node_pool.add(full_let_node)
}
other => {
unimplemented!(
@ -493,7 +494,7 @@ pub fn expr2_to_markup<'a, 'b>(
"RunTimeError".to_string(),
expr2_node_id,
HighlightStyle::Blank,
markup_node_pool,
mark_node_pool,
),
rest => todo!("implement expr2_to_markup for {:?}", rest),
};
@ -501,8 +502,8 @@ pub fn expr2_to_markup<'a, 'b>(
Ok(mark_node_id)
}
pub fn set_parent_for_all(markup_node_id: MarkNodeId, markup_node_pool: &mut SlowPool) {
let node = markup_node_pool.get(markup_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);
if let MarkupNode::Nested {
ast_node_id: _,
@ -515,7 +516,7 @@ pub fn set_parent_for_all(markup_node_id: MarkNodeId, markup_node_pool: &mut Slo
let children_ids_clone = children_ids.clone();
for child_id in children_ids_clone {
set_parent_for_all_helper(child_id, markup_node_id, markup_node_pool);
set_parent_for_all_helper(child_id, markup_node_id, mark_node_pool);
}
}
}
@ -523,9 +524,9 @@ pub fn set_parent_for_all(markup_node_id: MarkNodeId, markup_node_pool: &mut Slo
pub fn set_parent_for_all_helper(
markup_node_id: MarkNodeId,
parent_node_id: MarkNodeId,
markup_node_pool: &mut SlowPool,
mark_node_pool: &mut SlowPool,
) {
let node = markup_node_pool.get_mut(markup_node_id);
let node = mark_node_pool.get_mut(markup_node_id);
match node {
MarkupNode::Nested {
@ -539,7 +540,7 @@ pub fn set_parent_for_all_helper(
let children_ids_clone = children_ids.clone();
for child_id in children_ids_clone {
set_parent_for_all_helper(child_id, markup_node_id, markup_node_pool);
set_parent_for_all_helper(child_id, markup_node_id, mark_node_pool);
}
}
MarkupNode::Text { parent_id_opt, .. } => *parent_id_opt = Some(parent_node_id),
@ -680,7 +681,7 @@ pub fn header_to_markup(app_header: &AppHeader, mark_node_pool: &mut SlowPool) -
let provides_val_node_id = header_val_mn(
// TODO iter over provides like with imports
app_header.provides.first().unwrap().to_owned(),
app_header.provides.first().unwrap_or(&String::new()).to_owned(),
ast_node_id,
HighlightStyle::Provides,
mark_node_pool,

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

@ -7,7 +7,7 @@ use crate::editor::{
ed_error::{EdResult, EmptyCodeString, MissingParent, NoNodeAtCaretPosition},
};
use crate::graphics::primitives::rect::Rect;
use crate::lang::ast::ExprId;
use crate::lang::ast::{DefId, ExprId};
use crate::lang::expr::Env;
use crate::lang::parse::AST;
use crate::lang::pool::PoolStr;
@ -28,7 +28,7 @@ pub struct EdModel<'a> {
// allows us to map window coordinates to MarkNodeId's
pub grid_node_map: GridNodeMap,
pub markup_ids: Vec<MarkNodeId>, // one root node for every expression
pub markup_node_pool: SlowPool,
pub mark_node_pool: SlowPool,
// contains single char dimensions, used to calculate line height, column width...
pub glyph_dim_rect_opt: Option<Rect>,
pub has_focus: bool,
@ -57,7 +57,7 @@ pub fn init_model<'a>(
) -> EdResult<EdModel<'a>> {
let mut module = EdModule::new(code_str, env, code_arena)?;
let mut markup_node_pool = SlowPool::new();
let mut mark_node_pool = SlowPool::new();
let markup_ids = if code_str.is_empty() {
EmptyCodeString {}.fail()
@ -66,13 +66,13 @@ pub fn init_model<'a>(
code_arena,
&mut module.env,
&module.ast,
&mut markup_node_pool,
&mut mark_node_pool,
&loaded_module.interns,
)
}?;
let code_lines = EdModel::build_code_lines_from_markup(&markup_ids, &markup_node_pool)?;
let grid_node_map = EdModel::build_node_map_from_markup(&markup_ids, &markup_node_pool)?;
let code_lines = EdModel::build_code_lines_from_markup(&markup_ids, &mark_node_pool)?;
let grid_node_map = EdModel::build_node_map_from_markup(&markup_ids, &mark_node_pool)?;
let caret = match caret_pos {
CaretPos::Start => CaretWSelect::default(),
@ -86,7 +86,7 @@ pub fn init_model<'a>(
code_lines,
grid_node_map,
markup_ids,
markup_node_pool,
mark_node_pool,
glyph_dim_rect_opt: None,
has_focus: true,
caret_w_select_vec: NonEmpty::new((caret, None)),
@ -135,11 +135,11 @@ impl<'a> EdModel<'a> {
pub fn get_curr_child_indices(&self) -> EdResult<(usize, usize)> {
if self.node_exists_at_caret() {
let curr_mark_node_id = self.get_curr_mark_node_id()?;
let curr_mark_node = self.markup_node_pool.get(curr_mark_node_id);
let curr_mark_node = self.mark_node_pool.get(curr_mark_node_id);
if let Some(parent_id) = curr_mark_node.get_parent_id_opt() {
let parent = self.markup_node_pool.get(parent_id);
parent.get_child_indices(curr_mark_node_id, &self.markup_node_pool)
let parent = self.mark_node_pool.get(parent_id);
parent.get_child_indices(curr_mark_node_id, &self.mark_node_pool)
} else {
MissingParent {
node_id: curr_mark_node_id,

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

@ -26,8 +26,10 @@ use crate::editor::mvc::string_update::update_string;
use crate::editor::slow_pool::MarkNodeId;
use crate::editor::slow_pool::SlowPool;
use crate::editor::syntax_highlight::HighlightStyle;
use crate::lang::ast::Def2;
use crate::lang::ast::{Expr2, ExprId};
use crate::lang::constrain::constrain_expr;
use crate::lang::parse::ASTNodeId;
use crate::lang::pool::Pool;
use crate::lang::pool::PoolStr;
use crate::lang::types::Type2;
@ -116,7 +118,7 @@ impl<'a> EdModel<'a> {
pub fn build_node_map_from_markup(
markup_ids: &[MarkNodeId],
markup_node_pool: &SlowPool,
mark_node_pool: &SlowPool,
) -> EdResult<GridNodeMap> {
let mut grid_node_map = GridNodeMap::new();
let mut line_ctr = 0;
@ -126,28 +128,28 @@ impl<'a> EdModel<'a> {
*mark_id,
&mut grid_node_map,
&mut line_ctr,
markup_node_pool,
mark_node_pool,
)?;
}
Ok(grid_node_map)
}
pub fn add_mark_node(&mut self, node: MarkupNode) -> MarkNodeId {
self.markup_node_pool.add(node)
pub fn add_mark_node<T>(&mut self, node: MarkupNode) -> MarkNodeId {
self.mark_node_pool.add(node)
}
fn build_grid_node_map(
node_id: MarkNodeId,
grid_node_map: &mut GridNodeMap,
line_ctr: &mut usize,
markup_node_pool: &SlowPool,
mark_node_pool: &SlowPool,
) -> EdResult<()> {
let node = markup_node_pool.get(node_id);
let node = mark_node_pool.get(node_id);
if node.is_nested() {
for child_id in node.get_children_ids() {
EdModel::build_grid_node_map(child_id, grid_node_map, line_ctr, markup_node_pool)?;
EdModel::build_grid_node_map(child_id, grid_node_map, line_ctr, mark_node_pool)?;
}
} else {
let node_content_str = node.get_content();
@ -165,12 +167,12 @@ impl<'a> EdModel<'a> {
pub fn build_code_lines_from_markup(
markup_node_ids: &[MarkNodeId],
markup_node_pool: &SlowPool,
mark_node_pool: &SlowPool,
) -> EdResult<CodeLines> {
let mut all_code_string = String::new();
for mark_node_id in markup_node_ids.iter() {
EdModel::build_markup_string(*mark_node_id, &mut all_code_string, markup_node_pool)?;
EdModel::build_markup_string(*mark_node_id, &mut all_code_string, mark_node_pool)?;
}
let code_lines = CodeLines::from_str(&all_code_string);
@ -181,13 +183,13 @@ impl<'a> EdModel<'a> {
fn build_markup_string(
node_id: MarkNodeId,
all_code_string: &mut String,
markup_node_pool: &SlowPool,
mark_node_pool: &SlowPool,
) -> EdResult<()> {
let node = markup_node_pool.get(node_id);
let node = mark_node_pool.get(node_id);
if node.is_nested() {
for child_id in node.get_children_ids() {
EdModel::build_markup_string(child_id, all_code_string, markup_node_pool)?;
EdModel::build_markup_string(child_id, all_code_string, mark_node_pool)?;
}
} else {
let node_content_str = node.get_content();
@ -224,7 +226,7 @@ impl<'a> EdModel<'a> {
let mut col_nr = index;
for &node_id in node_ids {
let node_content_str = self.markup_node_pool.get(node_id).get_content();
let node_content_str = self.mark_node_pool.get(node_id).get_content();
self.grid_node_map.insert_between_line(
line_nr,
@ -284,10 +286,10 @@ impl<'a> EdModel<'a> {
pub fn select_expr(&mut self) -> EdResult<()> {
// include parent in selection if an `Expr2` was already selected
if let Some(selected_expr) = &self.selected_expr_opt {
let expr2_level_mark_node = self.markup_node_pool.get(selected_expr.mark_node_id);
let expr2_level_mark_node = self.mark_node_pool.get(selected_expr.mark_node_id);
if let Some(parent_id) = expr2_level_mark_node.get_parent_id_opt() {
let parent_mark_node = self.markup_node_pool.get(parent_id);
let parent_mark_node = self.mark_node_pool.get(parent_id);
let ast_node_id = parent_mark_node.get_ast_node_id();
let (expr_start_pos, expr_end_pos) = self
@ -433,7 +435,7 @@ impl<'a> EdModel<'a> {
fn replace_selected_expr_with_blank(&mut self) -> EdResult<()> {
let expr_mark_node_id_opt = if let Some(sel_expr) = &self.selected_expr_opt {
let expr2_level_mark_node = self.markup_node_pool.get(sel_expr.mark_node_id);
let expr2_level_mark_node = self.mark_node_pool.get(sel_expr.mark_node_id);
let newline_at_end = expr2_level_mark_node.has_newline_at_end();
let blank_replacement = MarkupNode::Blank {
@ -444,7 +446,7 @@ impl<'a> EdModel<'a> {
newline_at_end,
};
self.markup_node_pool
self.mark_node_pool
.replace_node(sel_expr.mark_node_id, blank_replacement);
let active_selection = self.get_selection().context(MissingSelection {})?;
@ -616,15 +618,15 @@ pub struct NodeContext<'a> {
pub curr_mark_node_id: MarkNodeId,
pub curr_mark_node: &'a MarkupNode,
pub parent_id_opt: Option<MarkNodeId>,
pub ast_node_id: ExprId,
pub ast_node_id: ASTNodeId,
}
pub fn get_node_context<'a>(ed_model: &'a EdModel) -> EdResult<NodeContext<'a>> {
pub fn get_node_context<'a, T>(ed_model: &'a EdModel) -> EdResult<NodeContext<'a>> {
let old_caret_pos = ed_model.get_caret();
let curr_mark_node_id = ed_model
.grid_node_map
.get_id_at_row_col(ed_model.get_caret())?;
let curr_mark_node = ed_model.markup_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 ast_node_id = curr_mark_node.get_ast_node_id();
@ -662,7 +664,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
let outcome =
if ed_model.node_exists_at_caret() {
let curr_mark_node_id = ed_model.get_curr_mark_node_id()?;
let curr_mark_node = ed_model.markup_node_pool.get(curr_mark_node_id);
let curr_mark_node = ed_model.mark_node_pool.get(curr_mark_node_id);
let prev_mark_node_id_opt = ed_model.get_prev_mark_node_id()?;
let ast_node_id = curr_mark_node.get_ast_node_id();
@ -743,7 +745,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
_ => {
let prev_ast_node_id =
ed_model
.markup_node_pool
.mark_node_pool
.get(prev_mark_node_id)
.get_ast_node_id();
@ -763,7 +765,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
)?
}
Expr2::Record{ record_var:_, fields } => {
let prev_mark_node = ed_model.markup_node_pool.get(prev_mark_node_id);
let prev_mark_node = ed_model.mark_node_pool.get(prev_mark_node_id);
if (curr_mark_node.get_content() == nodes::RIGHT_ACCOLADE || curr_mark_node.get_content() == nodes::COLON) &&
prev_mark_node.is_all_alphanumeric() {
@ -787,7 +789,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
}
}
Expr2::List{ elem_var: _, elems: _} => {
let prev_mark_node = ed_model.markup_node_pool.get(prev_mark_node_id);
let prev_mark_node = ed_model.mark_node_pool.get(prev_mark_node_id);
if prev_mark_node.get_content() == nodes::LEFT_SQUARE_BR && curr_mark_node.get_content() == nodes::RIGHT_SQUARE_BR {
// based on if, we are at the start of the list
@ -806,7 +808,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
_ => {
match ast_node_ref {
Expr2::EmptyRecord => {
let sibling_ids = curr_mark_node.get_sibling_ids(&ed_model.markup_node_pool);
let sibling_ids = curr_mark_node.get_sibling_ids(&ed_model.mark_node_pool);
update_empty_record(
&ch.to_string(),
@ -825,7 +827,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
let mark_parent_id_opt = curr_mark_node.get_parent_id_opt();
if let Some(mark_parent_id) = mark_parent_id_opt {
let parent_ast_id = ed_model.markup_node_pool.get(mark_parent_id).get_ast_node_id();
let parent_ast_id = ed_model.mark_node_pool.get(mark_parent_id).get_ast_node_id();
update_record_colon(ed_model, parent_ast_id)?
} else {
@ -838,7 +840,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
let mark_parent_id_opt = curr_mark_node.get_parent_id_opt();
if let Some(mark_parent_id) = mark_parent_id_opt {
let parent_ast_id = ed_model.markup_node_pool.get(mark_parent_id).get_ast_node_id();
let parent_ast_id = ed_model.mark_node_pool.get(mark_parent_id).get_ast_node_id();
let parent_expr2 = ed_model.module.env.pool.get(parent_ast_id);
match parent_expr2 {
@ -864,7 +866,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
}
}
} else if "\"{[".contains(*ch) {
let prev_mark_node = ed_model.markup_node_pool.get(prev_mark_node_id);
let prev_mark_node = ed_model.mark_node_pool.get(prev_mark_node_id);
if prev_mark_node.get_content() == nodes::LEFT_SQUARE_BR && curr_mark_node.get_content() == nodes::RIGHT_SQUARE_BR {
let (new_child_index, new_ast_child_index) = ed_model.get_curr_child_indices()?;
@ -943,7 +945,7 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
} else {
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 {
let prev_mark_node = ed_model.markup_node_pool.get(prev_mark_node_id);
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());
@ -963,11 +965,11 @@ pub fn handle_new_char(received_char: &char, ed_model: &mut EdModel) -> EdResult
if caret_pos.line > 0 {
// TODO avoid code replication with '\r'
// insert blank first, this simplifies flow
let new_blank = Expr2::Blank;
let new_blank = Def2::Blank;
let new_blank_id = ed_model.module.env.pool.add(new_blank);
// TODO this should insert at caret line_nr, not push at end
ed_model.module.ast.expression_ids.push(new_blank_id);
ed_model.module.ast.def_ids.push(new_blank_id);
let blank_mn_id = ed_model
.add_mark_node(new_blank_mn(new_blank_id, None));

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

@ -83,7 +83,7 @@ pub fn model_to_wgpu<'a>(
txt_coords,
config,
glyph_dim_rect,
&ed_model.markup_node_pool,
&ed_model.mark_node_pool,
)?;
all_rendered.extend(rendered_code_graphics);

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

@ -51,7 +51,7 @@ pub fn start_new_int(ed_model: &mut EdModel, digit_char: &char) -> EdResult<Inpu
if is_blank_node {
ed_model
.markup_node_pool
.mark_node_pool
.replace_node(curr_mark_node_id, int_node);
// remove data corresponding to Blank node
@ -87,7 +87,7 @@ pub fn update_int(
.grid_node_map
.get_offset_to_node_id(old_caret_pos, int_mark_node_id)?;
let int_mark_node = ed_model.markup_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 content_str_mut = int_mark_node.get_content_mut()?;

4
editor/src/editor/mvc/let_update.rs
View file

@ -85,7 +85,7 @@ pub fn start_new_let_value(ed_model: &mut EdModel, new_char: &char) -> EdResult<
if is_blank_node {
ed_model
.markup_node_pool
.mark_node_pool
.replace_node(curr_mark_node_id, val_mark_node);
// remove data corresponding to Blank node
@ -118,7 +118,7 @@ pub fn update_let_value(
let old_caret_pos = ed_model.get_caret();
// update markup
let val_name_mn_mut = ed_model.markup_node_pool.get_mut(val_name_mn_id);
let val_name_mn_mut = ed_model.mark_node_pool.get_mut(val_name_mn_id);
let content_str_mut = val_name_mn_mut.get_content_mut()?;
let old_val_name = content_str_mut.clone();

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

@ -49,7 +49,7 @@ pub fn start_new_list(ed_model: &mut EdModel) -> EdResult<InputOutcome> {
if is_blank_node {
ed_model
.markup_node_pool
.mark_node_pool
.replace_node(curr_mark_node_id, nested_node);
// remove data corresponding to Blank node
@ -94,7 +94,7 @@ pub fn add_blank_child(
let trip_result: EdResult<(ExprId, ExprId, MarkNodeId)> = if let Some(parent_id) = parent_id_opt
{
let parent = ed_model.markup_node_pool.get(parent_id);
let parent = ed_model.mark_node_pool.get(parent_id);
let list_ast_node_id = parent.get_ast_node_id();
let list_ast_node = ed_model.module.env.pool.get(list_ast_node_id);
@ -162,7 +162,7 @@ pub fn add_blank_child(
ed_model,
)?;
let parent = ed_model.markup_node_pool.get_mut(parent_id);
let parent = ed_model.mark_node_pool.get_mut(parent_id);
for (indx, child) in new_mark_children.iter().enumerate() {
parent.add_child_at_index(new_child_index + indx, *child)?;

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

@ -35,7 +35,7 @@ pub fn update_invalid_lookup(
.set(ast_node_id, Expr2::InvalidLookup(new_pool_str));
// update MarkupNode
let curr_mark_node_mut = ed_model.markup_node_pool.get_mut(curr_mark_node_id);
let curr_mark_node_mut = ed_model.mark_node_pool.get_mut(curr_mark_node_id);
let content_str_mut = curr_mark_node_mut.get_content_mut()?;
content_str_mut.insert_str(caret_offset, input_str);

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

@ -51,7 +51,7 @@ pub fn start_new_record(ed_model: &mut EdModel) -> EdResult<InputOutcome> {
if is_blank_node {
ed_model
.markup_node_pool
.mark_node_pool
.replace_node(curr_mark_node_id, nested_node);
// remove data corresponding to Blank node
@ -83,7 +83,7 @@ pub fn update_empty_record(
if input_chars.all(|ch| ch.is_ascii_alphabetic())
&& input_chars.all(|ch| ch.is_ascii_lowercase())
{
let prev_mark_node = ed_model.markup_node_pool.get(prev_mark_node_id);
let prev_mark_node = ed_model.mark_node_pool.get(prev_mark_node_id);
let NodeContext {
old_caret_pos,
@ -123,7 +123,7 @@ pub fn update_empty_record(
let record_field_node_id = ed_model.add_mark_node(record_field_node);
if let Some(parent_id) = parent_id_opt {
let parent = ed_model.markup_node_pool.get_mut(parent_id);
let parent = ed_model.mark_node_pool.get_mut(parent_id);
let new_child_index = index_of(curr_mark_node_id, &sibling_ids)?;
@ -171,7 +171,7 @@ pub fn update_record_colon(
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 {
let prev_mark_node = ed_model.markup_node_pool.get(prev_mark_node_id);
let prev_mark_node = ed_model.mark_node_pool.get(prev_mark_node_id);
let prev_ast_node = ed_model
.module
@ -183,7 +183,7 @@ pub fn update_record_colon(
if matches!(prev_ast_node, Expr2::Record { .. })
&& matches!(curr_ast_node, Expr2::Record { .. })
{
let sibling_ids = curr_mark_node.get_sibling_ids(&ed_model.markup_node_pool);
let sibling_ids = curr_mark_node.get_sibling_ids(&ed_model.mark_node_pool);
let new_child_index = index_of(curr_mark_node_id, &sibling_ids)?;
@ -197,7 +197,7 @@ pub fn update_record_colon(
if ed_model.node_exists_at_caret() {
let next_mark_node_id =
ed_model.grid_node_map.get_id_at_row_col(old_caret_pos)?;
let next_mark_node = ed_model.markup_node_pool.get(next_mark_node_id);
let next_mark_node = ed_model.mark_node_pool.get(next_mark_node_id);
if next_mark_node.get_content() == nodes::RIGHT_ACCOLADE {
// update AST node
let new_field_val = Expr2::Blank;
@ -229,7 +229,7 @@ pub fn update_record_colon(
let record_colon_node_id =
ed_model.add_mark_node(record_colon_node);
ed_model
.markup_node_pool
.mark_node_pool
.get_mut(parent_id)
.add_child_at_index(new_child_index, record_colon_node_id)?;
@ -237,7 +237,7 @@ pub fn update_record_colon(
.add_mark_node(new_blank_mn(new_field_val_id, Some(parent_id)));
ed_model
.markup_node_pool
.mark_node_pool
.get_mut(parent_id)
.add_child_at_index(
new_child_index + 1,
@ -286,7 +286,7 @@ pub fn update_record_field(
ed_model: &mut EdModel,
) -> EdResult<InputOutcome> {
// update MarkupNode
let curr_mark_node_mut = ed_model.markup_node_pool.get_mut(curr_mark_node_id);
let curr_mark_node_mut = ed_model.mark_node_pool.get_mut(curr_mark_node_id);
let content_str_mut = curr_mark_node_mut.get_content_mut()?;
let node_caret_offset = ed_model
.grid_node_map

6
editor/src/editor/mvc/string_update.rs
View file

@ -28,7 +28,7 @@ pub fn update_small_string(
let new_input = &new_char.to_string();
// update markup
let curr_mark_node_mut = ed_model.markup_node_pool.get_mut(curr_mark_node_id);
let curr_mark_node_mut = ed_model.mark_node_pool.get_mut(curr_mark_node_id);
let content_str_mut = curr_mark_node_mut.get_content_mut()?;
let node_caret_offset = ed_model
.grid_node_map
@ -84,7 +84,7 @@ pub fn update_string(new_char: char, ed_model: &mut EdModel) -> EdResult<InputOu
} = get_node_context(ed_model)?;
// update markup
let curr_mark_node_mut = ed_model.markup_node_pool.get_mut(curr_mark_node_id);
let curr_mark_node_mut = ed_model.mark_node_pool.get_mut(curr_mark_node_id);
let content_str_mut = curr_mark_node_mut.get_content_mut()?;
let node_caret_offset = ed_model
.grid_node_map
@ -143,7 +143,7 @@ pub fn start_new_string(ed_model: &mut EdModel) -> EdResult<InputOutcome> {
};
ed_model
.markup_node_pool
.mark_node_pool
.replace_node(curr_mark_node_id, new_string_node);
// remove data corresponding to Blank node

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

@ -5,6 +5,7 @@ use crate::editor::slow_pool::SlowPool;
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 crate::lang::ast::{DefId, ExprId};
use cgmath::Vector2;
use winit::dpi::PhysicalSize;
@ -16,7 +17,7 @@ pub fn build_code_graphics<'a>(
txt_coords: Vector2<f32>,
config: &Config,
glyph_dim_rect: Rect,
markup_node_pool: &'a SlowPool,
mark_node_pool: &'a SlowPool,
) -> EdResult<RenderedWgpu> {
let area_bounds = (size.width as f32, size.height as f32);
let layout = wgpu_glyph::Layout::default().h_align(wgpu_glyph::HorizontalAlign::Left);
@ -27,7 +28,7 @@ pub fn build_code_graphics<'a>(
let mut txt_row_col = (0, 0);
for markup_id in markup_ids.iter() {
let mark_node = markup_node_pool.get(*markup_id);
let mark_node = mark_node_pool.get(*markup_id);
let (mut glyph_text_vec, mut rects) = markup_to_wgpu(
mark_node,
@ -38,7 +39,7 @@ pub fn build_code_graphics<'a>(
glyph_dim_rect,
},
&mut txt_row_col,
markup_node_pool,
mark_node_pool,
)?;
all_glyph_text_vec.append(&mut glyph_text_vec);
@ -69,7 +70,7 @@ fn markup_to_wgpu<'a>(
markup_node: &'a MarkupNode,
code_style: &CodeStyle,
txt_row_col: &mut (usize, usize),
markup_node_pool: &'a SlowPool,
mark_node_pool: &'a SlowPool,
) -> EdResult<(Vec<glyph_brush::OwnedText>, Vec<Rect>)> {
let mut wgpu_texts: Vec<glyph_brush::OwnedText> = Vec::new();
let mut rects: Vec<Rect> = Vec::new();
@ -80,7 +81,7 @@ fn markup_to_wgpu<'a>(
&mut rects,
code_style,
txt_row_col,
markup_node_pool,
mark_node_pool,
)?;
Ok((wgpu_texts, rects))
@ -92,7 +93,7 @@ fn markup_to_wgpu_helper<'a>(
rects: &mut Vec<Rect>,
code_style: &CodeStyle,
txt_row_col: &mut (usize, usize),
markup_node_pool: &'a SlowPool,
mark_node_pool: &'a SlowPool,
) -> EdResult<()> {
match markup_node {
MarkupNode::Nested {
@ -102,14 +103,14 @@ fn markup_to_wgpu_helper<'a>(
newline_at_end,
} => {
for child_id in children_ids.iter() {
let child = markup_node_pool.get(*child_id);
let child = mark_node_pool.get(*child_id);
markup_to_wgpu_helper(
child,
wgpu_texts,
rects,
code_style,
txt_row_col,
markup_node_pool,
mark_node_pool,
)?;
}

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

@ -4,7 +4,7 @@ use crate::editor::mvc::ed_model::EdModel;
use crate::graphics::colors;
use crate::graphics::colors::from_hsb;
use crate::graphics::primitives::text as gr_text;
use crate::lang::ast::expr2_to_string;
use crate::lang::ast::{def2_to_string};
use cgmath::Vector2;
use winit::dpi::PhysicalSize;
@ -38,7 +38,7 @@ pub fn build_debug_graphics(
for mark_id in ed_model.markup_ids[1..].iter() {
// 1.. -> skip header
mark_node_trees_string.push_str(&tree_as_string(*mark_id, &ed_model.markup_node_pool));
mark_node_trees_string.push_str(&tree_as_string(*mark_id, &ed_model.mark_node_pool));
mark_node_trees_string.push('\n');
}
@ -47,14 +47,14 @@ pub fn build_debug_graphics(
.with_color(colors::to_slice(from_hsb(266, 31, 96)))
.with_scale(config.code_font_size);
let mark_node_pool_text = glyph_brush::OwnedText::new(format!("{}", ed_model.markup_node_pool))
let mark_node_pool_text = glyph_brush::OwnedText::new(format!("{}", ed_model.mark_node_pool))
.with_color(colors::to_slice(from_hsb(110, 45, 82)))
.with_scale(config.code_font_size);
let mut ast_node_text_str = "AST:\n".to_owned();
for expr_id in ed_model.module.ast.expression_ids.iter() {
ast_node_text_str.push_str(&expr2_to_string(*expr_id, ed_model.module.env.pool))
for def_id in ed_model.module.ast.def_ids.iter() {
ast_node_text_str.push_str(&def2_to_string(*def_id, ed_model.module.env.pool))
}
let ast_node_text = glyph_brush::OwnedText::new(ast_node_text_str)

5
editor/src/editor/resources/strings.rs
View file

@ -15,8 +15,9 @@ app "test-app"
imports []
provides [ main ] to base
main = "Hello, world!"
main = "Hello Main"
mars = "Yo Mars!"
yolo = "Hello, world!"
"#;

32
editor/src/lang/ast.rs
View file

@ -224,6 +224,17 @@ pub enum Expr2 {
RuntimeError(/* TODO make a version of RuntimeError that fits in 15B */),
}
// A top level definition, not inside a function. For example: `main = "Hello, world!"`
#[derive(Debug)]
pub enum Def2 {
// ValueDef example: `main = "Hello, world!"`. identifier -> `main`, expr -> "Hello, world!"
ValueDef {
identifier_id: NodeId<Pattern2>,
expr_id: NodeId<Expr2>,
},
Blank
}
#[derive(Debug)]
pub enum ValueDef {
WithAnnotation {
@ -431,6 +442,8 @@ pub struct WhenBranch {
// TODO make the inner types private?
pub type ExprId = NodeId<Expr2>;
pub type DefId = NodeId<Def2>;
use RecordField::*;
impl RecordField {
pub fn get_record_field_var(&self) -> &Variable {
@ -593,6 +606,25 @@ fn expr2_to_string_helper(
out_string.push('\n');
}
pub fn def2_to_string(node_id: DefId, pool: &Pool) -> String {
let mut full_string = String::new();
let def2 = pool.get(node_id);
match def2 {
Def2::ValueDef { identifier_id, expr_id } => {
full_string.push_str(&format!(
"Def2::ValueDef(identifier_id: >>{:?}), expr_id: >>{:?})",
pool.get(*identifier_id), expr2_to_string(*expr_id, pool)
));
},
Def2::Blank => {
full_string.push_str(&format!("Def2::Blank"));
}
}
full_string
}
fn var_to_string(some_var: &Variable, indent_level: usize) -> String {
format!("{}Var({:?})\n", get_spacing(indent_level + 1), some_var)
}

53
editor/src/lang/expr.rs
View file

@ -5,10 +5,7 @@ use bumpalo::{collections::Vec as BumpVec, Bump};
use std::collections::HashMap;
use std::iter::FromIterator;
use crate::lang::ast::{
expr2_to_string, ClosureExtra, Expr2, ExprId, FloatVal, IntStyle, IntVal, RecordField,
ValueDef, WhenBranch,
};
use crate::lang::ast::{ClosureExtra, Def2, Expr2, ExprId, FloatVal, IntStyle, IntVal, RecordField, ValueDef, WhenBranch, expr2_to_string, value_def_to_string};
use crate::lang::def::{
canonicalize_defs, sort_can_defs, CanDefs, Declaration, Def, PendingDef, References,
};
@ -289,15 +286,15 @@ pub fn to_expr_id<'a>(
(env.add(expr, region), output)
}
pub fn str_to_expr2_w_defs<'a>(
pub fn str_to_def2<'a>(
arena: &'a Bump,
input: &'a str,
env: &mut Env<'a>,
scope: &mut Scope,
region: Region,
) -> Result<Vec<Expr2>, SyntaxError<'a>> {
) -> Result<Vec<Def2>, SyntaxError<'a>> {
match roc_parse::test_helpers::parse_defs_with(arena, input.trim()) {
Ok(vec_loc_def) => Ok(to_expr2_from_defs(
Ok(vec_loc_def) => Ok(defs_to_defs2(
arena,
env,
scope,
@ -990,38 +987,39 @@ pub fn to_expr2<'a>(
}
}
pub fn to_expr2_from_defs<'a>(
pub fn defs_to_defs2<'a>(
arena: &'a Bump,
env: &mut Env<'a>,
scope: &mut Scope,
parsed_defs: &'a BumpVec<roc_region::all::Loc<roc_parse::ast::Def<'a>>>,
region: Region,
) -> Vec<Expr2> {
) -> Vec<Def2> {
use roc_parse::ast::Expr::*;
parsed_defs
.iter()
.map(|loc| to_expr2_from_def(arena, env, scope, &loc.value, region))
.map(|loc| to_def2_from_def(arena, env, scope, &loc.value, region))
.collect()
}
pub fn to_expr2_from_def<'a>(
pub fn to_def2_from_def<'a>(
arena: &'a Bump,
env: &mut Env<'a>,
scope: &mut Scope,
parsed_def: &'a roc_parse::ast::Def<'a>,
region: Region,
) -> Expr2 {
) -> Def2 {
use roc_parse::ast::Def::*;
match parsed_def {
SpaceBefore(inner_def, _) => to_expr2_from_def(arena, env, scope, inner_def, region),
SpaceAfter(inner_def, _) => to_expr2_from_def(arena, env, scope, inner_def, region),
SpaceBefore(inner_def, _) => to_def2_from_def(arena, env, scope, inner_def, region),
SpaceAfter(inner_def, _) => to_def2_from_def(arena, env, scope, inner_def, region),
Body(&loc_pattern, &loc_expr) => {
// TODO loc_pattern use identifier
let body_expr2 = loc_expr_to_expr2(arena, loc_expr, env, scope, region).0;
let body_expr_id = env.pool.add(body_expr2);
let expr2 = loc_expr_to_expr2(arena, loc_expr, env, scope, region).0;
dbg!(&expr2);
let expr_id = env.pool.add(expr2);
dbg!(expr_id);
use roc_parse::ast::Pattern::*;
@ -1037,24 +1035,9 @@ pub fn to_expr2_from_def<'a>(
let pattern_id = env.pool.add(pattern2);
// TODO support with annotation
let value_def = ValueDef::NoAnnotation {
pattern_id,
expr_id: body_expr_id,
expr_var: env.var_store.fresh(),
};
let value_def_id = env.pool.add(value_def);
let ident_id = env.ident_ids.add(str_ref.into());
dbg!(ident_id);
let var_symbol = Symbol::new(env.home, ident_id);
let body = Expr2::Var(var_symbol);
let body_id = env.pool.add(body);
Expr2::LetValue {
def_id: value_def_id,
body_var: env.var_store.fresh(),
body_id,
Def2::ValueDef {
identifier_id: pattern_id,
expr_id,
}
}
other => {

59
editor/src/lang/parse.rs
View file

@ -1,19 +1,54 @@
use crate::lang::scope::Scope;
use std::fmt::Debug;
use crate::{editor::ed_error::EdResult, editor::ed_error::ASTNodeIdWithoutExprId,lang::scope::Scope};
use bumpalo::Bump;
use roc_parse::parser::SyntaxError;
use roc_region::all::Region;
use super::{
ast::{Expr2, ExprId},
expr::{str_to_expr2_w_defs, Env},
};
use super::{ast::{DefId, Expr2, ExprId}, expr::{str_to_def2, Env}, pool::Pool};
// WORK IN PROGRESS FILE
#[derive(Debug)]
pub struct AST {
pub header: AppHeader,
pub expression_ids: Vec<ExprId>,
pub def_ids: Vec<DefId>,
}
#[derive(Debug)]
pub struct ASTNodeId {
pub def_id_opt: Option<DefId>,
pub expr_id_opt: Option<ExprId>,
}
impl ASTNodeId {
pub fn to_expr_id(&self) -> EdResult<ExprId>{
if let Some(expr_id) = self.expr_id_opt {
Ok(expr_id)
} else {
ASTNodeIdWithoutExprId {
ast_node_id: self
}.fail()
}
}
pub fn equals(&self, other: &ASTNodeId) -> bool {
if let Some(def_id_self) = self.def_id_opt {
if let Some(def_id_other) = other.def_id_opt {
def_id_self == def_id_other
} else {
false
}
} else if let Some(expr_id_self) = self.expr_id_opt {
if let Some(expr_id_other) = other.expr_id_opt {
expr_id_self == expr_id_other
} else {
false
}
} else {
unreachable!()
}
}
}
#[derive(Debug)]
@ -41,21 +76,21 @@ impl AST {
let mut scope = Scope::new(env.home, env.pool, env.var_store);
let region = Region::new(0, 0, 0, 0);
let mut expression_ids = Vec::<ExprId>::new();
let mut def_ids = Vec::<DefId>::new();
let expr2_vec = str_to_expr2_w_defs(ast_arena, tail_str, env, &mut scope, region)?;
let def2_vec = str_to_def2(ast_arena, tail_str, env, &mut scope, region)?;
for expr2 in expr2_vec {
let expr_id = env.pool.add(expr2);
for def2 in def2_vec {
let def_id = env.pool.add(def2);
expression_ids.push(expr_id);
def_ids.push(def_id);
}
let ast_node_id = env.pool.add(Expr2::Blank);
Ok(AST {
header: AppHeader::parse_from_string(header_str, ast_node_id),
expression_ids,
def_ids,
})
}
}