language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-02 19:32:17 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Pass var_store into desugar_expr so that desugaring may generate fresh vars

Browse source
This commit is contained in:
Elias Mulhall 2024-08-26 14:07:12 -04:00
parent dc5c8aeaf9
commit a16f757164
5 changed files with 412 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

492
crates/compiler/can/src/desugar.rs
View file

@ -14,6 +14,7 @@ use roc_parse::ast::{
}; };
use roc_problem::can::Problem; use roc_problem::can::Problem;
use roc_region::all::{LineInfo, Loc, Region}; use roc_region::all::{LineInfo, Loc, Region};
use roc_types::subs::VarStore;
// BinOp precedence logic adapted from Gluon by Markus Westerlind // BinOp precedence logic adapted from Gluon by Markus Westerlind
// https://github.com/gluon-lang/gluon - license information can be found in // https://github.com/gluon-lang/gluon - license information can be found in
@ -71,6 +72,7 @@ fn new_op_call_expr<'a>(
fn desugar_value_def<'a>( fn desugar_value_def<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
def: &'a ValueDef<'a>, def: &'a ValueDef<'a>,
src: &'a str, src: &'a str,
line_info: &mut Option<LineInfo>, line_info: &mut Option<LineInfo>,
@ -81,8 +83,24 @@ fn desugar_value_def<'a>(
match def { match def {
Body(loc_pattern, loc_expr) => Body( Body(loc_pattern, loc_expr) => Body(
desugar_loc_pattern(arena, loc_pattern, src, line_info, module_path, problems), desugar_loc_pattern(
desugar_expr(arena, loc_expr, src, line_info, module_path, problems), arena,
var_store,
loc_pattern,
src,
line_info,
module_path,
problems,
),
desugar_expr(
arena,
var_store,
loc_expr,
src,
line_info,
module_path,
problems,
),
), ),
ann @ Annotation(_, _) => *ann, ann @ Annotation(_, _) => *ann,
AnnotatedBody { AnnotatedBody {
@ -97,13 +115,22 @@ fn desugar_value_def<'a>(
lines_between, lines_between,
body_pattern: desugar_loc_pattern( body_pattern: desugar_loc_pattern(
arena, arena,
var_store,
body_pattern, body_pattern,
src, src,
line_info, line_info,
module_path, module_path,
problems, problems,
), ),
body_expr: desugar_expr(arena, body_expr, src, line_info, module_path, problems), body_expr: desugar_expr(
arena,
var_store,
body_expr,
src,
line_info,
module_path,
problems,
),
}, },
Dbg { Dbg {
@ -112,6 +139,7 @@ fn desugar_value_def<'a>(
} => { } => {
let desugared_condition = &*arena.alloc(desugar_expr( let desugared_condition = &*arena.alloc(desugar_expr(
arena, arena,
var_store,
condition, condition,
src, src,
line_info, line_info,
@ -129,6 +157,7 @@ fn desugar_value_def<'a>(
} => { } => {
let desugared_condition = &*arena.alloc(desugar_expr( let desugared_condition = &*arena.alloc(desugar_expr(
arena, arena,
var_store,
condition, condition,
src, src,
line_info, line_info,
@ -146,6 +175,7 @@ fn desugar_value_def<'a>(
} => { } => {
let desugared_condition = &*arena.alloc(desugar_expr( let desugared_condition = &*arena.alloc(desugar_expr(
arena, arena,
var_store,
condition, condition,
src, src,
line_info, line_info,
@ -170,6 +200,7 @@ fn desugar_value_def<'a>(
params: params.map(|params| { params: params.map(|params| {
desugar_field_collection( desugar_field_collection(
arena, arena,
var_store,
*params, *params,
src, src,
line_info, line_info,
@ -208,14 +239,24 @@ fn desugar_value_def<'a>(
)), )),
lines_between: &[], lines_between: &[],
body_pattern: new_pat, body_pattern: new_pat,
body_expr: desugar_expr(arena, stmt_expr, src, line_info, module_path, problems), body_expr: desugar_expr(
arena,
var_store,
stmt_expr,
src,
line_info,
module_path,
problems,
),
} }
} }
} }
} }
#[allow(clippy::too_many_arguments)]
pub fn desugar_defs_node_values<'a>( pub fn desugar_defs_node_values<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
defs: &mut roc_parse::ast::Defs<'a>, defs: &mut roc_parse::ast::Defs<'a>,
src: &'a str, src: &'a str,
line_info: &mut Option<LineInfo>, line_info: &mut Option<LineInfo>,
@ -226,6 +267,7 @@ pub fn desugar_defs_node_values<'a>(
for value_def in defs.value_defs.iter_mut() { for value_def in defs.value_defs.iter_mut() {
*value_def = desugar_value_def( *value_def = desugar_value_def(
arena, arena,
var_store,
arena.alloc(*value_def), arena.alloc(*value_def),
src, src,
line_info, line_info,
@ -350,6 +392,7 @@ pub fn desugar_value_def_suffixed<'a>(arena: &'a Bump, value_def: ValueDef<'a>)
/// then replace the BinOp nodes with Apply nodes. Also drop SpaceBefore and SpaceAfter nodes. /// then replace the BinOp nodes with Apply nodes. Also drop SpaceBefore and SpaceAfter nodes.
pub fn desugar_expr<'a>( pub fn desugar_expr<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
loc_expr: &'a Loc<Expr<'a>>, loc_expr: &'a Loc<Expr<'a>>,
src: &'a str, src: &'a str,
line_info: &mut Option<LineInfo>, line_info: &mut Option<LineInfo>,
@ -383,6 +426,7 @@ pub fn desugar_expr<'a>(
let region = loc_expr.region; let region = loc_expr.region;
let value = Str(StrLiteral::Line(desugar_str_segments( let value = Str(StrLiteral::Line(desugar_str_segments(
arena, arena,
var_store,
segments, segments,
src, src,
line_info, line_info,
@ -396,7 +440,15 @@ pub fn desugar_expr<'a>(
let region = loc_expr.region; let region = loc_expr.region;
let new_lines = Vec::from_iter_in( let new_lines = Vec::from_iter_in(
lines.iter().map(|segments| { lines.iter().map(|segments| {
desugar_str_segments(arena, segments, src, line_info, module_path, problems) desugar_str_segments(
arena,
var_store,
segments,
src,
line_info,
module_path,
problems,
)
}), }),
arena, arena,
); );
@ -415,6 +467,7 @@ pub fn desugar_expr<'a>(
let value = TupleAccess( let value = TupleAccess(
&desugar_expr( &desugar_expr(
arena, arena,
var_store,
arena.alloc(loc_sub_expr), arena.alloc(loc_sub_expr),
src, src,
line_info, line_info,
@ -434,8 +487,15 @@ pub fn desugar_expr<'a>(
target, target,
} => { } => {
let intermediate = arena.alloc(Loc::at(loc_expr.region, **sub_expr)); let intermediate = arena.alloc(Loc::at(loc_expr.region, **sub_expr));
let new_sub_loc_expr = let new_sub_loc_expr = desugar_expr(
desugar_expr(arena, intermediate, src, line_info, module_path, problems); arena,
var_store,
intermediate,
src,
line_info,
module_path,
problems,
);
let new_sub_expr = arena.alloc(new_sub_loc_expr.value); let new_sub_expr = arena.alloc(new_sub_loc_expr.value);
arena.alloc(Loc::at( arena.alloc(Loc::at(
@ -455,6 +515,7 @@ pub fn desugar_expr<'a>(
let value = RecordAccess( let value = RecordAccess(
&desugar_expr( &desugar_expr(
arena, arena,
var_store,
arena.alloc(loc_sub_expr), arena.alloc(loc_sub_expr),
src, src,
line_info, line_info,
@ -473,6 +534,7 @@ pub fn desugar_expr<'a>(
for item in items.iter() { for item in items.iter() {
new_items.push(desugar_expr( new_items.push(desugar_expr(
arena, arena,
var_store,
item, item,
src, src,
line_info, line_info,
@ -489,8 +551,15 @@ pub fn desugar_expr<'a>(
}) })
} }
Record(fields) => { Record(fields) => {
let fields = let fields = desugar_field_collection(
desugar_field_collection(arena, *fields, src, line_info, module_path, problems); arena,
var_store,
*fields,
src,
line_info,
module_path,
problems,
);
arena.alloc(Loc { arena.alloc(Loc {
region: loc_expr.region, region: loc_expr.region,
value: Record(fields), value: Record(fields),
@ -499,7 +568,15 @@ pub fn desugar_expr<'a>(
Tuple(fields) => { Tuple(fields) => {
let mut allocated = Vec::with_capacity_in(fields.len(), arena); let mut allocated = Vec::with_capacity_in(fields.len(), arena);
for field in fields.iter() { for field in fields.iter() {
let expr = desugar_expr(arena, field, src, line_info, module_path, problems); let expr = desugar_expr(
arena,
var_store,
field,
src,
line_info,
module_path,
problems,
);
allocated.push(expr); allocated.push(expr);
} }
let fields = fields.replace_items(allocated.into_bump_slice()); let fields = fields.replace_items(allocated.into_bump_slice());
@ -511,12 +588,27 @@ pub fn desugar_expr<'a>(
RecordUpdate { fields, update } => { RecordUpdate { fields, update } => {
// NOTE the `update` field is always a `Var { .. }`, we only desugar it to get rid of // NOTE the `update` field is always a `Var { .. }`, we only desugar it to get rid of
// any spaces before/after // any spaces before/after
let new_update = desugar_expr(arena, update, src, line_info, module_path, problems); let new_update = desugar_expr(
arena,
var_store,
update,
src,
line_info,
module_path,
problems,
);
let mut allocated = Vec::with_capacity_in(fields.len(), arena); let mut allocated = Vec::with_capacity_in(fields.len(), arena);
for field in fields.iter() { for field in fields.iter() {
let value = let value = desugar_field(
desugar_field(arena, &field.value, src, line_info, module_path, problems); arena,
var_store,
&field.value,
src,
line_info,
module_path,
problems,
);
allocated.push(Loc { allocated.push(Loc {
value, value,
region: field.region, region: field.region,
@ -589,8 +681,24 @@ pub fn desugar_expr<'a>(
Closure(loc_patterns, loc_ret) => arena.alloc(Loc { Closure(loc_patterns, loc_ret) => arena.alloc(Loc {
region: loc_expr.region, region: loc_expr.region,
value: Closure( value: Closure(
desugar_loc_patterns(arena, loc_patterns, src, line_info, module_path, problems), desugar_loc_patterns(
desugar_expr(arena, loc_ret, src, line_info, module_path, problems), arena,
var_store,
loc_patterns,
src,
line_info,
module_path,
problems,
),
desugar_expr(
arena,
var_store,
loc_ret,
src,
line_info,
module_path,
problems,
),
), ),
}), }),
Backpassing(loc_patterns, loc_body, loc_ret) => { Backpassing(loc_patterns, loc_body, loc_ret) => {
@ -605,12 +713,34 @@ pub fn desugar_expr<'a>(
problems.push(Problem::DeprecatedBackpassing(problem_region)); problems.push(Problem::DeprecatedBackpassing(problem_region));
// first desugar the body, because it may contain |> // first desugar the body, because it may contain |>
let desugared_body = let desugared_body = desugar_expr(
desugar_expr(arena, loc_body, src, line_info, module_path, problems); arena,
var_store,
loc_body,
src,
line_info,
module_path,
problems,
);
let desugared_ret = desugar_expr(arena, loc_ret, src, line_info, module_path, problems); let desugared_ret = desugar_expr(
let desugared_loc_patterns = arena,
desugar_loc_patterns(arena, loc_patterns, src, line_info, module_path, problems); var_store,
loc_ret,
src,
line_info,
module_path,
problems,
);
let desugared_loc_patterns = desugar_loc_patterns(
arena,
var_store,
loc_patterns,
src,
line_info,
module_path,
problems,
);
let closure = Expr::Closure(desugared_loc_patterns, desugared_ret); let closure = Expr::Closure(desugared_loc_patterns, desugared_ret);
let loc_closure = Loc::at(loc_expr.region, closure); let loc_closure = Loc::at(loc_expr.region, closure);
@ -646,7 +776,15 @@ pub fn desugar_expr<'a>(
RecordBuilder { mapper, fields } => { RecordBuilder { mapper, fields } => {
// NOTE the `mapper` is always a `Var { .. }`, we only desugar it to get rid of // NOTE the `mapper` is always a `Var { .. }`, we only desugar it to get rid of
// any spaces before/after // any spaces before/after
let new_mapper = desugar_expr(arena, mapper, src, line_info, module_path, problems); let new_mapper = desugar_expr(
arena,
var_store,
mapper,
src,
line_info,
module_path,
problems,
);
if fields.is_empty() { if fields.is_empty() {
return arena.alloc(Loc { return arena.alloc(Loc {
@ -669,37 +807,42 @@ pub fn desugar_expr<'a>(
let mut field_data = Vec::with_capacity_in(fields.len(), arena); let mut field_data = Vec::with_capacity_in(fields.len(), arena);
for field in fields.items { for field in fields.items {
let (name, value, ignored) = let desugared_field = desugar_field(
match desugar_field(arena, &field.value, src, line_info, module_path, problems) arena,
{ var_store,
AssignedField::RequiredValue(loc_name, _, loc_val) => { &field.value,
(loc_name, loc_val, false) src,
} line_info,
AssignedField::IgnoredValue(loc_name, _, loc_val) => { module_path,
(loc_name, loc_val, true) problems,
} );
AssignedField::LabelOnly(loc_name) => ( let (name, value, ignored) = match desugared_field {
loc_name, AssignedField::RequiredValue(loc_name, _, loc_val) => {
&*arena.alloc(Loc { (loc_name, loc_val, false)
region: loc_name.region, }
value: Expr::Var { AssignedField::IgnoredValue(loc_name, _, loc_val) => (loc_name, loc_val, true),
module_name: "", AssignedField::LabelOnly(loc_name) => (
ident: loc_name.value, loc_name,
}, &*arena.alloc(Loc {
}), region: loc_name.region,
false, value: Expr::Var {
), module_name: "",
AssignedField::OptionalValue(loc_name, _, loc_val) => { ident: loc_name.value,
return arena.alloc(Loc { },
region: loc_expr.region, }),
value: OptionalFieldInRecordBuilder(arena.alloc(loc_name), loc_val), false,
}); ),
} AssignedField::OptionalValue(loc_name, _, loc_val) => {
AssignedField::SpaceBefore(_, _) | AssignedField::SpaceAfter(_, _) => { return arena.alloc(Loc {
unreachable!("Should have been desugared in `desugar_field`") region: loc_expr.region,
} value: OptionalFieldInRecordBuilder(arena.alloc(loc_name), loc_val),
AssignedField::Malformed(_name) => continue, });
}; }
AssignedField::SpaceBefore(_, _) | AssignedField::SpaceAfter(_, _) => {
unreachable!("Should have been desugared in `desugar_field`")
}
AssignedField::Malformed(_name) => continue,
};
field_data.push(FieldData { field_data.push(FieldData {
name, name,
@ -903,6 +1046,7 @@ pub fn desugar_expr<'a>(
} }
BinOps(lefts, right) => desugar_bin_ops( BinOps(lefts, right) => desugar_bin_ops(
arena, arena,
var_store,
loc_expr.region, loc_expr.region,
lefts, lefts,
right, right,
@ -915,6 +1059,7 @@ pub fn desugar_expr<'a>(
let mut defs = (*defs).clone(); let mut defs = (*defs).clone();
desugar_defs_node_values( desugar_defs_node_values(
arena, arena,
var_store,
&mut defs, &mut defs,
src, src,
line_info, line_info,
@ -922,7 +1067,15 @@ pub fn desugar_expr<'a>(
false, false,
problems, problems,
); );
let loc_ret = desugar_expr(arena, loc_ret, src, line_info, module_path, problems); let loc_ret = desugar_expr(
arena,
var_store,
loc_ret,
src,
line_info,
module_path,
problems,
);
arena.alloc(Loc::at(loc_expr.region, Defs(arena.alloc(defs), loc_ret))) arena.alloc(Loc::at(loc_expr.region, Defs(arena.alloc(defs), loc_ret)))
} }
@ -956,6 +1109,7 @@ pub fn desugar_expr<'a>(
desugared_args.push(desugar_expr( desugared_args.push(desugar_expr(
arena, arena,
var_store,
arg, arg,
src, src,
line_info, line_info,
@ -968,7 +1122,15 @@ pub fn desugar_expr<'a>(
let mut apply: &Loc<Expr> = arena.alloc(Loc { let mut apply: &Loc<Expr> = arena.alloc(Loc {
value: Apply( value: Apply(
desugar_expr(arena, loc_fn, src, line_info, module_path, problems), desugar_expr(
arena,
var_store,
loc_fn,
src,
line_info,
module_path,
problems,
),
desugared_args, desugared_args,
*called_via, *called_via,
), ),
@ -980,8 +1142,15 @@ pub fn desugar_expr<'a>(
Some(apply_exprs) => { Some(apply_exprs) => {
for expr in apply_exprs { for expr in apply_exprs {
let desugared_expr = let desugared_expr = desugar_expr(
desugar_expr(arena, expr, src, line_info, module_path, problems); arena,
var_store,
expr,
src,
line_info,
module_path,
problems,
);
let args = std::slice::from_ref(arena.alloc(apply)); let args = std::slice::from_ref(arena.alloc(apply));
@ -998,6 +1167,7 @@ pub fn desugar_expr<'a>(
When(loc_cond_expr, branches) => { When(loc_cond_expr, branches) => {
let loc_desugared_cond = &*arena.alloc(desugar_expr( let loc_desugared_cond = &*arena.alloc(desugar_expr(
arena, arena,
var_store,
loc_cond_expr, loc_cond_expr,
src, src,
line_info, line_info,
@ -1007,10 +1177,18 @@ pub fn desugar_expr<'a>(
let mut desugared_branches = Vec::with_capacity_in(branches.len(), arena); let mut desugared_branches = Vec::with_capacity_in(branches.len(), arena);
for branch in branches.iter() { for branch in branches.iter() {
let desugared_expr = let desugared_expr = desugar_expr(
desugar_expr(arena, &branch.value, src, line_info, module_path, problems); arena,
var_store,
&branch.value,
src,
line_info,
module_path,
problems,
);
let desugared_patterns = desugar_loc_patterns( let desugared_patterns = desugar_loc_patterns(
arena, arena,
var_store,
branch.patterns, branch.patterns,
src, src,
line_info, line_info,
@ -1021,6 +1199,7 @@ pub fn desugar_expr<'a>(
let desugared_guard = if let Some(guard) = &branch.guard { let desugared_guard = if let Some(guard) = &branch.guard {
Some(*desugar_expr( Some(*desugar_expr(
arena, arena,
var_store,
guard, guard,
src, src,
line_info, line_info,
@ -1066,6 +1245,7 @@ pub fn desugar_expr<'a>(
let loc_fn_var = arena.alloc(Loc { region, value }); let loc_fn_var = arena.alloc(Loc { region, value });
let desugared_args = arena.alloc([desugar_expr( let desugared_args = arena.alloc([desugar_expr(
arena, arena,
var_store,
loc_arg, loc_arg,
src, src,
line_info, line_info,
@ -1083,6 +1263,7 @@ pub fn desugar_expr<'a>(
// are no longer needed and should be dropped. // are no longer needed and should be dropped.
desugar_expr( desugar_expr(
arena, arena,
var_store,
arena.alloc(Loc { arena.alloc(Loc {
value: **expr, value: **expr,
region: loc_expr.region, region: loc_expr.region,
@ -1096,6 +1277,7 @@ pub fn desugar_expr<'a>(
ParensAround(expr) => { ParensAround(expr) => {
let desugared = desugar_expr( let desugared = desugar_expr(
arena, arena,
var_store,
arena.alloc(Loc { arena.alloc(Loc {
value: **expr, value: **expr,
region: loc_expr.region, region: loc_expr.region,
@ -1115,6 +1297,7 @@ pub fn desugar_expr<'a>(
// If does not get desugared into `when` so we can give more targeted error messages during type checking. // If does not get desugared into `when` so we can give more targeted error messages during type checking.
let desugared_final_else = &*arena.alloc(desugar_expr( let desugared_final_else = &*arena.alloc(desugar_expr(
arena, arena,
var_store,
final_else_branch, final_else_branch,
src, src,
line_info, line_info,
@ -1125,10 +1308,26 @@ pub fn desugar_expr<'a>(
let mut desugared_if_thens = Vec::with_capacity_in(if_thens.len(), arena); let mut desugared_if_thens = Vec::with_capacity_in(if_thens.len(), arena);
for (condition, then_branch) in if_thens.iter() { for (condition, then_branch) in if_thens.iter() {
desugared_if_thens.push(( let desugared_condition = *desugar_expr(
*desugar_expr(arena, condition, src, line_info, module_path, problems), arena,
*desugar_expr(arena, then_branch, src, line_info, module_path, problems), var_store,
)); condition,
src,
line_info,
module_path,
problems,
);
let desugared_then_branch = *desugar_expr(
arena,
var_store,
then_branch,
src,
line_info,
module_path,
problems,
);
desugared_if_thens.push((desugared_condition, desugared_then_branch));
} }
arena.alloc(Loc { arena.alloc(Loc {
@ -1139,6 +1338,7 @@ pub fn desugar_expr<'a>(
Expect(condition, continuation) => { Expect(condition, continuation) => {
let desugared_condition = &*arena.alloc(desugar_expr( let desugared_condition = &*arena.alloc(desugar_expr(
arena, arena,
var_store,
condition, condition,
src, src,
line_info, line_info,
@ -1147,6 +1347,7 @@ pub fn desugar_expr<'a>(
)); ));
let desugared_continuation = &*arena.alloc(desugar_expr( let desugared_continuation = &*arena.alloc(desugar_expr(
arena, arena,
var_store,
continuation, continuation,
src, src,
line_info, line_info,
@ -1163,6 +1364,7 @@ pub fn desugar_expr<'a>(
// Inspect.toStr x |> LowLevelDbg // Inspect.toStr x |> LowLevelDbg
let desugared_continuation = &*arena.alloc(desugar_expr( let desugared_continuation = &*arena.alloc(desugar_expr(
arena, arena,
var_store,
continuation, continuation,
src, src,
line_info, line_info,
@ -1182,6 +1384,7 @@ pub fn desugar_expr<'a>(
}); });
let desugared_inspect_args = arena.alloc([desugar_expr( let desugared_inspect_args = arena.alloc([desugar_expr(
arena, arena,
var_store,
condition, condition,
src, src,
line_info, line_info,
@ -1228,6 +1431,7 @@ pub fn desugar_expr<'a>(
fn desugar_str_segments<'a>( fn desugar_str_segments<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
segments: &'a [StrSegment<'a>], segments: &'a [StrSegment<'a>],
src: &'a str, src: &'a str,
line_info: &mut Option<LineInfo>, line_info: &mut Option<LineInfo>,
@ -1242,6 +1446,7 @@ fn desugar_str_segments<'a>(
StrSegment::DeprecatedInterpolated(loc_expr) => { StrSegment::DeprecatedInterpolated(loc_expr) => {
let loc_desugared = desugar_expr( let loc_desugared = desugar_expr(
arena, arena,
var_store,
arena.alloc(Loc { arena.alloc(Loc {
region: loc_expr.region, region: loc_expr.region,
value: *loc_expr.value, value: *loc_expr.value,
@ -1259,6 +1464,7 @@ fn desugar_str_segments<'a>(
StrSegment::Interpolated(loc_expr) => { StrSegment::Interpolated(loc_expr) => {
let loc_desugared = desugar_expr( let loc_desugared = desugar_expr(
arena, arena,
var_store,
arena.alloc(Loc { arena.alloc(Loc {
region: loc_expr.region, region: loc_expr.region,
value: *loc_expr.value, value: *loc_expr.value,
@ -1281,6 +1487,7 @@ fn desugar_str_segments<'a>(
fn desugar_field_collection<'a>( fn desugar_field_collection<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
fields: Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>, fields: Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>,
src: &'a str, src: &'a str,
line_info: &mut Option<LineInfo>, line_info: &mut Option<LineInfo>,
@ -1290,7 +1497,15 @@ fn desugar_field_collection<'a>(
let mut allocated = Vec::with_capacity_in(fields.len(), arena); let mut allocated = Vec::with_capacity_in(fields.len(), arena);
for field in fields.iter() { for field in fields.iter() {
let value = desugar_field(arena, &field.value, src, line_info, module_path, problems); let value = desugar_field(
arena,
var_store,
&field.value,
src,
line_info,
module_path,
problems,
);
allocated.push(Loc::at(field.region, value)); allocated.push(Loc::at(field.region, value));
} }
@ -1300,6 +1515,7 @@ fn desugar_field_collection<'a>(
fn desugar_field<'a>( fn desugar_field<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
field: &'a AssignedField<'a, Expr<'a>>, field: &'a AssignedField<'a, Expr<'a>>,
src: &'a str, src: &'a str,
line_info: &mut Option<LineInfo>, line_info: &mut Option<LineInfo>,
@ -1315,7 +1531,15 @@ fn desugar_field<'a>(
region: loc_str.region, region: loc_str.region,
}, },
spaces, spaces,
desugar_expr(arena, loc_expr, src, line_info, module_path, problems), desugar_expr(
arena,
var_store,
loc_expr,
src,
line_info,
module_path,
problems,
),
), ),
OptionalValue(loc_str, spaces, loc_expr) => OptionalValue( OptionalValue(loc_str, spaces, loc_expr) => OptionalValue(
Loc { Loc {
@ -1323,7 +1547,15 @@ fn desugar_field<'a>(
region: loc_str.region, region: loc_str.region,
}, },
spaces, spaces,
desugar_expr(arena, loc_expr, src, line_info, module_path, problems), desugar_expr(
arena,
var_store,
loc_expr,
src,
line_info,
module_path,
problems,
),
), ),
IgnoredValue(loc_str, spaces, loc_expr) => IgnoredValue( IgnoredValue(loc_str, spaces, loc_expr) => IgnoredValue(
Loc { Loc {
@ -1331,7 +1563,15 @@ fn desugar_field<'a>(
region: loc_str.region, region: loc_str.region,
}, },
spaces, spaces,
desugar_expr(arena, loc_expr, src, line_info, module_path, problems), desugar_expr(
arena,
var_store,
loc_expr,
src,
line_info,
module_path,
problems,
),
), ),
LabelOnly(loc_str) => { LabelOnly(loc_str) => {
// Desugar { x } into { x: x } // Desugar { x } into { x: x }
@ -1351,6 +1591,7 @@ fn desugar_field<'a>(
&[], &[],
desugar_expr( desugar_expr(
arena, arena,
var_store,
arena.alloc(loc_expr), arena.alloc(loc_expr),
src, src,
line_info, line_info,
@ -1359,12 +1600,24 @@ fn desugar_field<'a>(
), ),
) )
} }
SpaceBefore(field, _spaces) => { SpaceBefore(field, _spaces) => desugar_field(
desugar_field(arena, field, src, line_info, module_path, problems) arena,
} var_store,
SpaceAfter(field, _spaces) => { field,
desugar_field(arena, field, src, line_info, module_path, problems) src,
} line_info,
module_path,
problems,
),
SpaceAfter(field, _spaces) => desugar_field(
arena,
var_store,
field,
src,
line_info,
module_path,
problems,
),
Malformed(string) => Malformed(string), Malformed(string) => Malformed(string),
} }
@ -1372,6 +1625,7 @@ fn desugar_field<'a>(
fn desugar_loc_patterns<'a>( fn desugar_loc_patterns<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
loc_patterns: &'a [Loc<Pattern<'a>>], loc_patterns: &'a [Loc<Pattern<'a>>],
src: &'a str, src: &'a str,
line_info: &mut Option<LineInfo>, line_info: &mut Option<LineInfo>,
@ -1383,6 +1637,7 @@ fn desugar_loc_patterns<'a>(
region: loc_pattern.region, region: loc_pattern.region,
value: desugar_pattern( value: desugar_pattern(
arena, arena,
var_store,
loc_pattern.value, loc_pattern.value,
src, src,
line_info, line_info,
@ -1397,6 +1652,7 @@ fn desugar_loc_patterns<'a>(
fn desugar_loc_pattern<'a>( fn desugar_loc_pattern<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
loc_pattern: &'a Loc<Pattern<'a>>, loc_pattern: &'a Loc<Pattern<'a>>,
src: &'a str, src: &'a str,
line_info: &mut Option<LineInfo>, line_info: &mut Option<LineInfo>,
@ -1407,6 +1663,7 @@ fn desugar_loc_pattern<'a>(
region: loc_pattern.region, region: loc_pattern.region,
value: desugar_pattern( value: desugar_pattern(
arena, arena,
var_store,
loc_pattern.value, loc_pattern.value,
src, src,
line_info, line_info,
@ -1418,6 +1675,7 @@ fn desugar_loc_pattern<'a>(
fn desugar_pattern<'a>( fn desugar_pattern<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
pattern: Pattern<'a>, pattern: Pattern<'a>,
src: &'a str, src: &'a str,
line_info: &mut Option<LineInfo>, line_info: &mut Option<LineInfo>,
@ -1448,6 +1706,7 @@ fn desugar_pattern<'a>(
region: arg_pattern.region, region: arg_pattern.region,
value: desugar_pattern( value: desugar_pattern(
arena, arena,
var_store,
arg_pattern.value, arg_pattern.value,
src, src,
line_info, line_info,
@ -1466,6 +1725,7 @@ fn desugar_pattern<'a>(
for field_pattern in field_patterns.iter() { for field_pattern in field_patterns.iter() {
let value = desugar_pattern( let value = desugar_pattern(
arena, arena,
var_store,
field_pattern.value, field_pattern.value,
src, src,
line_info, line_info,
@ -1483,17 +1743,40 @@ fn desugar_pattern<'a>(
} }
RequiredField(name, field_pattern) => RequiredField( RequiredField(name, field_pattern) => RequiredField(
name, name,
desugar_loc_pattern(arena, field_pattern, src, line_info, module_path, problems), desugar_loc_pattern(
arena,
var_store,
field_pattern,
src,
line_info,
module_path,
problems,
),
), ),
OptionalField(name, expr) => OptionalField( OptionalField(name, expr) => OptionalField(
name, name,
desugar_expr(arena, expr, src, line_info, module_path, problems), desugar_expr(
arena,
var_store,
expr,
src,
line_info,
module_path,
problems,
),
), ),
Tuple(patterns) => { Tuple(patterns) => {
let mut allocated = Vec::with_capacity_in(patterns.len(), arena); let mut allocated = Vec::with_capacity_in(patterns.len(), arena);
for pattern in patterns.iter() { for pattern in patterns.iter() {
let value = let value = desugar_pattern(
desugar_pattern(arena, pattern.value, src, line_info, module_path, problems); arena,
var_store,
pattern.value,
src,
line_info,
module_path,
problems,
);
allocated.push(Loc { allocated.push(Loc {
value, value,
region: pattern.region, region: pattern.region,
@ -1506,8 +1789,15 @@ fn desugar_pattern<'a>(
List(patterns) => { List(patterns) => {
let mut allocated = Vec::with_capacity_in(patterns.len(), arena); let mut allocated = Vec::with_capacity_in(patterns.len(), arena);
for pattern in patterns.iter() { for pattern in patterns.iter() {
let value = let value = desugar_pattern(
desugar_pattern(arena, pattern.value, src, line_info, module_path, problems); arena,
var_store,
pattern.value,
src,
line_info,
module_path,
problems,
);
allocated.push(Loc { allocated.push(Loc {
value, value,
region: pattern.region, region: pattern.region,
@ -1518,15 +1808,35 @@ fn desugar_pattern<'a>(
List(patterns) List(patterns)
} }
As(sub_pattern, symbol) => As( As(sub_pattern, symbol) => As(
desugar_loc_pattern(arena, sub_pattern, src, line_info, module_path, problems), desugar_loc_pattern(
arena,
var_store,
sub_pattern,
src,
line_info,
module_path,
problems,
),
symbol, symbol,
), ),
SpaceBefore(sub_pattern, _spaces) => { SpaceBefore(sub_pattern, _spaces) => desugar_pattern(
desugar_pattern(arena, *sub_pattern, src, line_info, module_path, problems) arena,
} var_store,
SpaceAfter(sub_pattern, _spaces) => { *sub_pattern,
desugar_pattern(arena, *sub_pattern, src, line_info, module_path, problems) src,
} line_info,
module_path,
problems,
),
SpaceAfter(sub_pattern, _spaces) => desugar_pattern(
arena,
var_store,
*sub_pattern,
src,
line_info,
module_path,
problems,
),
} }
} }
@ -1649,6 +1959,7 @@ fn binop_to_function(binop: BinOp) -> (&'static str, &'static str) {
#[allow(clippy::too_many_arguments)] #[allow(clippy::too_many_arguments)]
fn desugar_bin_ops<'a>( fn desugar_bin_ops<'a>(
arena: &'a Bump, arena: &'a Bump,
var_store: &mut VarStore,
whole_region: Region, whole_region: Region,
lefts: &'a [(Loc<Expr<'_>>, Loc<BinOp>)], lefts: &'a [(Loc<Expr<'_>>, Loc<BinOp>)],
right: &'a Loc<Expr<'_>>, right: &'a Loc<Expr<'_>>,
@ -1663,6 +1974,7 @@ fn desugar_bin_ops<'a>(
for (loc_expr, loc_op) in lefts { for (loc_expr, loc_op) in lefts {
arg_stack.push(desugar_expr( arg_stack.push(desugar_expr(
arena, arena,
var_store,
loc_expr, loc_expr,
src, src,
line_info, line_info,
@ -1675,7 +1987,15 @@ fn desugar_bin_ops<'a>(
} }
} }
let mut expr = desugar_expr(arena, right, src, line_info, module_path, problems); let mut expr = desugar_expr(
arena,
var_store,
right,
src,
line_info,
module_path,
problems,
);
for (left, loc_op) in arg_stack.into_iter().zip(op_stack.into_iter()).rev() { for (left, loc_op) in arg_stack.into_iter().zip(op_stack.into_iter()).rev() {
expr = arena.alloc(new_op_call_expr(arena, left, loc_op, expr)); expr = arena.alloc(new_op_call_expr(arena, left, loc_op, expr));

1
crates/compiler/can/src/module.rs
View file

@ -339,6 +339,7 @@ pub fn canonicalize_module_defs<'a>(
crate::desugar::desugar_defs_node_values( crate::desugar::desugar_defs_node_values(
arena, arena,
var_store,
loc_defs, loc_defs,
src, src,
&mut None, &mut None,

1
crates/compiler/can/tests/helpers/mod.rs
View file

@ -55,6 +55,7 @@ pub fn can_expr_with(arena: &Bump, home: ModuleId, expr_str: &str) -> CanExprOut
// rules multiple times unnecessarily. // rules multiple times unnecessarily.
let loc_expr = desugar::desugar_expr( let loc_expr = desugar::desugar_expr(
arena, arena,
&mut var_store,
&loc_expr, &loc_expr,
expr_str, expr_str,
&mut None, &mut None,

3
crates/compiler/can/tests/test_suffixed.rs
View file

@ -7,13 +7,16 @@ mod suffixed_tests {
use insta::assert_snapshot; use insta::assert_snapshot;
use roc_can::desugar::desugar_defs_node_values; use roc_can::desugar::desugar_defs_node_values;
use roc_parse::test_helpers::parse_defs_with; use roc_parse::test_helpers::parse_defs_with;
use roc_types::subs::VarStore;
macro_rules! run_test { macro_rules! run_test {
($src:expr) => {{ ($src:expr) => {{
let arena = &Bump::new(); let arena = &Bump::new();
let mut var_store = VarStore::default();
let mut defs = parse_defs_with(arena, indoc!($src)).unwrap(); let mut defs = parse_defs_with(arena, indoc!($src)).unwrap();
desugar_defs_node_values( desugar_defs_node_values(
arena, arena,
&mut var_store,
&mut defs, &mut defs,
$src, $src,
&mut None, &mut None,

1
crates/compiler/load/tests/helpers/mod.rs
View file

@ -170,6 +170,7 @@ pub fn can_expr_with<'a>(
// rules multiple times unnecessarily. // rules multiple times unnecessarily.
let loc_expr = desugar::desugar_expr( let loc_expr = desugar::desugar_expr(
arena, arena,
&mut var_store,
&loc_expr, &loc_expr,
expr_str, expr_str,
&mut None, &mut None,