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

update mono tests

Browse source
This commit is contained in:
Folkert 2022-07-08 16:19:12 +02:00
commit c0ace1ee0b
No known key found for this signature in database
GPG key ID: 1F17F6FFD112B97C
19 changed files with 274 additions and 228 deletions
Download patch file Download diff file Expand all files Collapse all files

127
crates/compiler/mono/src/ir.rs
View file

@ -7646,23 +7646,19 @@ fn call_by_name_help<'a>(
"see call_by_name for background (scroll down a bit), function is {:?}",
proc_name,
);
let field_symbols = field_symbols.into_bump_slice();
let call = self::Call {
call_type: CallType::ByName {
name: proc_name,
ret_layout,
arg_layouts: argument_layouts,
specialization_id: env.next_call_specialization_id(),
},
arguments: field_symbols,
};
let result = build_call(env, call, assigned, *ret_layout, hole);
let iter = loc_args.into_iter().rev().zip(field_symbols.iter().rev());
assign_to_symbols(env, procs, layout_cache, iter, result)
call_specialized_proc(
env,
procs,
proc_name,
lambda_set,
RawFunctionLayout::Function(argument_layouts, lambda_set, ret_layout),
top_level_layout,
field_symbols.into_bump_slice(),
loc_args,
layout_cache,
assigned,
hole,
)
} else if env.is_imported_symbol(proc_name.name()) {
add_needed_external(procs, env, original_fn_var, proc_name);
@ -7739,52 +7735,21 @@ fn call_by_name_help<'a>(
proc_name,
);
let has_captures = argument_layouts.len() != top_level_layout.arguments.len();
let closure_argument = env.unique_symbol();
if has_captures {
field_symbols.push(closure_argument);
}
let field_symbols = field_symbols.into_bump_slice();
let call = self::Call {
call_type: CallType::ByName {
name: proc_name,
ret_layout,
arg_layouts: top_level_layout.arguments,
specialization_id: env.next_call_specialization_id(),
},
arguments: field_symbols,
};
let result = build_call(env, call, assigned, *ret_layout, hole);
// NOTE: the zip omits the closure symbol, if it exists,
// because loc_args then is shorter than field_symbols
debug_assert!([0, 1].contains(&(field_symbols.len() - loc_args.len())));
let iter = loc_args.into_iter().zip(field_symbols.iter()).rev();
let result = assign_to_symbols(env, procs, layout_cache, iter, result);
if has_captures {
let partial_proc = procs.partial_procs.get_symbol(proc_name.name()).unwrap();
let captured = match partial_proc.captured_symbols {
CapturedSymbols::None => &[],
CapturedSymbols::Captured(slice) => slice,
};
construct_closure_data(
env,
lambda_set,
proc_name,
captured.iter(),
closure_argument,
env.arena.alloc(result),
)
} else {
result
}
call_specialized_proc(
env,
procs,
proc_name,
lambda_set,
RawFunctionLayout::Function(argument_layouts, lambda_set, ret_layout),
top_level_layout,
field_symbols,
loc_args,
layout_cache,
assigned,
hole,
)
}
PendingSpecializations::Making => {
let opt_partial_proc = procs.partial_procs.symbol_to_id(proc_name.name());
@ -7810,13 +7775,26 @@ fn call_by_name_help<'a>(
partial_proc,
) {
Ok((proc, layout)) => {
let proc_name = proc.name;
let function_layout = ProcLayout::from_raw(
env.arena,
layout,
proc_name.captures_niche(),
);
procs.specialized.insert_specialized(
proc_name.name(),
function_layout,
proc,
);
// now we just call our freshly-specialized function
call_specialized_proc(
env,
procs,
proc,
proc_name,
lambda_set,
layout,
function_layout,
field_symbols,
loc_args,
layout_cache,
@ -7831,12 +7809,25 @@ fn call_by_name_help<'a>(
attempted_layout,
);
let proc_name = proc.name;
let function_layout = ProcLayout::from_raw(
env.arena,
attempted_layout,
proc_name.captures_niche(),
);
procs.specialized.insert_specialized(
proc_name.name(),
function_layout,
proc,
);
call_specialized_proc(
env,
procs,
proc,
proc_name,
lambda_set,
attempted_layout,
function_layout,
field_symbols,
loc_args,
layout_cache,
@ -7985,22 +7976,16 @@ fn call_by_name_module_thunk<'a>(
fn call_specialized_proc<'a>(
env: &mut Env<'a, '_>,
procs: &mut Procs<'a>,
proc: Proc<'a>,
proc_name: LambdaName<'a>,
lambda_set: LambdaSet<'a>,
layout: RawFunctionLayout<'a>,
function_layout: ProcLayout<'a>,
field_symbols: &'a [Symbol],
loc_args: std::vec::Vec<(Variable, Loc<roc_can::expr::Expr>)>,
layout_cache: &mut LayoutCache<'a>,
assigned: Symbol,
hole: &'a Stmt<'a>,
) -> Stmt<'a> {
let proc_name = proc.name;
let function_layout = ProcLayout::from_raw(env.arena, layout, proc_name.captures_niche());
procs
.specialized
.insert_specialized(proc_name.name(), function_layout, proc);
if field_symbols.is_empty() {
debug_assert!(loc_args.is_empty());