language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-07-24 06:55:15 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Put the capture niche in the lambda name instead of generating new names

Browse source
This commit is contained in:
Ayaz Hafiz 2022-07-01 15:52:36 -04:00 • committed by ayazhafiz
parent 1ed2e1a8e9
commit 019ebd93f7
No known key found for this signature in database
GPG key ID: B443F7A3030C9AED
20 changed files with 592 additions and 486 deletions
Download patch file Download diff file Expand all files Collapse all files

49
crates/compiler/alias_analysis/src/lib.rs
View file

@ -23,11 +23,13 @@ pub const STATIC_LIST_NAME: ConstName = ConstName(b"THIS IS A STATIC LIST");
const ENTRY_POINT_NAME: &[u8] = b"mainForHost";
pub fn func_name_bytes(proc: &Proc) -> [u8; SIZE] {
func_name_bytes_help(
proc.name.call_name(),
let bytes = func_name_bytes_help(
proc.name.name(),
proc.args.iter().map(|x| x.0),
proc.name.captures_niche.iter().copied(),
&proc.ret_layout,
)
);
bytes
}
#[inline(always)]
@ -65,13 +67,15 @@ impl TagUnionId {
}
}
pub fn func_name_bytes_help<'a, I>(
pub fn func_name_bytes_help<'a, I1, I2>(
symbol: Symbol,
argument_layouts: I,
argument_layouts: I2,
captures_niche: I1,
return_layout: &Layout<'a>,
) -> [u8; SIZE]
where
I: IntoIterator<Item = Layout<'a>>,
I1: IntoIterator<Item = Layout<'a>>,
I2: IntoIterator<Item = Layout<'a>>,
{
let mut name_bytes = [0u8; SIZE];
@ -86,6 +90,10 @@ where
layout.hash(&mut hasher);
}
for capture_layout in captures_niche {
capture_layout.hash(&mut hasher);
}
return_layout.hash(&mut hasher);
hasher.finish()
@ -177,13 +185,17 @@ where
match layout {
RawFunctionLayout::Function(_, _, _) => {
let it = top_level.arguments.iter().copied();
let bytes = func_name_bytes_help(*symbol, it, &top_level.result);
let bytes = func_name_bytes_help(*symbol, it, [], &top_level.result);
host_exposed_functions.push((bytes, top_level.arguments));
}
RawFunctionLayout::ZeroArgumentThunk(_) => {
let bytes =
func_name_bytes_help(*symbol, [Layout::UNIT], &top_level.result);
let bytes = func_name_bytes_help(
*symbol,
[Layout::UNIT],
[],
&top_level.result,
);
host_exposed_functions.push((bytes, top_level.arguments));
}
@ -211,6 +223,7 @@ where
let roc_main_bytes = func_name_bytes_help(
entry_point.symbol,
entry_point.layout.arguments.iter().copied(),
std::iter::empty(),
&entry_point.layout.result,
);
let roc_main = FuncName(&roc_main_bytes);
@ -635,7 +648,7 @@ fn call_spec(
match &call.call_type {
ByName {
name: symbol,
name,
ret_layout,
arg_layouts,
specialization_id,
@ -644,8 +657,9 @@ fn call_spec(
let spec_var = CalleeSpecVar(&array);
let arg_value_id = build_tuple_value(builder, env, block, call.arguments)?;
let it = arg_layouts.iter().copied();
let bytes = func_name_bytes_help(*symbol, it, ret_layout);
let args_it = arg_layouts.iter().copied();
let captures_it = name.captures_niche.iter().copied();
let bytes = func_name_bytes_help(name.name(), args_it, captures_it, ret_layout);
let name = FuncName(&bytes);
let module = MOD_APP;
builder.add_call(block, spec_var, module, name, arg_value_id)
@ -688,9 +702,14 @@ fn call_spec(
let mode = update_mode.to_bytes();
let update_mode_var = UpdateModeVar(&mode);
let it = passed_function.argument_layouts.iter().copied();
let bytes =
func_name_bytes_help(passed_function.name, it, &passed_function.return_layout);
let args_it = passed_function.argument_layouts.iter().copied();
let captures_it = passed_function.name.captures_niche.iter().copied();
let bytes = func_name_bytes_help(
passed_function.name.name(),
args_it,
captures_it,
&passed_function.return_layout,
);
let name = FuncName(&bytes);
let module = MOD_APP;

4
crates/compiler/builtins/src/bitcode.rs
View file

@ -29,7 +29,7 @@ pub enum DecWidth {
}
#[repr(u8)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
pub enum FloatWidth {
F32,
F64,
@ -76,7 +76,7 @@ impl FloatWidth {
}
#[repr(u8)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, PartialOrd, Ord)]
pub enum IntWidth {
U8 = 0,
U16 = 1,

36
crates/compiler/can/src/def.rs
View file

@ -7,6 +7,7 @@ use crate::annotation::make_apply_symbol;
use crate::annotation::IntroducedVariables;
use crate::annotation::OwnedNamedOrAble;
use crate::env::Env;
use crate::expr::AccessorData;
use crate::expr::AnnotatedMark;
use crate::expr::ClosureData;
use crate::expr::Declarations;
@ -1554,7 +1555,10 @@ fn canonicalize_pending_value_def<'a>(
region: loc_ann.region,
}
} else {
let symbol = scope.gen_unique_symbol();
let symbol = match &loc_can_pattern.value {
Pattern::Identifier(symbol) => *symbol,
_ => scope.gen_unique_symbol(),
};
// generate a fake pattern for each argument. this makes signatures
// that are functions only crash when they are applied.
@ -1725,6 +1729,36 @@ fn canonicalize_pending_body<'a>(
(loc_can_expr, def_references)
}
// Turn f = .foo into f = \rcd -[f]-> rcd.foo
// (
// Pattern::Identifier(defined_symbol)
// | Pattern::AbilityMemberSpecialization {
// ident: defined_symbol,
// ..
// },
// ast::Expr::AccessorFunction(field),
// ) => {
// let (loc_can_expr, can_output) = (
// Loc::at(
// loc_expr.region,
// Accessor(AccessorData {
// name: scope.gen_unique_symbol(),
// function_var: var_store.fresh(),
// record_var: var_store.fresh(),
// ext_var: var_store.fresh(),
// closure_var: var_store.fresh(),
// field_var: var_store.fresh(),
// field: (*field).into(),
// }),
// ),
// Output::default(),
// );
// let def_references = DefReferences::Value(can_output.references.clone());
// output.union(can_output);
// (loc_can_expr, def_references)
// }
_ => {
let (loc_can_expr, can_output) =
canonicalize_expr(env, var_store, scope, loc_expr.region, &loc_expr.value);

20
crates/compiler/gen_dev/src/lib.rs
View file

@ -106,8 +106,8 @@ trait Backend<'a> {
proc: Proc<'a>,
layout_ids: &mut LayoutIds<'a>,
) -> (Vec<u8>, Vec<Relocation>, Vec<'a, (Symbol, String)>) {
let layout_id = layout_ids.get(proc.name.call_name(), &proc.ret_layout);
let proc_name = self.symbol_to_string(proc.name.call_name(), layout_id);
let layout_id = layout_ids.get(proc.name.name(), &proc.ret_layout);
let proc_name = self.symbol_to_string(proc.name.name(), layout_id);
self.reset(proc_name, proc.is_self_recursive);
self.load_args(proc.args, &proc.ret_layout);
for (layout, sym) in proc.args {
@ -263,7 +263,7 @@ trait Backend<'a> {
..
} => {
if let LowLevelWrapperType::CanBeReplacedBy(lowlevel) =
LowLevelWrapperType::from_symbol(*func_sym)
LowLevelWrapperType::from_symbol(func_sym.name())
{
self.build_run_low_level(
sym,
@ -272,14 +272,20 @@ trait Backend<'a> {
arg_layouts,
ret_layout,
)
} else if self.defined_in_app_module(*func_sym) {
let layout_id = LayoutIds::default().get(*func_sym, layout);
let fn_name = self.symbol_to_string(*func_sym, layout_id);
} else if self.defined_in_app_module(func_sym.name()) {
let layout_id = LayoutIds::default().get(func_sym.name(), layout);
let fn_name = self.symbol_to_string(func_sym.name(), layout_id);
// Now that the arguments are needed, load them if they are literals.
self.load_literal_symbols(arguments);
self.build_fn_call(sym, fn_name, arguments, arg_layouts, ret_layout)
} else {
self.build_builtin(sym, *func_sym, arguments, arg_layouts, ret_layout)
self.build_builtin(
sym,
func_sym.name(),
arguments,
arg_layouts,
ret_layout,
)
}
}

43
crates/compiler/gen_llvm/src/llvm/build.rs
View file

@ -62,7 +62,9 @@ use roc_mono::ir::{
BranchInfo, CallType, EntryPoint, HigherOrderLowLevel, JoinPointId, ListLiteralElement,
ModifyRc, OptLevel, ProcLayout,
};
use roc_mono::layout::{Builtin, LambdaSet, Layout, LayoutIds, TagIdIntType, UnionLayout};
use roc_mono::layout::{
Builtin, LambdaName, LambdaSet, Layout, LayoutIds, TagIdIntType, UnionLayout,
};
use roc_std::RocDec;
use roc_target::{PtrWidth, TargetInfo};
use std::convert::{TryFrom, TryInto};
@ -715,7 +717,7 @@ fn promote_to_main_function<'a, 'ctx, 'env>(
top_level: ProcLayout<'a>,
) -> (&'static str, FunctionValue<'ctx>) {
let it = top_level.arguments.iter().copied();
let bytes = roc_alias_analysis::func_name_bytes_help(symbol, it, &top_level.result);
let bytes = roc_alias_analysis::func_name_bytes_help(symbol, it, [], &top_level.result);
let func_name = FuncName(&bytes);
let func_solutions = mod_solutions.func_solutions(func_name).unwrap();
@ -727,7 +729,7 @@ fn promote_to_main_function<'a, 'ctx, 'env>(
);
// NOTE fake layout; it is only used for debug prints
let roc_main_fn = function_value_by_func_spec(env, *func_spec, symbol, &[], &Layout::UNIT);
let roc_main_fn = function_value_by_func_spec(env, *func_spec, symbol, &[], &[], &Layout::UNIT);
let main_fn_name = "$Test.main";
@ -3296,6 +3298,7 @@ fn expose_function_to_host<'a, 'ctx, 'env>(
symbol: Symbol,
roc_function: FunctionValue<'ctx>,
arguments: &'a [Layout<'a>],
captures_niche: &'a [Layout<'a>],
return_layout: Layout<'a>,
layout_ids: &mut LayoutIds<'a>,
) {
@ -3304,6 +3307,7 @@ fn expose_function_to_host<'a, 'ctx, 'env>(
let proc_layout = ProcLayout {
arguments,
result: return_layout,
captures_niche,
};
let c_function_name: String = layout_ids
@ -4185,7 +4189,7 @@ fn build_procedures_help<'a, 'ctx, 'env>(
// only have top-level thunks for this proc's module in scope
// this retain is not needed for correctness, but will cause less confusion when debugging
let home = proc.name.call_name().module_id();
let home = proc.name.name().module_id();
current_scope.retain_top_level_thunks_for_module(home);
build_proc(
@ -4301,6 +4305,7 @@ fn build_proc_header<'a, 'ctx, 'env>(
symbol,
fn_val,
arguments.into_bump_slice(),
proc.name.captures_niche,
proc.ret_layout,
layout_ids,
);
@ -4530,8 +4535,12 @@ pub fn build_proc<'a, 'ctx, 'env>(
// * roc__mainForHost_1_Update_result_size() -> i64
let it = top_level.arguments.iter().copied();
let bytes =
roc_alias_analysis::func_name_bytes_help(symbol, it, &top_level.result);
let bytes = roc_alias_analysis::func_name_bytes_help(
symbol,
it,
[],
&top_level.result,
);
let func_name = FuncName(&bytes);
let func_solutions = mod_solutions.func_solutions(func_name).unwrap();
@ -4548,6 +4557,7 @@ pub fn build_proc<'a, 'ctx, 'env>(
*func_spec,
symbol,
top_level.arguments,
&[],
&top_level.result,
)
}
@ -4559,7 +4569,7 @@ pub fn build_proc<'a, 'ctx, 'env>(
}
};
let ident_string = proc.name.call_name().as_str(&env.interns);
let ident_string = proc.name.name().as_str(&env.interns);
let fn_name: String = format!("{}_1", ident_string);
build_closure_caller(
@ -4624,17 +4634,19 @@ fn function_value_by_func_spec<'a, 'ctx, 'env>(
func_spec: FuncSpec,
symbol: Symbol,
arguments: &[Layout<'a>],
captures_niche: &[Layout<'a>],
result: &Layout<'a>,
) -> FunctionValue<'ctx> {
let fn_name = func_spec_name(env.arena, &env.interns, symbol, func_spec);
let fn_name = fn_name.as_str();
function_value_by_name_help(env, arguments, result, symbol, fn_name)
function_value_by_name_help(env, arguments, captures_niche, result, symbol, fn_name)
}
fn function_value_by_name_help<'a, 'ctx, 'env>(
env: &Env<'a, 'ctx, 'env>,
arguments: &[Layout<'a>],
_captures_niche: &[Layout<'a>],
result: &Layout<'a>,
symbol: Symbol,
fn_name: &str,
@ -4675,12 +4687,18 @@ fn roc_call_with_args<'a, 'ctx, 'env>(
env: &Env<'a, 'ctx, 'env>,
argument_layouts: &[Layout<'a>],
result_layout: &Layout<'a>,
symbol: Symbol,
name: LambdaName<'a>,
func_spec: FuncSpec,
arguments: &[BasicValueEnum<'ctx>],
) -> BasicValueEnum<'ctx> {
let fn_val =
function_value_by_func_spec(env, func_spec, symbol, argument_layouts, result_layout);
let fn_val = function_value_by_func_spec(
env,
func_spec,
name.name(),
argument_layouts,
name.captures_niche,
result_layout,
);
call_roc_function(env, fn_val, result_layout, arguments)
}
@ -4869,8 +4887,9 @@ fn run_higher_order_low_level<'a, 'ctx, 'env>(
let function = function_value_by_func_spec(
env,
func_spec,
function_name,
function_name.name(),
argument_layouts,
function_name.captures_niche,
return_layout,
);

5
crates/compiler/gen_wasm/src/backend.rs
View file

@ -380,7 +380,7 @@ impl<'a> WasmBackend<'a> {
println!("\ngenerating procedure {:?}\n", proc.name);
}
self.append_proc_debug_name(proc.name.call_name());
self.append_proc_debug_name(proc.name.name());
self.start_proc(proc);
@ -1125,9 +1125,10 @@ impl<'a> WasmBackend<'a> {
let proc_layout = ProcLayout {
arguments: arg_layouts,
result: **result,
captures_niche: func_sym.captures_niche,
};
self.expr_call_by_name(
*func_sym,
func_sym.name(),
&proc_layout,
arguments,
ret_sym,

4
crates/compiler/gen_wasm/src/low_level.rs
View file

@ -1951,12 +1951,13 @@ pub fn call_higher_order_lowlevel<'a>(
let passed_proc_layout = ProcLayout {
arguments: argument_layouts,
result: *result_layout,
captures_niche: fn_name.captures_niche,
};
let passed_proc_index = backend
.proc_lookup
.iter()
.position(|ProcLookupData { name, layout, .. }| {
name == fn_name && layout == &passed_proc_layout
*name == fn_name.name() && layout == &passed_proc_layout
})
.unwrap();
ProcSource::HigherOrderWrapper(passed_proc_index)
@ -1984,6 +1985,7 @@ pub fn call_higher_order_lowlevel<'a>(
ProcLayout {
arguments: wrapper_arg_layouts.into_bump_slice(),
result: Layout::UNIT,
captures_niche: &[],
}
};

9
crates/compiler/load_internal/src/file.rs
View file

@ -132,7 +132,7 @@ struct ModuleCache<'a> {
typechecked: MutMap<ModuleId, TypeCheckedModule<'a>>,
found_specializations: MutMap<ModuleId, FoundSpecializationsModule<'a>>,
late_specializations: MutMap<ModuleId, LateSpecializationsModule<'a>>,
external_specializations_requested: MutMap<ModuleId, Vec<ExternalSpecializations>>,
external_specializations_requested: MutMap<ModuleId, Vec<ExternalSpecializations<'a>>>,
/// Various information
imports: MutMap<ModuleId, MutSet<ModuleId>>,
@ -717,7 +717,7 @@ enum Msg<'a> {
module_id: ModuleId,
ident_ids: IdentIds,
layout_cache: LayoutCache<'a>,
external_specializations_requested: BumpMap<ModuleId, ExternalSpecializations>,
external_specializations_requested: BumpMap<ModuleId, ExternalSpecializations<'a>>,
procs_base: ProcsBase<'a>,
procedures: MutMap<(Symbol, ProcLayout<'a>), Proc<'a>>,
update_mode_ids: UpdateModeIds,
@ -1013,7 +1013,7 @@ enum BuildTask<'a> {
subs: Subs,
procs_base: ProcsBase<'a>,
layout_cache: LayoutCache<'a>,
specializations_we_must_make: Vec<ExternalSpecializations>,
specializations_we_must_make: Vec<ExternalSpecializations<'a>>,
module_timing: ModuleTiming,
world_abilities: WorldAbilities,
derived_symbols: GlobalDerivedSymbols,
@ -2678,6 +2678,7 @@ fn finish_specialization(
layout: roc_mono::ir::ProcLayout {
arguments: &[],
result: Layout::struct_no_name_order(&[]),
captures_niche: &[],
},
symbol,
}
@ -4425,7 +4426,7 @@ fn make_specializations<'a>(
mut subs: Subs,
procs_base: ProcsBase<'a>,
mut layout_cache: LayoutCache<'a>,
specializations_we_must_make: Vec<ExternalSpecializations>,
specializations_we_must_make: Vec<ExternalSpecializations<'a>>,
mut module_timing: ModuleTiming,
target_info: TargetInfo,
world_abilities: WorldAbilities,

32
crates/compiler/mono/src/borrow.rs
View file

@ -263,7 +263,7 @@ impl<'a> ParamMap<'a> {
self.declarations[index + i] = param;
}
self.visit_stmt(arena, proc.name.call_name(), &proc.body);
self.visit_stmt(arena, proc.name.name(), &proc.body);
}
fn visit_proc_always_owned(
@ -282,7 +282,7 @@ impl<'a> ParamMap<'a> {
self.declarations[index + i] = param;
}
self.visit_stmt(arena, proc.name.call_name(), &proc.body);
self.visit_stmt(arena, proc.name.name(), &proc.body);
}
fn visit_stmt(&mut self, arena: &'a Bump, _fnid: Symbol, stmt: &Stmt<'a>) {
@ -501,11 +501,12 @@ impl<'a> BorrowInfState<'a> {
arg_layouts,
..
} => {
let top_level = ProcLayout::new(self.arena, arg_layouts, **ret_layout);
let top_level =
ProcLayout::new(self.arena, arg_layouts, name.captures_niche, **ret_layout);
// get the borrow signature of the applied function
let ps = param_map
.get_symbol(*name, top_level)
.get_symbol(name.name(), top_level)
.expect("function is defined");
// the return value will be owned
@ -544,12 +545,14 @@ impl<'a> BorrowInfState<'a> {
let closure_layout = ProcLayout {
arguments: passed_function.argument_layouts,
result: passed_function.return_layout,
captures_niche: passed_function.name.captures_niche,
};
let function_ps = match param_map.get_symbol(passed_function.name, closure_layout) {
Some(function_ps) => function_ps,
None => unreachable!(),
};
let function_ps =
match param_map.get_symbol(passed_function.name.name(), closure_layout) {
Some(function_ps) => function_ps,
None => unreachable!(),
};
match op {
ListMap { xs } => {
@ -743,12 +746,13 @@ impl<'a> BorrowInfState<'a> {
Stmt::Ret(z),
) = (v, b)
{
let top_level = ProcLayout::new(self.arena, arg_layouts, **ret_layout);
let top_level =
ProcLayout::new(self.arena, arg_layouts, g.captures_niche, **ret_layout);
if self.current_proc == *g && x == *z {
if self.current_proc == g.name() && x == *z {
// anonymous functions (for which the ps may not be known)
// can never be tail-recursive, so this is fine
if let Some(ps) = param_map.get_symbol(*g, top_level) {
if let Some(ps) = param_map.get_symbol(g.name(), top_level) {
self.own_params_using_args(ys, ps)
}
}
@ -852,10 +856,10 @@ impl<'a> BorrowInfState<'a> {
let ys = Vec::from_iter_in(proc.args.iter().map(|t| t.1), self.arena).into_bump_slice();
self.update_param_set_symbols(ys);
self.current_proc = proc.name.call_name();
self.current_proc = proc.name.name();
// ensure that current_proc is in the owned map
self.owned.entry(proc.name.call_name()).or_default();
self.owned.entry(proc.name.name()).or_default();
self.collect_stmt(param_map, &proc.body);
self.update_param_map_declaration(param_map, param_offset, proc.args.len());
@ -975,7 +979,7 @@ fn call_info_call<'a>(call: &crate::ir::Call<'a>, info: &mut CallInfo<'a>) {
match call.call_type {
ByName { name, .. } => {
info.keys.push(name);
info.keys.push(name.name());
}
Foreign { .. } => {}
LowLevel { .. } => {}

8
crates/compiler/mono/src/code_gen_help/mod.rs
View file

@ -170,7 +170,7 @@ impl<'a> CodeGenHelp<'a> {
let arg_layouts = self.arena.alloc([layout]);
let expr = Expr::Call(Call {
call_type: CallType::ByName {
name: proc_name,
name: LambdaName::only_receiver(proc_name),
ret_layout,
arg_layouts,
specialization_id: CallSpecId::BACKEND_DUMMY,
@ -262,7 +262,7 @@ impl<'a> CodeGenHelp<'a> {
Some(Expr::Call(Call {
call_type: CallType::ByName {
name: proc_name,
name: LambdaName::only_receiver(proc_name),
ret_layout,
arg_layouts,
specialization_id: CallSpecId::BACKEND_DUMMY,
@ -375,19 +375,23 @@ impl<'a> CodeGenHelp<'a> {
HelperOp::Inc => ProcLayout {
arguments: self.arena.alloc([*layout, self.layout_isize]),
result: LAYOUT_UNIT,
captures_niche: &[],
},
HelperOp::Dec => ProcLayout {
arguments: self.arena.alloc([*layout]),
result: LAYOUT_UNIT,
captures_niche: &[],
},
HelperOp::Reset => ProcLayout {
arguments: self.arena.alloc([*layout]),
result: *layout,
captures_niche: &[],
},
HelperOp::DecRef(_) => unreachable!("No generated Proc for DecRef"),
HelperOp::Eq => ProcLayout {
arguments: self.arena.alloc([*layout, *layout]),
result: LAYOUT_BOOL,
captures_niche: &[],
},
};

10
crates/compiler/mono/src/inc_dec.rs
View file

@ -564,12 +564,13 @@ impl<'a> Context<'a> {
arg_layouts,
..
} => {
let top_level = ProcLayout::new(self.arena, arg_layouts, **ret_layout);
let top_level =
ProcLayout::new(self.arena, arg_layouts, name.captures_niche, **ret_layout);
// get the borrow signature
let ps = self
.param_map
.get_symbol(*name, top_level)
.get_symbol(name.name(), top_level)
.expect("function is defined");
let v = Expr::Call(crate::ir::Call {
@ -614,11 +615,12 @@ impl<'a> Context<'a> {
let function_layout = ProcLayout {
arguments: passed_function.argument_layouts,
result: passed_function.return_layout,
captures_niche: passed_function.name.captures_niche,
};
let function_ps = match self
.param_map
.get_symbol(passed_function.name, function_layout)
.get_symbol(passed_function.name.name(), function_layout)
{
Some(function_ps) => function_ps,
None => unreachable!(),
@ -1406,7 +1408,7 @@ fn visit_proc<'a, 'i>(
proc: &mut Proc<'a>,
layout: ProcLayout<'a>,
) {
let params = match param_map.get_symbol(proc.name.call_name(), layout) {
let params = match param_map.get_symbol(proc.name.name(), layout) {
Some(slice) => slice,
None => Vec::from_iter_in(
proc.args.iter().cloned().map(|(layout, symbol)| Param {

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

File diff suppressed because it is too large Load diff

211
crates/compiler/mono/src/layout.rs
View file

@ -232,7 +232,7 @@ impl<'a> RawFunctionLayout<'a> {
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct FieldOrderHash(u64);
impl FieldOrderHash {
@ -254,7 +254,7 @@ impl FieldOrderHash {
}
/// Types for code gen must be monomorphic. No type variables allowed!
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum Layout<'a> {
Builtin(Builtin<'a>),
Struct {
@ -276,7 +276,7 @@ pub enum Layout<'a> {
RecursivePointer,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum UnionLayout<'a> {
/// A non-recursive tag union
/// e.g. `Result a e : [Ok a, Err e]`
@ -678,16 +678,13 @@ impl std::fmt::Debug for SetElement<'_> {
impl std::fmt::Debug for LambdaSet<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
struct Helper<'a> {
set: &'a [(LambdaName, &'a [Layout<'a>])],
set: &'a [(Symbol, &'a [Layout<'a>])],
}
impl std::fmt::Debug for Helper<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let entries = self.set.iter().map(|x| SetElement {
symbol: match (x.0).0 {
LambdaNameInner::Name(name) => name,
LambdaNameInner::Multimorphic { alias, .. } => alias,
},
symbol: x.0,
layout: x.1,
});
@ -864,74 +861,61 @@ impl MultimorphicNames {
}
}
static_assertions::assert_eq_size!(&[Layout], Option<&[Layout]>);
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
enum LambdaNameInner {
/// Standard lambda name assigned during canonicalize/constrain
Name(Symbol),
pub struct LambdaName<'a> {
name: Symbol,
/// Sometimes we can end up with lambdas of the same name and different captures in the same
/// lambda set, like [[Thunk U8, Thunk Str]]. See also https://github.com/rtfeldman/roc/issues/3336.
/// We call such lambdas "multi-morphic".
///
/// The current compilation scheme in such cases is to assign an alias name for subsequent such
/// lambda names, and then code-gen those lambda variants under a different `Proc`. In our
/// example, the lambda set would be transformed to something like
/// [[Thunk U8, Multimorphic(Thunk, ThunkAliasStr) Str]] which tells us to specialize the
/// second variant using the proc `Thunk` but under the name `ThunkAliasStr`, with that
/// particular closure layout.
///
/// Currently we do no de-duplication of alias names. This does make compilation faster, but
/// also we should expect redundant multimorphic aliases to be somewhat rare, as that means a
/// non-unitary lambda set is the same in multiple areas of a program.
Multimorphic {
/// The lambda we came from, e.g. `Thunk` in the example
source: Symbol,
/// The lambda we become, e.g. `ThunkAliasStr` in the example
alias: Symbol,
},
/// By recording the captures layouts this lambda expects in its identifier, we can distinguish
/// between such differences.
pub captures_niche: &'a [Layout<'a>],
}
#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug)]
pub struct LambdaName(LambdaNameInner);
impl LambdaName {
impl LambdaName<'_> {
#[inline(always)]
pub fn source_name(&self) -> Symbol {
match self.0 {
LambdaNameInner::Name(name) => name,
LambdaNameInner::Multimorphic { source, .. } => source,
}
pub fn name(&self) -> Symbol {
self.name
}
#[inline(always)]
pub fn call_name(&self) -> Symbol {
match self.0 {
LambdaNameInner::Name(name) => name,
LambdaNameInner::Multimorphic { alias, .. } => alias,
}
}
#[inline(always)]
pub fn is_multimorphic(&self) -> bool {
matches!(self.0, LambdaNameInner::Multimorphic { .. })
pub fn no_captures(&self) -> bool {
self.captures_niche.is_empty()
}
#[inline(always)]
pub fn thunk(name: Symbol) -> Self {
Self(LambdaNameInner::Name(name))
Self {
name,
captures_niche: &[],
}
}
// When the function name is known, so there can only be one possible receiver, in such cases
// the lambda cannot be multimorphic.
#[inline(always)]
pub fn only_receiver(name: Symbol) -> Self {
Self(LambdaNameInner::Name(name))
Self {
name,
captures_niche: &[],
}
}
#[inline(always)]
pub fn replace_name(&self, name: Symbol) -> Self {
Self {
name,
captures_niche: self.captures_niche,
}
}
}
#[derive(Clone, Copy, PartialEq, Eq, Hash)]
#[derive(Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct LambdaSet<'a> {
/// collection of function names and their closure arguments
pub set: &'a [(LambdaName, &'a [Layout<'a>])],
pub set: &'a [(Symbol, &'a [Layout<'a>])],
/// how the closure will be represented at runtime
representation: &'a Layout<'a>,
}
@ -961,12 +945,8 @@ impl<'a> LambdaSet<'a> {
}
/// Does the lambda set contain the given symbol?
/// NOTE: for multimorphic variants, this checks the alias name.
pub fn contains(&self, symbol: Symbol) -> bool {
self.set.iter().any(|(s, _)| match s.0 {
LambdaNameInner::Name(name) => name == symbol,
LambdaNameInner::Multimorphic { alias, .. } => alias == symbol,
})
self.set.iter().any(|(s, _)| *s == symbol)
}
pub fn is_represented(&self) -> Option<Layout<'a>> {
@ -980,64 +960,54 @@ impl<'a> LambdaSet<'a> {
}
}
pub fn iter_set(&self) -> impl ExactSizeIterator<Item = LambdaName<'a>> {
self.set.iter().map(|(name, captures_layouts)| LambdaName {
name: *name,
captures_niche: captures_layouts,
})
}
pub fn layout_for_member_with_lambda_name(
&self,
lambda_name: LambdaName,
) -> ClosureRepresentation<'a> {
debug_assert!(
self.set.iter().any(|(s, _)| *s == lambda_name),
"lambda {:?} not in set {:#?}",
lambda_name,
self.set,
);
debug_assert!(self.contains(lambda_name.name));
let comparator =
|other_name: LambdaName, _other_captures_layouts: &[Layout]| other_name == lambda_name;
let comparator = |other_name: Symbol, other_captures_layouts: &[Layout]| {
other_name == lambda_name.name
&& other_captures_layouts.iter().eq(lambda_name.captures_niche)
};
self.layout_for_member(comparator)
}
fn contains_source(&self, symbol: Symbol) -> bool {
self.set.iter().any(|(s, _)| match s.0 {
LambdaNameInner::Name(name) => name == symbol,
LambdaNameInner::Multimorphic { source, .. } => source == symbol,
})
}
/// Finds an alias name for a possible-multimorphic lambda variant in the lambda set.
pub fn find_lambda_name(
&self,
function_symbol: Symbol,
captures_layouts: &[Layout],
) -> LambdaName {
debug_assert!(
self.contains_source(function_symbol),
"function symbol not in set"
);
) -> LambdaName<'a> {
debug_assert!(self.contains(function_symbol), "function symbol not in set");
let comparator = |other_name: LambdaName, other_captures_layouts: &[Layout]| {
let other_name = match other_name.0 {
LambdaNameInner::Name(name) => name,
// Take the source, since we'll want to pick out the multimorphic name if it
// matches
LambdaNameInner::Multimorphic { source, .. } => source,
};
other_name == function_symbol
&& captures_layouts.iter().eq(other_captures_layouts.iter())
let comparator = |other_name: Symbol, other_captures_layouts: &[Layout]| {
other_name == function_symbol && other_captures_layouts.iter().eq(captures_layouts)
};
let (name, _) = self
let (name, layouts) = self
.set
.iter()
.find(|(name, layouts)| comparator(*name, layouts))
.expect("no lambda set found");
*name
LambdaName {
name: *name,
captures_niche: layouts,
}
}
fn layout_for_member<F>(&self, comparator: F) -> ClosureRepresentation<'a>
where
F: Fn(LambdaName, &[Layout]) -> bool,
F: Fn(Symbol, &[Layout]) -> bool,
{
match self.representation {
Layout::Union(union) => {
@ -1054,10 +1024,7 @@ impl<'a> LambdaSet<'a> {
.find(|(_, (s, layouts))| comparator(*s, layouts))
.unwrap();
let closure_name = match name.0 {
LambdaNameInner::Name(name) => name,
LambdaNameInner::Multimorphic { alias, .. } => alias,
};
let closure_name = *name;
ClosureRepresentation::Union {
tag_id: index as TagIdIntType,
@ -1140,15 +1107,14 @@ impl<'a> LambdaSet<'a> {
// sort the tags; make sure ordering stays intact!
lambdas.sort_by_key(|(sym, _)| *sym);
let mut set: Vec<(LambdaName, &[Layout])> =
Vec::with_capacity_in(lambdas.len(), arena);
let mut set_for_making_repr: std::vec::Vec<(Symbol, std::vec::Vec<Variable>)> =
let mut set: Vec<(Symbol, &[Layout])> = Vec::with_capacity_in(lambdas.len(), arena);
let mut set_with_variables: std::vec::Vec<(Symbol, std::vec::Vec<Variable>)> =
std::vec::Vec::with_capacity(lambdas.len());
let mut last_function_symbol = None;
let mut lambdas_it = lambdas.iter().peekable();
let mut has_multimorphic = false;
let mut has_duplicate_lambda_names = false;
while let Some((function_symbol, variables)) = lambdas_it.next() {
let mut arguments = Vec::with_capacity_in(variables.len(), arena);
@ -1174,37 +1140,42 @@ impl<'a> LambdaSet<'a> {
}
};
let lambda_name = if is_multimorphic {
let alias = multimorphic_names.get_or_insert(*function_symbol, arguments);
has_duplicate_lambda_names = has_duplicate_lambda_names || is_multimorphic;
has_multimorphic = true;
LambdaNameInner::Multimorphic {
source: *function_symbol,
alias,
}
} else {
LambdaNameInner::Name(*function_symbol)
};
let lambda_name = LambdaName(lambda_name);
set.push((lambda_name, arguments));
set_for_making_repr.push((lambda_name.call_name(), variables.to_vec()));
set.push((*function_symbol, arguments));
set_with_variables.push((*function_symbol, variables.to_vec()));
last_function_symbol = Some(function_symbol);
}
if has_multimorphic {
// Must re-sort the set in case we added multimorphic lambdas since they may under
// another name
set.sort_by_key(|(name, _)| name.call_name());
set_for_making_repr.sort_by_key(|(name, _)| *name);
}
let (set, set_with_variables) = if has_duplicate_lambda_names {
// If we have a lambda set with duplicate names, then we sort first by name,
// and break ties by sorting on the layout. We need to do this again since the
// first sort would not have sorted on the layout.
// TODO: be more efficient, we can compute the permutation once and then apply
// it to both vectors.
let mut joined = set
.into_iter()
.zip(set_with_variables.into_iter())
.collect::<std::vec::Vec<_>>();
joined.sort_by(|(lam_and_captures1, _), (lam_and_captures2, _)| {
lam_and_captures1.cmp(lam_and_captures2)
});
let (set, set_with_variables): (std::vec::Vec<_>, std::vec::Vec<_>) =
joined.into_iter().unzip();
let set = Vec::from_iter_in(set, arena);
(set, set_with_variables)
} else {
(set, set_with_variables)
};
let representation = arena.alloc(Self::make_representation(
arena,
subs,
set_for_making_repr,
set_with_variables,
target_info,
multimorphic_names,
));
@ -1323,7 +1294,7 @@ fn resolve_lambda_set(subs: &Subs, mut var: Variable) -> ResolvedLambdaSet {
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum Builtin<'a> {
Int(IntWidth),
Float(FloatWidth),
@ -3433,7 +3404,7 @@ mod test {
#[test]
fn width_and_alignment_union_empty_struct() {
let lambda_set = LambdaSet {
set: &[(LambdaName::only_receiver(Symbol::LIST_MAP), &[])],
set: &[(Symbol::LIST_MAP, &[])],
representation: &Layout::UNIT,
};

8
crates/compiler/mono/src/tail_recursion.rs
View file

@ -1,7 +1,7 @@
#![allow(clippy::manual_map)]
use crate::ir::{CallType, Expr, JoinPointId, Param, Stmt};
use crate::layout::Layout;
use crate::layout::{LambdaName, Layout};
use bumpalo::collections::Vec;
use bumpalo::Bump;
use roc_module::symbol::Symbol;
@ -31,7 +31,7 @@ use roc_module::symbol::Symbol;
pub fn make_tail_recursive<'a>(
arena: &'a Bump,
id: JoinPointId,
needle: Symbol,
needle: LambdaName,
stmt: Stmt<'a>,
args: &'a [(Layout<'a>, Symbol, Symbol)],
ret_layout: Layout,
@ -71,7 +71,7 @@ fn insert_jumps<'a>(
arena: &'a Bump,
stmt: &'a Stmt<'a>,
goal_id: JoinPointId,
needle: Symbol,
needle: LambdaName,
needle_arguments: &'a [(Layout<'a>, Symbol, Symbol)],
needle_result: Layout,
) -> Option<&'a Stmt<'a>> {
@ -80,7 +80,7 @@ fn insert_jumps<'a>(
// to insert a tail-call, it must not just be a call to the function itself, but it must also
// have the same layout. In particular when lambda sets get involved, a self-recursive call may
// have a different type and should not be converted to a jump!
let is_equal_function = |function_name: Symbol, arguments: &[_], result| {
let is_equal_function = |function_name: LambdaName, arguments: &[_], result| {
let it = needle_arguments.iter().map(|t| &t.0);
needle == function_name && it.eq(arguments.iter()) && needle_result == result
};

43
crates/compiler/test_mono/generated/multimorphic_lambda_set_capture.txt
View file

@ -1,24 +1,29 @@
procedure #Multimorphic.0 (Test.23, #Attr.12):
let Test.4 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
inc Test.4;
dec #Attr.12;
let Test.25 : Str = "";
ret Test.25;
procedure Num.94 (#Attr.2):
let Num.273 : Str = lowlevel NumToStr #Attr.2;
ret Num.273;
procedure #Multimorphic.1 (Test.17, #Attr.12):
let Test.4 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
dec #Attr.12;
let Test.19 : Str = "";
ret Test.19;
procedure Num.94 (#Attr.2):
let Num.274 : Str = lowlevel NumToStr #Attr.2;
ret Num.274;
procedure Test.1 (Test.4):
let Test.16 : [C Str, C {}] = ClosureTag(#Multimorphic.1) Test.4;
let Test.16 : [C U8, C U64] = ClosureTag(Test.5) Test.4;
ret Test.16;
procedure Test.1 (Test.4):
let Test.22 : [C Str, C {}] = ClosureTag(#Multimorphic.0) Test.4;
let Test.22 : [C U8, C U64] = ClosureTag(Test.5) Test.4;
ret Test.22;
procedure Test.5 (Test.17, #Attr.12):
let Test.4 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.19 : Str = CallByName Num.94 Test.4;
ret Test.19;
procedure Test.5 (Test.17, #Attr.12):
let Test.4 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.25 : Str = CallByName Num.94 Test.4;
ret Test.25;
procedure Test.0 ():
let Test.2 : Int1 = true;
joinpoint Test.13 Test.3:
@ -29,21 +34,21 @@ procedure Test.0 ():
in
switch Test.9:
case 0:
let Test.11 : Str = CallByName #Multimorphic.0 Test.8 Test.3;
let Test.11 : Str = CallByName Test.5 Test.8 Test.3;
jump Test.10 Test.11;
default:
let Test.12 : Str = CallByName #Multimorphic.1 Test.8 Test.3;
let Test.12 : Str = CallByName Test.5 Test.8 Test.3;
jump Test.10 Test.12;
in
let Test.26 : Int1 = true;
let Test.27 : Int1 = lowlevel Eq Test.26 Test.2;
if Test.27 then
let Test.15 : {} = Struct {};
let Test.14 : [C Str, C {}] = CallByName Test.1 Test.15;
let Test.15 : U64 = 123i64;
let Test.14 : [C U8, C U64] = CallByName Test.1 Test.15;
jump Test.13 Test.14;
else
let Test.21 : Str = "";
let Test.20 : [C Str, C {}] = CallByName Test.1 Test.21;
let Test.21 : U8 = 18i64;
let Test.20 : [C U8, C U64] = CallByName Test.1 Test.21;
jump Test.13 Test.20;

50
crates/compiler/test_mono/generated/multimorphic_lambdas_have_captured_function_in_closure.txt
View file

@ -1,24 +1,3 @@
procedure #Multimorphic.0 (Test.29, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 0) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.49 : {} = Struct {};
let Test.48 : Str = CallByName Test.16 Test.49;
let Test.45 : {Str} = CallByName Test.4 Test.48;
let Test.47 : {} = Struct {};
let Test.46 : Str = CallByName Test.13 Test.47 Test.45;
ret Test.46;
procedure #Multimorphic.1 (Test.29, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.35 : {} = Struct {};
let Test.34 : Str = CallByName Test.15 Test.35;
let Test.31 : {} = CallByName Test.3 Test.34;
dec Test.34;
let Test.33 : {} = Struct {};
let Test.32 : Str = CallByName Test.11 Test.33;
ret Test.32;
procedure Test.11 (Test.37):
let Test.38 : Str = "";
ret Test.38;
@ -38,11 +17,11 @@ procedure Test.16 (Test.54):
ret Test.56;
procedure Test.2 (Test.7, Test.8):
let Test.9 : [C {} {}, C {} {}] = ClosureTag(#Multimorphic.0) Test.7 Test.8;
let Test.9 : [C {} {}, C {} {}] = ClosureTag(Test.9) Test.7 Test.8;
ret Test.9;
procedure Test.2 (Test.7, Test.8):
let Test.9 : [C {} {}, C {} {}] = ClosureTag(#Multimorphic.1) Test.7 Test.8;
let Test.9 : [C {} {}, C {} {}] = ClosureTag(Test.9) Test.7 Test.8;
ret Test.9;
procedure Test.3 (Test.17):
@ -53,6 +32,27 @@ procedure Test.4 (Test.18):
let Test.50 : {Str} = Struct {Test.18};
ret Test.50;
procedure Test.9 (Test.29, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 0) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.35 : {} = Struct {};
let Test.34 : Str = CallByName Test.15 Test.35;
let Test.31 : {} = CallByName Test.3 Test.34;
dec Test.34;
let Test.33 : {} = Struct {};
let Test.32 : Str = CallByName Test.11 Test.33;
ret Test.32;
procedure Test.9 (Test.29, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.49 : {} = Struct {};
let Test.48 : Str = CallByName Test.16 Test.49;
let Test.45 : {Str} = CallByName Test.4 Test.48;
let Test.47 : {} = Struct {};
let Test.46 : Str = CallByName Test.13 Test.47 Test.45;
ret Test.46;
procedure Test.0 ():
let Test.5 : Int1 = true;
joinpoint Test.25 Test.6:
@ -63,11 +63,11 @@ procedure Test.0 ():
in
switch Test.21:
case 0:
let Test.23 : Str = CallByName #Multimorphic.0 Test.20 Test.6;
let Test.23 : Str = CallByName Test.9 Test.20 Test.6;
jump Test.22 Test.23;
default:
let Test.24 : Str = CallByName #Multimorphic.1 Test.20 Test.6;
let Test.24 : Str = CallByName Test.9 Test.20 Test.6;
jump Test.22 Test.24;
in

36
crates/compiler/test_mono/generated/multimorphic_lambdas_with_non_capturing_function.txt
View file

@ -1,25 +1,25 @@
procedure #Multimorphic.0 (Test.28, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.30 : Str = "";
ret Test.30;
procedure #Multimorphic.1 (Test.20, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.22 : Str = "";
ret Test.22;
procedure Test.1 (Test.5):
let Test.19 : [C U64, C {}, C ] = ClosureTag(#Multimorphic.1) Test.5;
let Test.19 : [C , C U64, C {}] = ClosureTag(Test.6) Test.5;
ret Test.19;
procedure Test.1 (Test.5):
let Test.27 : [C U64, C {}, C ] = ClosureTag(#Multimorphic.0) Test.5;
let Test.27 : [C , C U64, C {}] = ClosureTag(Test.6) Test.5;
ret Test.27;
procedure Test.2 (Test.8):
let Test.24 : Str = "";
ret Test.24;
procedure Test.6 (Test.20, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.30 : Str = "";
ret Test.30;
procedure Test.6 (Test.20, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 2) (Index 0) #Attr.12;
let Test.22 : Str = "";
ret Test.22;
procedure Test.0 ():
let Test.3 : U8 = 0u8;
joinpoint Test.16 Test.4:
@ -30,30 +30,30 @@ procedure Test.0 ():
in
switch Test.11:
case 0:
let Test.13 : Str = CallByName #Multimorphic.0 Test.10 Test.4;
let Test.13 : Str = CallByName Test.2 Test.10;
jump Test.12 Test.13;
case 1:
let Test.14 : Str = CallByName #Multimorphic.1 Test.10 Test.4;
let Test.14 : Str = CallByName Test.6 Test.10 Test.4;
jump Test.12 Test.14;
default:
let Test.15 : Str = CallByName Test.2 Test.10;
let Test.15 : Str = CallByName Test.6 Test.10 Test.4;
jump Test.12 Test.15;
in
switch Test.3:
case 0:
let Test.18 : {} = Struct {};
let Test.17 : [C U64, C {}, C ] = CallByName Test.1 Test.18;
let Test.17 : [C , C U64, C {}] = CallByName Test.1 Test.18;
jump Test.16 Test.17;
case 1:
let Test.2 : [C U64, C {}, C ] = ClosureTag(Test.2) ;
let Test.2 : [C , C U64, C {}] = ClosureTag(Test.2) ;
jump Test.16 Test.2;
default:
let Test.26 : U64 = 1i64;
let Test.25 : [C U64, C {}, C ] = CallByName Test.1 Test.26;
let Test.25 : [C , C U64, C {}] = CallByName Test.1 Test.26;
jump Test.16 Test.25;

32
crates/compiler/test_mono/generated/multimorphic_lambdas_with_other_lambda_capture.txt
View file

@ -1,27 +1,27 @@
procedure #Multimorphic.0 (Test.33, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
dec #Attr.12;
let Test.35 : Str = "";
ret Test.35;
procedure #Multimorphic.1 (Test.21, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
dec #Attr.12;
let Test.23 : Str = "";
ret Test.23;
procedure Test.1 (Test.5):
let Test.20 : [C U64, C {}, C Str] = ClosureTag(#Multimorphic.1) Test.5;
let Test.20 : [C U64, C {}, C Str] = ClosureTag(Test.6) Test.5;
ret Test.20;
procedure Test.1 (Test.5):
let Test.32 : [C U64, C {}, C Str] = ClosureTag(#Multimorphic.0) Test.5;
let Test.32 : [C U64, C {}, C Str] = ClosureTag(Test.6) Test.5;
ret Test.32;
procedure Test.2 (Test.7):
let Test.26 : [C U64, C {}, C Str] = ClosureTag(Test.8) Test.7;
ret Test.26;
procedure Test.6 (Test.21, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
dec #Attr.12;
let Test.35 : Str = "";
ret Test.35;
procedure Test.6 (Test.21, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
dec #Attr.12;
let Test.23 : Str = "";
ret Test.23;
procedure Test.8 (Test.27, #Attr.12):
let Test.7 : Str = UnionAtIndex (Id 2) (Index 0) #Attr.12;
inc Test.7;
@ -38,11 +38,11 @@ procedure Test.0 ():
in
switch Test.12:
case 0:
let Test.14 : Str = CallByName #Multimorphic.0 Test.11 Test.4;
let Test.14 : Str = CallByName Test.6 Test.11 Test.4;
jump Test.13 Test.14;
case 1:
let Test.15 : Str = CallByName #Multimorphic.1 Test.11 Test.4;
let Test.15 : Str = CallByName Test.6 Test.11 Test.4;
jump Test.13 Test.15;
default:

9
crates/compiler/test_mono/src/tests.rs
View file

@ -1530,19 +1530,18 @@ fn tail_call_with_different_layout() {
fn multimorphic_lambda_set_capture() {
indoc!(
r#"
capture : a -> ({} -> Str)
capture : _ -> ({} -> Str)
capture = \val ->
\{} ->
when val is
_ -> ""
Num.toStr val
x : [True, False]
x = True
fun =
when x is
True -> capture {}
False -> capture ""
True -> capture 123u64
False -> capture 18u8
fun {}
"#