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

Merge pull request #2542 from rtfeldman/i/2535

Browse source 
Monomorphize records with same layout, but different field order, correctly
This commit is contained in:
Folkert de Vries 2022-02-21 20:59:44 +01:00 • committed by GitHub
commit 5fec87dc2a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
90 changed files with 854 additions and 691 deletions
Download patch file Download diff file Expand all files Collapse all files

2
compiler/gen_dev/src/generic64/storage.rs
View file

@ -580,7 +580,7 @@ impl<
} }
let base_offset = self.claim_stack_area(sym, struct_size); let base_offset = self.claim_stack_area(sym, struct_size);
if let Layout::Struct(field_layouts) = layout { if let Layout::Struct { field_layouts, .. } = layout {
let mut current_offset = base_offset; let mut current_offset = base_offset;
for (field, field_layout) in fields.iter().zip(field_layouts.iter()) { for (field, field_layout) in fields.iter().zip(field_layouts.iter()) {
self.copy_symbol_to_stack_offset(buf, current_offset, field, field_layout); self.copy_symbol_to_stack_offset(buf, current_offset, field, field_layout);

8
compiler/gen_llvm/src/llvm/bitcode.rs
View file

@ -374,7 +374,9 @@ fn build_transform_caller_help<'a, 'ctx, 'env>(
} }
match closure_data_layout.runtime_representation() { match closure_data_layout.runtime_representation() {
Layout::Struct(&[]) => { Layout::Struct {
field_layouts: &[], ..
} => {
// nothing to add // nothing to add
} }
other => { other => {
@ -694,7 +696,9 @@ pub fn build_compare_wrapper<'a, 'ctx, 'env>(
let default = [value1.into(), value2.into()]; let default = [value1.into(), value2.into()];
let arguments_cast = match closure_data_layout.runtime_representation() { let arguments_cast = match closure_data_layout.runtime_representation() {
Layout::Struct(&[]) => { Layout::Struct {
field_layouts: &[], ..
} => {
// nothing to add // nothing to add
&default &default
} }

29
compiler/gen_llvm/src/llvm/build.rs
View file

@ -714,8 +714,7 @@ fn promote_to_main_function<'a, 'ctx, 'env>(
); );
// NOTE fake layout; it is only used for debug prints // NOTE fake layout; it is only used for debug prints
let roc_main_fn = let roc_main_fn = function_value_by_func_spec(env, *func_spec, symbol, &[], &Layout::UNIT);
function_value_by_func_spec(env, *func_spec, symbol, &[], &Layout::Struct(&[]));
let main_fn_name = "$Test.main"; let main_fn_name = "$Test.main";
@ -1188,8 +1187,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>(
// extract field from a record // extract field from a record
match (value, layout) { match (value, layout) {
(StructValue(argument), Layout::Struct(fields)) => { (StructValue(argument), Layout::Struct { field_layouts, .. }) => {
debug_assert!(!fields.is_empty()); debug_assert!(!field_layouts.is_empty());
let field_value = env let field_value = env
.builder .builder
@ -1201,14 +1200,14 @@ pub fn build_exp_expr<'a, 'ctx, 'env>(
) )
.unwrap(); .unwrap();
let field_layout = fields[*index as usize]; let field_layout = field_layouts[*index as usize];
use_roc_value(env, field_layout, field_value, "struct_field_tag") use_roc_value(env, field_layout, field_value, "struct_field_tag")
} }
( (
PointerValue(argument), PointerValue(argument),
Layout::Union(UnionLayout::NonNullableUnwrapped(fields)), Layout::Union(UnionLayout::NonNullableUnwrapped(fields)),
) => { ) => {
let struct_layout = Layout::Struct(fields); let struct_layout = Layout::struct_no_name_order(fields);
let struct_type = basic_type_from_layout(env, &struct_layout); let struct_type = basic_type_from_layout(env, &struct_layout);
let cast_argument = env let cast_argument = env
@ -1292,7 +1291,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>(
) )
} }
UnionLayout::NonNullableUnwrapped(field_layouts) => { UnionLayout::NonNullableUnwrapped(field_layouts) => {
let struct_layout = Layout::Struct(field_layouts); let struct_layout = Layout::struct_no_name_order(field_layouts);
let struct_type = basic_type_from_layout(env, &struct_layout); let struct_type = basic_type_from_layout(env, &struct_layout);
@ -1341,7 +1340,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>(
debug_assert_ne!(*tag_id != 0, *nullable_id); debug_assert_ne!(*tag_id != 0, *nullable_id);
let field_layouts = other_fields; let field_layouts = other_fields;
let struct_layout = Layout::Struct(field_layouts); let struct_layout = Layout::struct_no_name_order(field_layouts);
let struct_type = basic_type_from_layout(env, &struct_layout); let struct_type = basic_type_from_layout(env, &struct_layout);
@ -2024,7 +2023,7 @@ fn lookup_at_index_ptr2<'a, 'ctx, 'env>(
) -> BasicValueEnum<'ctx> { ) -> BasicValueEnum<'ctx> {
let builder = env.builder; let builder = env.builder;
let struct_layout = Layout::Struct(field_layouts); let struct_layout = Layout::struct_no_name_order(field_layouts);
let struct_type = basic_type_from_layout(env, &struct_layout); let struct_type = basic_type_from_layout(env, &struct_layout);
let wrapper_type = env let wrapper_type = env
@ -3522,7 +3521,7 @@ fn expose_function_to_host_help_c_abi_gen_test<'a, 'ctx, 'env>(
call_roc_function( call_roc_function(
env, env,
roc_wrapper_function, roc_wrapper_function,
&Layout::Struct(&[Layout::u64(), return_layout]), &Layout::struct_no_name_order(&[Layout::u64(), return_layout]),
arguments_for_call, arguments_for_call,
) )
}; };
@ -3903,7 +3902,7 @@ fn roc_result_layout<'a>(
) -> Layout<'a> { ) -> Layout<'a> {
let elements = [Layout::u64(), Layout::usize(target_info), return_layout]; let elements = [Layout::u64(), Layout::usize(target_info), return_layout];
Layout::Struct(arena.alloc(elements)) Layout::struct_no_name_order(arena.alloc(elements))
} }
fn roc_result_type<'a, 'ctx, 'env>( fn roc_result_type<'a, 'ctx, 'env>(
@ -5363,7 +5362,7 @@ fn run_low_level<'a, 'ctx, 'env>(
let (string, _string_layout) = load_symbol_and_layout(scope, &args[0]); let (string, _string_layout) = load_symbol_and_layout(scope, &args[0]);
let number_layout = match layout { let number_layout = match layout {
Layout::Struct(fields) => fields[0], // TODO: why is it sometimes a struct? Layout::Struct { field_layouts, .. } => field_layouts[0], // TODO: why is it sometimes a struct?
_ => unreachable!(), _ => unreachable!(),
}; };
@ -6977,9 +6976,9 @@ fn build_int_unary_op<'a, 'ctx, 'env>(
// return_layout : Result N [ OutOfBounds ]* ~ { result: N, out_of_bounds: bool } // return_layout : Result N [ OutOfBounds ]* ~ { result: N, out_of_bounds: bool }
let target_int_width = match return_layout { let target_int_width = match return_layout {
Layout::Struct(layouts) if layouts.len() == 2 => { Layout::Struct { field_layouts, .. } if field_layouts.len() == 2 => {
debug_assert!(matches!(layouts[1], Layout::Builtin(Builtin::Bool))); debug_assert!(matches!(field_layouts[1], Layout::Builtin(Builtin::Bool)));
match layouts[0] { match field_layouts[0] {
Layout::Builtin(Builtin::Int(iw)) => iw, Layout::Builtin(Builtin::Int(iw)) => iw,
layout => internal_error!( layout => internal_error!(
"There can only be an int layout here, found {:?}!", "There can only be an int layout here, found {:?}!",

3
compiler/gen_llvm/src/llvm/build_dict.rs
View file

@ -735,8 +735,7 @@ pub fn set_from_list<'a, 'ctx, 'env>(
let result_alloca = builder.build_alloca(zig_dict_type(env), "result_alloca"); let result_alloca = builder.build_alloca(zig_dict_type(env), "result_alloca");
let alignment = let alignment = Alignment::from_key_value_layout(key_layout, &Layout::UNIT, env.target_info);
Alignment::from_key_value_layout(key_layout, &Layout::Struct(&[]), env.target_info);
let alignment_iv = alignment.as_int_value(env.context); let alignment_iv = alignment.as_int_value(env.context);
let hash_fn = build_hash_wrapper(env, layout_ids, key_layout); let hash_fn = build_hash_wrapper(env, layout_ids, key_layout);

10
compiler/gen_llvm/src/llvm/build_hash.rs
View file

@ -50,10 +50,10 @@ fn build_hash_layout<'a, 'ctx, 'env>(
hash_builtin(env, layout_ids, seed, val, layout, builtin, when_recursive) hash_builtin(env, layout_ids, seed, val, layout, builtin, when_recursive)
} }
Layout::Struct(fields) => build_hash_struct( Layout::Struct { field_layouts, .. } => build_hash_struct(
env, env,
layout_ids, layout_ids,
fields, field_layouts,
when_recursive, when_recursive,
seed, seed,
val.into_struct_value(), val.into_struct_value(),
@ -166,7 +166,7 @@ fn build_hash_struct<'a, 'ctx, 'env>(
let block = env.builder.get_insert_block().expect("to be in a function"); let block = env.builder.get_insert_block().expect("to be in a function");
let di_location = env.builder.get_current_debug_location().unwrap(); let di_location = env.builder.get_current_debug_location().unwrap();
let struct_layout = Layout::Struct(field_layouts); let struct_layout = Layout::struct_no_name_order(field_layouts);
let symbol = Symbol::GENERIC_HASH; let symbol = Symbol::GENERIC_HASH;
let fn_name = layout_ids let fn_name = layout_ids
@ -248,7 +248,7 @@ fn hash_struct<'a, 'ctx, 'env>(
) -> IntValue<'ctx> { ) -> IntValue<'ctx> {
let ptr_bytes = env.target_info; let ptr_bytes = env.target_info;
let layout = Layout::Struct(field_layouts); let layout = Layout::struct_no_name_order(field_layouts);
// Optimization: if the bit representation of equal values is the same // Optimization: if the bit representation of equal values is the same
// just hash the bits. Caveat here is tags: e.g. `Nothing` in `Just a` // just hash the bits. Caveat here is tags: e.g. `Nothing` in `Just a`
@ -818,7 +818,7 @@ fn hash_ptr_to_struct<'a, 'ctx, 'env>(
.build_struct_gep(wrapper_ptr, TAG_DATA_INDEX, "get_tag_data") .build_struct_gep(wrapper_ptr, TAG_DATA_INDEX, "get_tag_data")
.unwrap(); .unwrap();
let struct_layout = Layout::Struct(field_layouts); let struct_layout = Layout::struct_no_name_order(field_layouts);
let struct_type = basic_type_from_layout(env, &struct_layout); let struct_type = basic_type_from_layout(env, &struct_layout);
let struct_ptr = env let struct_ptr = env
.builder .builder

12
compiler/gen_llvm/src/llvm/compare.rs
View file

@ -161,10 +161,10 @@ fn build_eq<'a, 'ctx, 'env>(
build_eq_builtin(env, layout_ids, lhs_val, rhs_val, builtin, when_recursive) build_eq_builtin(env, layout_ids, lhs_val, rhs_val, builtin, when_recursive)
} }
Layout::Struct(fields) => build_struct_eq( Layout::Struct { field_layouts, .. } => build_struct_eq(
env, env,
layout_ids, layout_ids,
fields, field_layouts,
when_recursive, when_recursive,
lhs_val.into_struct_value(), lhs_val.into_struct_value(),
rhs_val.into_struct_value(), rhs_val.into_struct_value(),
@ -330,11 +330,11 @@ fn build_neq<'a, 'ctx, 'env>(
build_neq_builtin(env, layout_ids, lhs_val, rhs_val, builtin, when_recursive) build_neq_builtin(env, layout_ids, lhs_val, rhs_val, builtin, when_recursive)
} }
Layout::Struct(fields) => { Layout::Struct { field_layouts, .. } => {
let is_equal = build_struct_eq( let is_equal = build_struct_eq(
env, env,
layout_ids, layout_ids,
fields, field_layouts,
when_recursive, when_recursive,
lhs_val.into_struct_value(), lhs_val.into_struct_value(),
rhs_val.into_struct_value(), rhs_val.into_struct_value(),
@ -587,7 +587,7 @@ fn build_struct_eq<'a, 'ctx, 'env>(
let block = env.builder.get_insert_block().expect("to be in a function"); let block = env.builder.get_insert_block().expect("to be in a function");
let di_location = env.builder.get_current_debug_location().unwrap(); let di_location = env.builder.get_current_debug_location().unwrap();
let struct_layout = Layout::Struct(field_layouts); let struct_layout = Layout::struct_no_name_order(field_layouts);
let symbol = Symbol::GENERIC_EQ; let symbol = Symbol::GENERIC_EQ;
let fn_name = layout_ids let fn_name = layout_ids
@ -1208,7 +1208,7 @@ fn eq_ptr_to_struct<'a, 'ctx, 'env>(
tag1: PointerValue<'ctx>, tag1: PointerValue<'ctx>,
tag2: PointerValue<'ctx>, tag2: PointerValue<'ctx>,
) -> IntValue<'ctx> { ) -> IntValue<'ctx> {
let struct_layout = Layout::Struct(field_layouts); let struct_layout = Layout::struct_no_name_order(field_layouts);
let wrapper_type = basic_type_from_layout(env, &struct_layout); let wrapper_type = basic_type_from_layout(env, &struct_layout);
debug_assert!(wrapper_type.is_struct_type()); debug_assert!(wrapper_type.is_struct_type());

10
compiler/gen_llvm/src/llvm/convert.rs
View file

@ -28,7 +28,10 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>(
use Layout::*; use Layout::*;
match layout { match layout {
Struct(sorted_fields) => basic_type_from_record(env, sorted_fields), Struct {
field_layouts: sorted_fields,
..
} => basic_type_from_record(env, sorted_fields),
LambdaSet(lambda_set) => basic_type_from_layout(env, &lambda_set.runtime_representation()), LambdaSet(lambda_set) => basic_type_from_layout(env, &lambda_set.runtime_representation()),
Union(union_layout) => { Union(union_layout) => {
use UnionLayout::*; use UnionLayout::*;
@ -86,7 +89,10 @@ pub fn basic_type_from_layout_1<'a, 'ctx, 'env>(
use Layout::*; use Layout::*;
match layout { match layout {
Struct(sorted_fields) => basic_type_from_record(env, sorted_fields), Struct {
field_layouts: sorted_fields,
..
} => basic_type_from_record(env, sorted_fields),
LambdaSet(lambda_set) => { LambdaSet(lambda_set) => {
basic_type_from_layout_1(env, &lambda_set.runtime_representation()) basic_type_from_layout_1(env, &lambda_set.runtime_representation())
} }

15
compiler/gen_llvm/src/llvm/refcounting.rs
View file

@ -280,7 +280,7 @@ fn modify_refcount_struct<'a, 'ctx, 'env>(
let block = env.builder.get_insert_block().expect("to be in a function"); let block = env.builder.get_insert_block().expect("to be in a function");
let di_location = env.builder.get_current_debug_location().unwrap(); let di_location = env.builder.get_current_debug_location().unwrap();
let layout = Layout::Struct(layouts); let layout = Layout::struct_no_name_order(layouts);
let (_, fn_name) = function_name_from_mode( let (_, fn_name) = function_name_from_mode(
layout_ids, layout_ids,
@ -440,7 +440,7 @@ fn modify_refcount_builtin<'a, 'ctx, 'env>(
} }
Set(element_layout) => { Set(element_layout) => {
let key_layout = element_layout; let key_layout = element_layout;
let value_layout = &Layout::Struct(&[]); let value_layout = &Layout::UNIT;
let function = modify_refcount_dict( let function = modify_refcount_dict(
env, env,
@ -619,8 +619,9 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>(
} }
} }
Struct(layouts) => { Struct { field_layouts, .. } => {
let function = modify_refcount_struct(env, layout_ids, layouts, mode, when_recursive); let function =
modify_refcount_struct(env, layout_ids, field_layouts, mode, when_recursive);
Some(function) Some(function)
} }
@ -1312,7 +1313,8 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>(
env.builder.position_at_end(block); env.builder.position_at_end(block);
let wrapper_type = basic_type_from_layout(env, &Layout::Struct(field_layouts)); let wrapper_type =
basic_type_from_layout(env, &Layout::struct_no_name_order(field_layouts));
// cast the opaque pointer to a pointer of the correct shape // cast the opaque pointer to a pointer of the correct shape
let struct_ptr = env let struct_ptr = env
@ -1720,7 +1722,8 @@ fn modify_refcount_union_help<'a, 'ctx, 'env>(
let block = env.context.append_basic_block(parent, "tag_id_modify"); let block = env.context.append_basic_block(parent, "tag_id_modify");
env.builder.position_at_end(block); env.builder.position_at_end(block);
let wrapper_type = basic_type_from_layout(env, &Layout::Struct(field_layouts)); let wrapper_type =
basic_type_from_layout(env, &Layout::struct_no_name_order(field_layouts));
debug_assert!(wrapper_type.is_struct_type()); debug_assert!(wrapper_type.is_struct_type());
let opaque_tag_data_ptr = env let opaque_tag_data_ptr = env

2
compiler/gen_wasm/src/backend.rs
View file

@ -884,7 +884,7 @@ impl<'a> WasmBackend<'a> {
storage: &StoredValue, storage: &StoredValue,
fields: &'a [Symbol], fields: &'a [Symbol],
) { ) {
if matches!(layout, Layout::Struct(_)) { if matches!(layout, Layout::Struct { .. }) {
match storage { match storage {
StoredValue::StackMemory { location, size, .. } => { StoredValue::StackMemory { location, size, .. } => {
if *size > 0 { if *size > 0 {

2
compiler/gen_wasm/src/layout.rs
View file

@ -88,7 +88,7 @@ impl WasmLayout {
}, },
Layout::Builtin(Str | Dict(_, _) | Set(_) | List(_)) Layout::Builtin(Str | Dict(_, _) | Set(_) | List(_))
| Layout::Struct(_) | Layout::Struct { .. }
| Layout::LambdaSet(_) | Layout::LambdaSet(_)
| Layout::Union(NonRecursive(_)) => Self::StackMemory { | Layout::Union(NonRecursive(_)) => Self::StackMemory {
size, size,

6
compiler/gen_wasm/src/low_level.rs
View file

@ -212,7 +212,7 @@ impl<'a> LowLevelCall<'a> {
} }
StrToNum => { StrToNum => {
let number_layout = match self.ret_layout { let number_layout = match self.ret_layout {
Layout::Struct(fields) => fields[0], Layout::Struct { field_layouts, .. } => field_layouts[0],
_ => { _ => {
internal_error!("Unexpected mono layout {:?} for StrToNum", self.ret_layout) internal_error!("Unexpected mono layout {:?} for StrToNum", self.ret_layout)
} }
@ -711,7 +711,7 @@ impl<'a> LowLevelCall<'a> {
// Empty record is always equal to empty record. // Empty record is always equal to empty record.
// There are no runtime arguments to check, so just emit true or false. // There are no runtime arguments to check, so just emit true or false.
Layout::Struct(fields) if fields.is_empty() => { Layout::Struct { field_layouts, .. } if field_layouts.is_empty() => {
backend.code_builder.i32_const(!invert_result as i32); backend.code_builder.i32_const(!invert_result as i32);
} }
@ -722,7 +722,7 @@ impl<'a> LowLevelCall<'a> {
} }
Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_) | Builtin::List(_)) Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_) | Builtin::List(_))
| Layout::Struct(_) | Layout::Struct { .. }
| Layout::Union(_) | Layout::Union(_)
| Layout::LambdaSet(_) => { | Layout::LambdaSet(_) => {
// Don't want Zig calling convention here, we're calling internal Roc functions // Don't want Zig calling convention here, we're calling internal Roc functions

2
compiler/load/src/file.rs
View file

@ -2101,7 +2101,7 @@ fn finish_specialization(
EntryPoint { EntryPoint {
layout: roc_mono::ir::ProcLayout { layout: roc_mono::ir::ProcLayout {
arguments: &[], arguments: &[],
result: Layout::Struct(&[]), result: Layout::struct_no_name_order(&[]),
}, },
symbol, symbol,
} }

13
compiler/mono/src/alias_analysis.rs
View file

@ -308,7 +308,7 @@ fn build_entry_point(
let block = builder.add_block(); let block = builder.add_block();
let type_id = layout_spec(&mut builder, &Layout::Struct(layouts))?; let type_id = layout_spec(&mut builder, &Layout::struct_no_name_order(layouts))?;
let argument = builder.add_unknown_with(block, &[], type_id)?; let argument = builder.add_unknown_with(block, &[], type_id)?;
@ -349,7 +349,10 @@ fn proc_spec<'a>(proc: &Proc<'a>) -> Result<(FuncDef, MutSet<UnionLayout<'a>>)>
let value_id = stmt_spec(&mut builder, &mut env, block, &proc.ret_layout, &proc.body)?; let value_id = stmt_spec(&mut builder, &mut env, block, &proc.ret_layout, &proc.body)?;
let root = BlockExpr(block, value_id); let root = BlockExpr(block, value_id);
let arg_type_id = layout_spec(&mut builder, &Layout::Struct(&argument_layouts))?; let arg_type_id = layout_spec(
&mut builder,
&Layout::struct_no_name_order(&argument_layouts),
)?;
let ret_type_id = layout_spec(&mut builder, &proc.ret_layout)?; let ret_type_id = layout_spec(&mut builder, &proc.ret_layout)?;
let spec = builder.build(arg_type_id, ret_type_id, root)?; let spec = builder.build(arg_type_id, ret_type_id, root)?;
@ -1135,7 +1138,7 @@ fn call_spec(
// ListFindUnsafe returns { value: v, found: Bool=Int1 } // ListFindUnsafe returns { value: v, found: Bool=Int1 }
let output_layouts = vec![argument_layouts[0], Layout::Builtin(Builtin::Bool)]; let output_layouts = vec![argument_layouts[0], Layout::Builtin(Builtin::Bool)];
let output_layout = Layout::Struct(&output_layouts); let output_layout = Layout::struct_no_name_order(&output_layouts);
let output_type = layout_spec(builder, &output_layout)?; let output_type = layout_spec(builder, &output_layout)?;
let loop_body = |builder: &mut FuncDefBuilder, block, output| { let loop_body = |builder: &mut FuncDefBuilder, block, output| {
@ -1672,7 +1675,9 @@ fn layout_spec_help(
match layout { match layout {
Builtin(builtin) => builtin_spec(builder, builtin, when_recursive), Builtin(builtin) => builtin_spec(builder, builtin, when_recursive),
Struct(fields) => build_recursive_tuple_type(builder, fields, when_recursive), Struct { field_layouts, .. } => {
build_recursive_tuple_type(builder, field_layouts, when_recursive)
}
LambdaSet(lambda_set) => layout_spec_help( LambdaSet(lambda_set) => layout_spec_help(
builder, builder,
&lambda_set.runtime_representation(), &lambda_set.runtime_representation(),

2
compiler/mono/src/code_gen_help/equality.rs
View file

@ -32,7 +32,7 @@ pub fn eq_generic<'a>(
} }
Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_)) => eq_todo(), Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_)) => eq_todo(),
Layout::Builtin(Builtin::List(elem_layout)) => eq_list(root, ident_ids, ctx, elem_layout), Layout::Builtin(Builtin::List(elem_layout)) => eq_list(root, ident_ids, ctx, elem_layout),
Layout::Struct(field_layouts) => eq_struct(root, ident_ids, ctx, field_layouts), Layout::Struct { field_layouts, .. } => eq_struct(root, ident_ids, ctx, field_layouts),
Layout::Union(union_layout) => eq_tag_union(root, ident_ids, ctx, union_layout), Layout::Union(union_layout) => eq_tag_union(root, ident_ids, ctx, union_layout),
Layout::LambdaSet(_) => unreachable!("`==` is not defined on functions"), Layout::LambdaSet(_) => unreachable!("`==` is not defined on functions"),
Layout::RecursivePointer => { Layout::RecursivePointer => {

16
compiler/mono/src/code_gen_help/mod.rs
View file

@ -15,7 +15,7 @@ mod equality;
mod refcount; mod refcount;
const LAYOUT_BOOL: Layout = Layout::Builtin(Builtin::Bool); const LAYOUT_BOOL: Layout = Layout::Builtin(Builtin::Bool);
const LAYOUT_UNIT: Layout = Layout::Struct(&[]); const LAYOUT_UNIT: Layout = Layout::UNIT;
const ARG_1: Symbol = Symbol::ARG_1; const ARG_1: Symbol = Symbol::ARG_1;
const ARG_2: Symbol = Symbol::ARG_2; const ARG_2: Symbol = Symbol::ARG_2;
@ -354,9 +354,15 @@ impl<'a> CodeGenHelp<'a> {
Layout::Builtin(_) => layout, Layout::Builtin(_) => layout,
Layout::Struct(fields) => { Layout::Struct {
let new_fields_iter = fields.iter().map(|f| self.replace_rec_ptr(ctx, *f)); field_layouts,
Layout::Struct(self.arena.alloc_slice_fill_iter(new_fields_iter)) field_order_hash,
} => {
let new_fields_iter = field_layouts.iter().map(|f| self.replace_rec_ptr(ctx, *f));
Layout::Struct {
field_layouts: self.arena.alloc_slice_fill_iter(new_fields_iter),
field_order_hash,
}
} }
Layout::Union(UnionLayout::NonRecursive(tags)) => { Layout::Union(UnionLayout::NonRecursive(tags)) => {
@ -462,7 +468,7 @@ fn layout_needs_helper_proc(layout: &Layout, op: HelperOp) -> bool {
Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_) | Builtin::List(_)) => true, Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_) | Builtin::List(_)) => true,
Layout::Struct(fields) => !fields.is_empty(), Layout::Struct { field_layouts, .. } => !field_layouts.is_empty(),
Layout::Union(UnionLayout::NonRecursive(tags)) => !tags.is_empty(), Layout::Union(UnionLayout::NonRecursive(tags)) => !tags.is_empty(),

8
compiler/mono/src/code_gen_help/refcount.rs
View file

@ -12,7 +12,7 @@ use crate::layout::{Builtin, Layout, TagIdIntType, UnionLayout};
use super::{CodeGenHelp, Context, HelperOp}; use super::{CodeGenHelp, Context, HelperOp};
const LAYOUT_BOOL: Layout = Layout::Builtin(Builtin::Bool); const LAYOUT_BOOL: Layout = Layout::Builtin(Builtin::Bool);
const LAYOUT_UNIT: Layout = Layout::Struct(&[]); const LAYOUT_UNIT: Layout = Layout::UNIT;
const LAYOUT_PTR: Layout = Layout::RecursivePointer; const LAYOUT_PTR: Layout = Layout::RecursivePointer;
const LAYOUT_U32: Layout = Layout::Builtin(Builtin::Int(IntWidth::U32)); const LAYOUT_U32: Layout = Layout::Builtin(Builtin::Int(IntWidth::U32));
@ -69,7 +69,7 @@ pub fn refcount_stmt<'a>(
} }
// Struct and non-recursive Unions are stack-only, so DecRef is a no-op // Struct and non-recursive Unions are stack-only, so DecRef is a no-op
Layout::Struct(_) => following, Layout::Struct { .. } => following,
Layout::Union(UnionLayout::NonRecursive(_)) => following, Layout::Union(UnionLayout::NonRecursive(_)) => following,
// Inline the refcounting code instead of making a function. Don't iterate fields, // Inline the refcounting code instead of making a function. Don't iterate fields,
@ -111,7 +111,7 @@ pub fn refcount_generic<'a>(
refcount_list(root, ident_ids, ctx, &layout, elem_layout, structure) refcount_list(root, ident_ids, ctx, &layout, elem_layout, structure)
} }
Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_)) => rc_todo(), Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_)) => rc_todo(),
Layout::Struct(field_layouts) => { Layout::Struct { field_layouts, .. } => {
refcount_struct(root, ident_ids, ctx, field_layouts, structure) refcount_struct(root, ident_ids, ctx, field_layouts, structure)
} }
Layout::Union(union_layout) => { Layout::Union(union_layout) => {
@ -135,7 +135,7 @@ pub fn is_rc_implemented_yet(layout: &Layout) -> bool {
Layout::Builtin(Builtin::Dict(..) | Builtin::Set(_)) => false, Layout::Builtin(Builtin::Dict(..) | Builtin::Set(_)) => false,
Layout::Builtin(Builtin::List(elem_layout)) => is_rc_implemented_yet(elem_layout), Layout::Builtin(Builtin::List(elem_layout)) => is_rc_implemented_yet(elem_layout),
Layout::Builtin(_) => true, Layout::Builtin(_) => true,
Layout::Struct(fields) => fields.iter().all(is_rc_implemented_yet), Layout::Struct { field_layouts, .. } => field_layouts.iter().all(is_rc_implemented_yet),
Layout::Union(union_layout) => match union_layout { Layout::Union(union_layout) => match union_layout {
NonRecursive(tags) => tags NonRecursive(tags) => tags
.iter() .iter()

8
compiler/mono/src/decision_tree.rs
View file

@ -747,7 +747,11 @@ fn to_relevant_branch_help<'a>(
// the test matches the constructor of this pattern // the test matches the constructor of this pattern
match layout { match layout {
UnionLayout::NonRecursive([[Layout::Struct([_])]]) => { UnionLayout::NonRecursive(
[[Layout::Struct {
field_layouts: [_], ..
}]],
) => {
// a one-element record equivalent // a one-element record equivalent
// Theory: Unbox doesn't have any value for us // Theory: Unbox doesn't have any value for us
debug_assert_eq!(arguments.len(), 1); debug_assert_eq!(arguments.len(), 1);
@ -1235,7 +1239,7 @@ fn path_to_expr_help<'a>(
layout = inner_layout; layout = inner_layout;
} }
Layout::Struct(field_layouts) => { Layout::Struct { field_layouts, .. } => {
debug_assert!(field_layouts.len() > 1); debug_assert!(field_layouts.len() > 1);
let inner_expr = Expr::StructAtIndex { let inner_expr = Expr::StructAtIndex {

47
compiler/mono/src/ir.rs
View file

@ -1125,7 +1125,7 @@ impl<'a> Param<'a> {
pub const EMPTY: Self = Param { pub const EMPTY: Self = Param {
symbol: Symbol::EMPTY_PARAM, symbol: Symbol::EMPTY_PARAM,
borrow: false, borrow: false,
layout: Layout::Struct(&[]), layout: Layout::UNIT,
}; };
} }
@ -1725,11 +1725,11 @@ impl<'a> Stmt<'a> {
use Stmt::*; use Stmt::*;
match self { match self {
Let(symbol, expr, _layout, cont) => alloc Let(symbol, expr, layout, cont) => alloc
.text("let ") .text("let ")
.append(symbol_to_doc(alloc, *symbol)) .append(symbol_to_doc(alloc, *symbol))
.append(" : ") .append(" : ")
.append(alloc.text(format!("{:?}", _layout))) .append(layout.to_doc(alloc, Parens::NotNeeded))
.append(" = ") .append(" = ")
.append(expr.to_doc(alloc)) .append(expr.to_doc(alloc))
.append(";") .append(";")
@ -2436,7 +2436,7 @@ fn specialize_external<'a>(
let closure_data_layout = match opt_closure_layout { let closure_data_layout = match opt_closure_layout {
Some(lambda_set) => Layout::LambdaSet(lambda_set), Some(lambda_set) => Layout::LambdaSet(lambda_set),
None => Layout::Struct(&[]), None => Layout::UNIT,
}; };
// I'm not sure how to handle the closure case, does it ever occur? // I'm not sure how to handle the closure case, does it ever occur?
@ -3985,7 +3985,7 @@ pub fn with_hole<'a>(
.unwrap_or_else(|err| panic!("TODO turn fn_var into a RuntimeError {:?}", err)); .unwrap_or_else(|err| panic!("TODO turn fn_var into a RuntimeError {:?}", err));
let field_layouts = match &record_layout { let field_layouts = match &record_layout {
Layout::Struct(layouts) => *layouts, Layout::Struct { field_layouts, .. } => *field_layouts,
other => arena.alloc([*other]), other => arena.alloc([*other]),
}; };
@ -4701,7 +4701,7 @@ fn construct_closure_data<'a>(
Vec::from_iter_in(combined.iter().map(|(_, b)| **b), env.arena).into_bump_slice(); Vec::from_iter_in(combined.iter().map(|(_, b)| **b), env.arena).into_bump_slice();
debug_assert_eq!( debug_assert_eq!(
Layout::Struct(field_layouts), Layout::struct_no_name_order(field_layouts),
lambda_set.runtime_representation() lambda_set.runtime_representation()
); );
@ -4785,9 +4785,7 @@ fn convert_tag_union<'a>(
"The `[]` type has no constructors, source var {:?}", "The `[]` type has no constructors, source var {:?}",
variant_var variant_var
), ),
Unit | UnitWithArguments => { Unit | UnitWithArguments => Stmt::Let(assigned, Expr::Struct(&[]), Layout::UNIT, hole),
Stmt::Let(assigned, Expr::Struct(&[]), Layout::Struct(&[]), hole)
}
BoolUnion { ttrue, .. } => Stmt::Let( BoolUnion { ttrue, .. } => Stmt::Let(
assigned, assigned,
Expr::Literal(Literal::Bool(tag_name == ttrue)), Expr::Literal(Literal::Bool(tag_name == ttrue)),
@ -5096,7 +5094,7 @@ fn sorted_field_symbols<'a>(
// Note it does not catch the use of `[]` currently. // Note it does not catch the use of `[]` currently.
use roc_can::expr::Expr; use roc_can::expr::Expr;
arg.value = Expr::RuntimeError(RuntimeError::VoidValue); arg.value = Expr::RuntimeError(RuntimeError::VoidValue);
Layout::Struct(&[]) Layout::UNIT
} }
Err(LayoutProblem::Erroneous) => { Err(LayoutProblem::Erroneous) => {
// something went very wrong // something went very wrong
@ -5191,7 +5189,10 @@ fn register_capturing_closure<'a>(
Content::Structure(FlatType::Func(_, closure_var, _)) => { Content::Structure(FlatType::Func(_, closure_var, _)) => {
match LambdaSet::from_var(env.arena, env.subs, closure_var, env.target_info) { match LambdaSet::from_var(env.arena, env.subs, closure_var, env.target_info) {
Ok(lambda_set) => { Ok(lambda_set) => {
if let Layout::Struct(&[]) = lambda_set.runtime_representation() { if let Layout::Struct {
field_layouts: &[], ..
} = lambda_set.runtime_representation()
{
CapturedSymbols::None CapturedSymbols::None
} else { } else {
let mut temp = Vec::from_iter_in(captured_symbols, env.arena); let mut temp = Vec::from_iter_in(captured_symbols, env.arena);
@ -6255,7 +6256,7 @@ fn store_pattern_help<'a>(
let mut fields = Vec::with_capacity_in(arguments.len(), env.arena); let mut fields = Vec::with_capacity_in(arguments.len(), env.arena);
fields.extend(arguments.iter().map(|x| x.1)); fields.extend(arguments.iter().map(|x| x.1));
let layout = Layout::Struct(fields.into_bump_slice()); let layout = Layout::struct_no_name_order(fields.into_bump_slice());
return store_newtype_pattern( return store_newtype_pattern(
env, env,
@ -6676,7 +6677,7 @@ fn force_thunk<'a>(
} }
fn let_empty_struct<'a>(assigned: Symbol, hole: &'a Stmt<'a>) -> Stmt<'a> { fn let_empty_struct<'a>(assigned: Symbol, hole: &'a Stmt<'a>) -> Stmt<'a> {
Stmt::Let(assigned, Expr::Struct(&[]), Layout::Struct(&[]), hole) Stmt::Let(assigned, Expr::Struct(&[]), Layout::UNIT, hole)
} }
/// If the symbol is a function, make sure it is properly specialized /// If the symbol is a function, make sure it is properly specialized
@ -8457,7 +8458,7 @@ where
env.arena.alloc(result), env.arena.alloc(result),
) )
} }
Layout::Struct(_) => match lambda_set.set.get(0) { Layout::Struct { .. } => match lambda_set.set.get(0) {
Some((function_symbol, _)) => { Some((function_symbol, _)) => {
let call_spec_id = env.next_call_specialization_id(); let call_spec_id = env.next_call_specialization_id();
let update_mode = env.next_update_mode_id(); let update_mode = env.next_update_mode_id();
@ -8630,7 +8631,10 @@ fn match_on_lambda_set<'a>(
env.arena.alloc(result), env.arena.alloc(result),
) )
} }
Layout::Struct(fields) => { Layout::Struct {
field_layouts,
field_order_hash,
} => {
let function_symbol = lambda_set.set[0].0; let function_symbol = lambda_set.set[0].0;
union_lambda_set_branch_help( union_lambda_set_branch_help(
@ -8638,7 +8642,10 @@ fn match_on_lambda_set<'a>(
function_symbol, function_symbol,
lambda_set, lambda_set,
closure_data_symbol, closure_data_symbol,
Layout::Struct(fields), Layout::Struct {
field_layouts,
field_order_hash,
},
argument_symbols, argument_symbols,
argument_layouts, argument_layouts,
return_layout, return_layout,
@ -8797,7 +8804,9 @@ fn union_lambda_set_branch_help<'a>(
hole: &'a Stmt<'a>, hole: &'a Stmt<'a>,
) -> Stmt<'a> { ) -> Stmt<'a> {
let (argument_layouts, argument_symbols) = match closure_data_layout { let (argument_layouts, argument_symbols) = match closure_data_layout {
Layout::Struct(&[]) Layout::Struct {
field_layouts: &[], ..
}
| Layout::Builtin(Builtin::Bool) | Layout::Builtin(Builtin::Bool)
| Layout::Builtin(Builtin::Int(IntWidth::U8)) => { | Layout::Builtin(Builtin::Int(IntWidth::U8)) => {
(argument_layouts_slice, argument_symbols_slice) (argument_layouts_slice, argument_symbols_slice)
@ -8924,7 +8933,9 @@ fn enum_lambda_set_branch<'a>(
let assigned = result_symbol; let assigned = result_symbol;
let (argument_layouts, argument_symbols) = match closure_data_layout { let (argument_layouts, argument_symbols) = match closure_data_layout {
Layout::Struct(&[]) Layout::Struct {
field_layouts: &[], ..
}
| Layout::Builtin(Builtin::Bool) | Layout::Builtin(Builtin::Bool)
| Layout::Builtin(Builtin::Int(IntWidth::U8)) => { | Layout::Builtin(Builtin::Int(IntWidth::U8)) => {
(argument_layouts_slice, argument_symbols_slice) (argument_layouts_slice, argument_symbols_slice)

113
compiler/mono/src/layout.rs
View file

@ -11,8 +11,9 @@ use roc_types::subs::{
Content, FlatType, RecordFields, Subs, UnionTags, UnsortedUnionTags, Variable, Content, FlatType, RecordFields, Subs, UnionTags, UnsortedUnionTags, Variable,
}; };
use roc_types::types::{gather_fields_unsorted_iter, RecordField}; use roc_types::types::{gather_fields_unsorted_iter, RecordField};
use std::collections::hash_map::Entry; use std::collections::hash_map::{DefaultHasher, Entry};
use std::collections::HashMap; use std::collections::HashMap;
use std::hash::{Hash, Hasher};
use ven_pretty::{DocAllocator, DocBuilder}; use ven_pretty::{DocAllocator, DocBuilder};
// if your changes cause this number to go down, great! // if your changes cause this number to go down, great!
@ -201,14 +202,44 @@ impl<'a> RawFunctionLayout<'a> {
} }
} }
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct FieldOrderHash(u64);
impl FieldOrderHash {
// NB: This should really be a proper "zero" hash via `DefaultHasher::new().finish()`, but Rust
// stdlib hashers are not (yet) compile-time-computable.
const ZERO_FIELD_HASH: Self = Self(0);
const IRRELEVANT_NON_ZERO_FIELD_HASH: Self = Self(1);
pub fn from_ordered_fields(fields: &[&Lowercase]) -> Self {
if fields.is_empty() {
// HACK: we must make sure this is always equivalent to a `ZERO_FIELD_HASH`.
return Self::ZERO_FIELD_HASH;
}
let mut hasher = DefaultHasher::new();
fields.iter().for_each(|field| field.hash(&mut hasher));
Self(hasher.finish())
}
}
/// Types for code gen must be monomorphic. No type variables allowed! /// 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)]
pub enum Layout<'a> { pub enum Layout<'a> {
Builtin(Builtin<'a>), Builtin(Builtin<'a>),
/// A layout that is empty (turns into the empty struct in LLVM IR Struct {
/// but for our purposes, not zero-sized, so it does not get dropped from data structures /// Two different struct types can have the same layout, for example
/// this is important for closures that capture zero-sized values /// { a: U8, b: I64 }
Struct(&'a [Layout<'a>]), /// { a: I64, b: U8 }
/// both have the layout {I64, U8}. Not distinguishing the order of record fields can cause
/// us problems during monomorphization when we specialize the same type in different ways,
/// so keep a hash of the record order for disambiguation. This still of course may result
/// in collisions, but it's unlikely.
///
/// See also https://github.com/rtfeldman/roc/issues/2535.
field_order_hash: FieldOrderHash,
field_layouts: &'a [Layout<'a>],
},
Union(UnionLayout<'a>), Union(UnionLayout<'a>),
LambdaSet(LambdaSet<'a>), LambdaSet(LambdaSet<'a>),
RecursivePointer, RecursivePointer,
@ -417,7 +448,9 @@ impl<'a> UnionLayout<'a> {
fn tags_alignment_bytes(tags: &[&[Layout]], target_info: TargetInfo) -> u32 { fn tags_alignment_bytes(tags: &[&[Layout]], target_info: TargetInfo) -> u32 {
tags.iter() tags.iter()
.map(|fields| Layout::Struct(fields).alignment_bytes(target_info)) .map(|field_layouts| {
Layout::struct_no_name_order(field_layouts).alignment_bytes(target_info)
})
.max() .max()
.unwrap_or(0) .unwrap_or(0)
} }
@ -426,14 +459,14 @@ impl<'a> UnionLayout<'a> {
let allocation = match self { let allocation = match self {
UnionLayout::NonRecursive(_) => unreachable!("not heap-allocated"), UnionLayout::NonRecursive(_) => unreachable!("not heap-allocated"),
UnionLayout::Recursive(tags) => Self::tags_alignment_bytes(tags, target_info), UnionLayout::Recursive(tags) => Self::tags_alignment_bytes(tags, target_info),
UnionLayout::NonNullableUnwrapped(fields) => { UnionLayout::NonNullableUnwrapped(field_layouts) => {
Layout::Struct(fields).alignment_bytes(target_info) Layout::struct_no_name_order(field_layouts).alignment_bytes(target_info)
} }
UnionLayout::NullableWrapped { other_tags, .. } => { UnionLayout::NullableWrapped { other_tags, .. } => {
Self::tags_alignment_bytes(other_tags, target_info) Self::tags_alignment_bytes(other_tags, target_info)
} }
UnionLayout::NullableUnwrapped { other_fields, .. } => { UnionLayout::NullableUnwrapped { other_fields, .. } => {
Layout::Struct(other_fields).alignment_bytes(target_info) Layout::struct_no_name_order(other_fields).alignment_bytes(target_info)
} }
}; };
@ -495,12 +528,12 @@ impl<'a> UnionLayout<'a> {
let mut alignment_bytes = 0; let mut alignment_bytes = 0;
for field_layouts in variant_field_layouts { for field_layouts in variant_field_layouts {
let mut data = Layout::Struct(field_layouts); let mut data = Layout::struct_no_name_order(field_layouts);
let fields_and_id; let fields_and_id;
if let Some(id_layout) = id_data_layout { if let Some(id_layout) = id_data_layout {
fields_and_id = [data, id_layout]; fields_and_id = [data, id_layout];
data = Layout::Struct(&fields_and_id); data = Layout::struct_no_name_order(&fields_and_id);
} }
let (variant_size, variant_alignment) = data.stack_size_and_alignment(target_info); let (variant_size, variant_alignment) = data.stack_size_and_alignment(target_info);
@ -590,7 +623,10 @@ impl<'a> LambdaSet<'a> {
} }
pub fn is_represented(&self) -> Option<Layout<'a>> { pub fn is_represented(&self) -> Option<Layout<'a>> {
if let Layout::Struct(&[]) = self.representation { if let Layout::Struct {
field_layouts: &[], ..
} = self.representation
{
None None
} else { } else {
Some(*self.representation) Some(*self.representation)
@ -648,7 +684,7 @@ impl<'a> LambdaSet<'a> {
} => todo!("recursive closures"), } => todo!("recursive closures"),
} }
} }
Layout::Struct(_) => { Layout::Struct { .. } => {
// get the fields from the set, where they are sorted in alphabetic order // get the fields from the set, where they are sorted in alphabetic order
// (and not yet sorted by their alignment) // (and not yet sorted by their alignment)
let (_, fields) = self let (_, fields) = self
@ -673,7 +709,9 @@ impl<'a> LambdaSet<'a> {
argument_layouts argument_layouts
} else { } else {
match self.representation { match self.representation {
Layout::Struct(&[]) => { Layout::Struct {
field_layouts: &[], ..
} => {
// this function does not have anything in its closure, and the lambda set is a // this function does not have anything in its closure, and the lambda set is a
// singleton, so we pass no extra argument // singleton, so we pass no extra argument
argument_layouts argument_layouts
@ -769,7 +807,7 @@ impl<'a> LambdaSet<'a> {
} }
Newtype { Newtype {
arguments: layouts, .. arguments: layouts, ..
} => Layout::Struct(layouts.into_bump_slice()), } => Layout::struct_no_name_order(layouts.into_bump_slice()),
Wrapped(variant) => { Wrapped(variant) => {
use WrappedVariant::*; use WrappedVariant::*;
@ -865,7 +903,10 @@ pub const fn round_up_to_alignment(width: u32, alignment: u32) -> u32 {
impl<'a> Layout<'a> { impl<'a> Layout<'a> {
pub const VOID: Self = Layout::Union(UnionLayout::NonRecursive(&[])); pub const VOID: Self = Layout::Union(UnionLayout::NonRecursive(&[]));
pub const UNIT: Self = Layout::Struct(&[]); pub const UNIT: Self = Layout::Struct {
field_layouts: &[],
field_order_hash: FieldOrderHash::ZERO_FIELD_HASH,
};
fn new_help<'b>( fn new_help<'b>(
env: &mut Env<'a, 'b>, env: &mut Env<'a, 'b>,
@ -926,7 +967,7 @@ impl<'a> Layout<'a> {
match self { match self {
Builtin(builtin) => builtin.safe_to_memcpy(), Builtin(builtin) => builtin.safe_to_memcpy(),
Struct(fields) => fields Struct { field_layouts, .. } => field_layouts
.iter() .iter()
.all(|field_layout| field_layout.safe_to_memcpy()), .all(|field_layout| field_layout.safe_to_memcpy()),
Union(variant) => { Union(variant) => {
@ -990,10 +1031,10 @@ impl<'a> Layout<'a> {
match self { match self {
Builtin(builtin) => builtin.stack_size(target_info), Builtin(builtin) => builtin.stack_size(target_info),
Struct(fields) => { Struct { field_layouts, .. } => {
let mut sum = 0; let mut sum = 0;
for field_layout in *fields { for field_layout in *field_layouts {
sum += field_layout.stack_size(target_info); sum += field_layout.stack_size(target_info);
} }
@ -1020,7 +1061,7 @@ impl<'a> Layout<'a> {
pub fn alignment_bytes(&self, target_info: TargetInfo) -> u32 { pub fn alignment_bytes(&self, target_info: TargetInfo) -> u32 {
match self { match self {
Layout::Struct(fields) => fields Layout::Struct { field_layouts, .. } => field_layouts
.iter() .iter()
.map(|x| x.alignment_bytes(target_info)) .map(|x| x.alignment_bytes(target_info))
.max() .max()
@ -1069,7 +1110,7 @@ impl<'a> Layout<'a> {
pub fn allocation_alignment_bytes(&self, target_info: TargetInfo) -> u32 { pub fn allocation_alignment_bytes(&self, target_info: TargetInfo) -> u32 {
match self { match self {
Layout::Builtin(builtin) => builtin.allocation_alignment_bytes(target_info), Layout::Builtin(builtin) => builtin.allocation_alignment_bytes(target_info),
Layout::Struct(_) => unreachable!("not heap-allocated"), Layout::Struct { .. } => unreachable!("not heap-allocated"),
Layout::Union(union_layout) => union_layout.allocation_alignment_bytes(target_info), Layout::Union(union_layout) => union_layout.allocation_alignment_bytes(target_info),
Layout::LambdaSet(lambda_set) => lambda_set Layout::LambdaSet(lambda_set) => lambda_set
.runtime_representation() .runtime_representation()
@ -1103,7 +1144,7 @@ impl<'a> Layout<'a> {
match self { match self {
Builtin(builtin) => builtin.is_refcounted(), Builtin(builtin) => builtin.is_refcounted(),
Struct(fields) => fields.iter().any(|f| f.contains_refcounted()), Struct { field_layouts, .. } => field_layouts.iter().any(|f| f.contains_refcounted()),
Union(variant) => { Union(variant) => {
use UnionLayout::*; use UnionLayout::*;
@ -1134,8 +1175,8 @@ impl<'a> Layout<'a> {
match self { match self {
Builtin(builtin) => builtin.to_doc(alloc, parens), Builtin(builtin) => builtin.to_doc(alloc, parens),
Struct(fields) => { Struct { field_layouts, .. } => {
let fields_doc = fields.iter().map(|x| x.to_doc(alloc, parens)); let fields_doc = field_layouts.iter().map(|x| x.to_doc(alloc, parens));
alloc alloc
.text("{") .text("{")
@ -1147,6 +1188,18 @@ impl<'a> Layout<'a> {
RecursivePointer => alloc.text("*self"), RecursivePointer => alloc.text("*self"),
} }
} }
/// Used to build a `Layout::Struct` where the field name order is irrelevant.
pub fn struct_no_name_order(field_layouts: &'a [Layout]) -> Self {
if field_layouts.is_empty() {
Self::UNIT
} else {
Self::Struct {
field_layouts,
field_order_hash: FieldOrderHash::IRRELEVANT_NON_ZERO_FIELD_HASH,
}
}
}
} }
/// Avoid recomputing Layout from Variable multiple times. /// Avoid recomputing Layout from Variable multiple times.
@ -1590,6 +1643,11 @@ fn layout_from_flat_type<'a>(
size2.cmp(&size1).then(label1.cmp(label2)) size2.cmp(&size1).then(label1.cmp(label2))
}); });
let ordered_field_names =
Vec::from_iter_in(pairs.iter().map(|(label, _)| *label), arena);
let field_order_hash =
FieldOrderHash::from_ordered_fields(ordered_field_names.as_slice());
let mut layouts = Vec::from_iter_in(pairs.into_iter().map(|t| t.1), arena); let mut layouts = Vec::from_iter_in(pairs.into_iter().map(|t| t.1), arena);
if layouts.len() == 1 { if layouts.len() == 1 {
@ -1597,7 +1655,10 @@ fn layout_from_flat_type<'a>(
// unwrap it. // unwrap it.
Ok(layouts.pop().unwrap()) Ok(layouts.pop().unwrap())
} else { } else {
Ok(Layout::Struct(layouts.into_bump_slice())) Ok(Layout::Struct {
field_order_hash,
field_layouts: layouts.into_bump_slice(),
})
} }
} }
TagUnion(tags, ext_var) => { TagUnion(tags, ext_var) => {
@ -2430,7 +2491,7 @@ fn layout_from_tag_union<'a>(
let answer1 = if field_layouts.len() == 1 { let answer1 = if field_layouts.len() == 1 {
field_layouts[0] field_layouts[0]
} else { } else {
Layout::Struct(field_layouts.into_bump_slice()) Layout::struct_no_name_order(field_layouts.into_bump_slice())
}; };
answer1 answer1

28
compiler/test_gen/src/gen_records.rs
View file

@ -13,6 +13,9 @@ use crate::helpers::wasm::assert_evals_to;
// use crate::assert_wasm_evals_to as assert_evals_to; // use crate::assert_wasm_evals_to as assert_evals_to;
use indoc::indoc; use indoc::indoc;
#[cfg(test)]
use roc_std::RocList;
#[test] #[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))] #[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn basic_record() { fn basic_record() {
@ -1007,6 +1010,31 @@ fn both_have_unique_fields() {
); );
} }
#[test]
// TODO(brian-carroll): enable wasm (https://github.com/rtfeldman/roc/issues/2549)
#[cfg(any(feature = "gen-llvm"))]
// https://github.com/rtfeldman/roc/issues/2535
fn different_proc_types_specialized_to_same_layout() {
assert_evals_to!(
indoc!(
r#"
app "test" provides [ nums ] to "./platform"
alpha = { a: 1, b: 2 }
nums : List U8
nums =
[
alpha.a,
alpha.b,
]
"#
),
RocList::from_slice(&[1, 2]),
RocList<u8>
);
}
#[test] #[test]
#[cfg(any(feature = "gen-llvm"))] #[cfg(any(feature = "gen-llvm"))]
#[should_panic( #[should_panic(

2
compiler/test_mono/generated/alias_variable.txt
View file

@ -1,3 +1,3 @@
procedure Test.0 (): procedure Test.0 ():
let Test.3 : Builtin(Int(I64)) = 3i64; let Test.3 : I64 = 3i64;
ret Test.3; ret Test.3;

2
compiler/test_mono/generated/alias_variable_and_return_it.txt
View file

@ -1,3 +1,3 @@
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Builtin(Int(I64)) = 5i64; let Test.2 : I64 = 5i64;
ret Test.2; ret Test.2;

18
compiler/test_mono/generated/aliased_polymorphic_closure.txt
View file

@ -1,17 +1,17 @@
procedure Test.2 (Test.6, #Attr.12): procedure Test.2 (Test.6, #Attr.12):
let Test.1 : Builtin(Int(U8)) = StructAtIndex 0 #Attr.12; let Test.1 : U8 = StructAtIndex 0 #Attr.12;
let Test.11 : LambdaSet(LambdaSet { set: [( Test.4, [Builtin(Int(U8))])], representation: Struct([Builtin(Int(U8))]) }) = Struct {Test.1}; let Test.11 : {U8} = Struct {Test.1};
ret Test.11; ret Test.11;
procedure Test.4 (Test.5, #Attr.12): procedure Test.4 (Test.5, #Attr.12):
let Test.1 : Builtin(Int(U8)) = StructAtIndex 0 #Attr.12; let Test.1 : U8 = StructAtIndex 0 #Attr.12;
ret Test.1; ret Test.1;
procedure Test.0 (): procedure Test.0 ():
let Test.1 : Builtin(Int(U8)) = 1i64; let Test.1 : U8 = 1i64;
let Test.8 : Struct([]) = Struct {}; let Test.8 : {} = Struct {};
let Test.10 : Struct([]) = Struct {}; let Test.10 : {} = Struct {};
let Test.14 : LambdaSet(LambdaSet { set: [( Test.2, [Builtin(Int(U8))])], representation: Struct([Builtin(Int(U8))]) }) = Struct {Test.1}; let Test.14 : {U8} = Struct {Test.1};
let Test.9 : LambdaSet(LambdaSet { set: [( Test.4, [Builtin(Int(U8))])], representation: Struct([Builtin(Int(U8))]) }) = CallByName Test.2 Test.10 Test.14; let Test.9 : {U8} = CallByName Test.2 Test.10 Test.14;
let Test.7 : Builtin(Int(U8)) = CallByName Test.4 Test.8 Test.9; let Test.7 : U8 = CallByName Test.4 Test.8 Test.9;
ret Test.7; ret Test.7;

8
compiler/test_mono/generated/branch_store_variable.txt
View file

@ -1,9 +1,9 @@
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Builtin(Int(I64)) = 0i64; let Test.2 : I64 = 0i64;
let Test.5 : Builtin(Int(I64)) = 1i64; let Test.5 : I64 = 1i64;
let Test.6 : Builtin(Bool) = lowlevel Eq Test.5 Test.2; let Test.6 : Int1 = lowlevel Eq Test.5 Test.2;
if Test.6 then if Test.6 then
let Test.3 : Builtin(Int(I64)) = 12i64; let Test.3 : I64 = 12i64;
ret Test.3; ret Test.3;
else else
ret Test.2; ret Test.2;

18
compiler/test_mono/generated/closure_in_list.txt
View file

@ -1,21 +1,21 @@
procedure List.7 (#Attr.2): procedure List.7 (#Attr.2):
let Test.8 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.8 : U64 = lowlevel ListLen #Attr.2;
ret Test.8; ret Test.8;
procedure Test.1 (Test.5): procedure Test.1 (Test.5):
let Test.2 : Builtin(Int(I64)) = 41i64; let Test.2 : I64 = 41i64;
let Test.12 : LambdaSet(LambdaSet { set: [( Test.3, [Builtin(Int(I64))])], representation: Struct([Builtin(Int(I64))]) }) = Struct {Test.2}; let Test.12 : {I64} = Struct {Test.2};
let Test.11 : Builtin(List(LambdaSet(LambdaSet { set: [( Test.3, [Builtin(Int(I64))])], representation: Struct([Builtin(Int(I64))]) }))) = Array [Test.12]; let Test.11 : List {I64} = Array [Test.12];
ret Test.11; ret Test.11;
procedure Test.3 (Test.10, #Attr.12): procedure Test.3 (Test.10, #Attr.12):
let Test.2 : Builtin(Int(I64)) = StructAtIndex 0 #Attr.12; let Test.2 : I64 = StructAtIndex 0 #Attr.12;
let Test.2 : Builtin(Int(I64)) = 41i64; let Test.2 : I64 = 41i64;
ret Test.2; ret Test.2;
procedure Test.0 (): procedure Test.0 ():
let Test.9 : Struct([]) = Struct {}; let Test.9 : {} = Struct {};
let Test.7 : Builtin(List(LambdaSet(LambdaSet { set: [( Test.3, [Builtin(Int(I64))])], representation: Struct([Builtin(Int(I64))]) }))) = CallByName Test.1 Test.9; let Test.7 : List {I64} = CallByName Test.1 Test.9;
let Test.6 : Builtin(Int(U64)) = CallByName List.7 Test.7; let Test.6 : U64 = CallByName List.7 Test.7;
dec Test.7; dec Test.7;
ret Test.6; ret Test.6;

8
compiler/test_mono/generated/dict.txt
View file

@ -1,13 +1,13 @@
procedure Dict.2 (): procedure Dict.2 ():
let Test.4 : Builtin(Dict(Union(NonRecursive([])), Union(NonRecursive([])))) = lowlevel DictEmpty ; let Test.4 : Dict [] [] = lowlevel DictEmpty ;
ret Test.4; ret Test.4;
procedure Dict.8 (#Attr.2): procedure Dict.8 (#Attr.2):
let Test.3 : Builtin(Int(U64)) = lowlevel DictSize #Attr.2; let Test.3 : U64 = lowlevel DictSize #Attr.2;
dec #Attr.2; dec #Attr.2;
ret Test.3; ret Test.3;
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Builtin(Dict(Union(NonRecursive([])), Union(NonRecursive([])))) = CallByName Dict.2; let Test.2 : Dict [] [] = CallByName Dict.2;
let Test.1 : Builtin(Int(U64)) = CallByName Dict.8 Test.2; let Test.1 : U64 = CallByName Dict.8 Test.2;
ret Test.1; ret Test.1;

40
compiler/test_mono/generated/empty_list_of_function_type.txt
View file

@ -1,42 +1,42 @@
procedure List.3 (#Attr.2, #Attr.3): procedure List.3 (#Attr.2, #Attr.3):
let Test.20 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.20 : U64 = lowlevel ListLen #Attr.2;
let Test.17 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.20; let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.20;
if Test.17 then if Test.17 then
let Test.19 : LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) }) = lowlevel ListGetUnsafe #Attr.2 #Attr.3; let Test.19 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let Test.18 : Union(NonRecursive([[Struct([])], [LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) })]])) = Ok Test.19; let Test.18 : [C {}, C {}] = Ok Test.19;
ret Test.18; ret Test.18;
else else
let Test.16 : Struct([]) = Struct {}; let Test.16 : {} = Struct {};
let Test.15 : Union(NonRecursive([[Struct([])], [LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) })]])) = Err Test.16; let Test.15 : [C {}, C {}] = Err Test.16;
ret Test.15; ret Test.15;
procedure Test.2 (Test.6): procedure Test.2 (Test.6):
let Test.24 : Builtin(Str) = "bar"; let Test.24 : Str = "bar";
ret Test.24; ret Test.24;
procedure Test.0 (): procedure Test.0 ():
joinpoint Test.22 Test.3: joinpoint Test.22 Test.3:
let Test.14 : Builtin(Int(U64)) = 0i64; let Test.14 : U64 = 0i64;
let Test.7 : Union(NonRecursive([[Struct([])], [LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) })]])) = CallByName List.3 Test.3 Test.14; let Test.7 : [C {}, C {}] = CallByName List.3 Test.3 Test.14;
dec Test.3; dec Test.3;
let Test.11 : Builtin(Int(U8)) = 1i64; let Test.11 : U8 = 1i64;
let Test.12 : Builtin(Int(U8)) = GetTagId Test.7; let Test.12 : U8 = GetTagId Test.7;
let Test.13 : Builtin(Bool) = lowlevel Eq Test.11 Test.12; let Test.13 : Int1 = lowlevel Eq Test.11 Test.12;
if Test.13 then if Test.13 then
let Test.5 : LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) }) = UnionAtIndex (Id 1) (Index 0) Test.7; let Test.5 : {} = UnionAtIndex (Id 1) (Index 0) Test.7;
let Test.9 : Builtin(Str) = "foo"; let Test.9 : Str = "foo";
let Test.8 : Builtin(Str) = CallByName Test.2 Test.9; let Test.8 : Str = CallByName Test.2 Test.9;
dec Test.9; dec Test.9;
ret Test.8; ret Test.8;
else else
let Test.10 : Builtin(Str) = "bad!"; let Test.10 : Str = "bad!";
ret Test.10; ret Test.10;
in in
let Test.25 : Builtin(Bool) = false; let Test.25 : Int1 = false;
if Test.25 then if Test.25 then
let Test.1 : Builtin(List(LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) }))) = Array []; let Test.1 : List {} = Array [];
jump Test.22 Test.1; jump Test.22 Test.1;
else else
let Test.23 : LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) }) = Struct {}; let Test.23 : {} = Struct {};
let Test.21 : Builtin(List(LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) }))) = Array [Test.23]; let Test.21 : List {} = Array [Test.23];
jump Test.22 Test.21; jump Test.22 Test.21;

20
compiler/test_mono/generated/factorial.txt
View file

@ -1,27 +1,27 @@
procedure Num.23 (#Attr.2, #Attr.3): procedure Num.23 (#Attr.2, #Attr.3):
let Test.14 : Builtin(Int(I64)) = lowlevel NumSub #Attr.2 #Attr.3; let Test.14 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Test.14; ret Test.14;
procedure Num.24 (#Attr.2, #Attr.3): procedure Num.24 (#Attr.2, #Attr.3):
let Test.12 : Builtin(Int(I64)) = lowlevel NumMul #Attr.2 #Attr.3; let Test.12 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.12; ret Test.12;
procedure Test.1 (Test.17, Test.18): procedure Test.1 (Test.17, Test.18):
joinpoint Test.7 Test.2 Test.3: joinpoint Test.7 Test.2 Test.3:
let Test.15 : Builtin(Int(I64)) = 0i64; let Test.15 : I64 = 0i64;
let Test.16 : Builtin(Bool) = lowlevel Eq Test.15 Test.2; let Test.16 : Int1 = lowlevel Eq Test.15 Test.2;
if Test.16 then if Test.16 then
ret Test.3; ret Test.3;
else else
let Test.13 : Builtin(Int(I64)) = 1i64; let Test.13 : I64 = 1i64;
let Test.10 : Builtin(Int(I64)) = CallByName Num.23 Test.2 Test.13; let Test.10 : I64 = CallByName Num.23 Test.2 Test.13;
let Test.11 : Builtin(Int(I64)) = CallByName Num.24 Test.2 Test.3; let Test.11 : I64 = CallByName Num.24 Test.2 Test.3;
jump Test.7 Test.10 Test.11; jump Test.7 Test.10 Test.11;
in in
jump Test.7 Test.17 Test.18; jump Test.7 Test.17 Test.18;
procedure Test.0 (): procedure Test.0 ():
let Test.5 : Builtin(Int(I64)) = 10i64; let Test.5 : I64 = 10i64;
let Test.6 : Builtin(Int(I64)) = 1i64; let Test.6 : I64 = 1i64;
let Test.4 : Builtin(Int(I64)) = CallByName Test.1 Test.5 Test.6; let Test.4 : I64 = CallByName Test.1 Test.5 Test.6;
ret Test.4; ret Test.4;

6
compiler/test_mono/generated/fst.txt
View file

@ -3,9 +3,9 @@ procedure Test.1 (Test.2, Test.3):
ret Test.2; ret Test.2;
procedure Test.0 (): procedure Test.0 ():
let Test.5 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; let Test.5 : List I64 = Array [1i64, 2i64, 3i64];
let Test.6 : Builtin(List(Builtin(Int(I64)))) = Array [3i64, 2i64, 1i64]; let Test.6 : List I64 = Array [3i64, 2i64, 1i64];
let Test.4 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.5 Test.6; let Test.4 : List I64 = CallByName Test.1 Test.5 Test.6;
dec Test.6; dec Test.6;
dec Test.5; dec Test.5;
ret Test.4; ret Test.4;

16
compiler/test_mono/generated/guard_pattern_true.txt
View file

@ -1,25 +1,25 @@
procedure Test.1 (Test.3): procedure Test.1 (Test.3):
let Test.6 : Builtin(Int(I64)) = 2i64; let Test.6 : I64 = 2i64;
joinpoint Test.11: joinpoint Test.11:
let Test.10 : Builtin(Int(I64)) = 0i64; let Test.10 : I64 = 0i64;
ret Test.10; ret Test.10;
in in
let Test.13 : Builtin(Int(I64)) = 2i64; let Test.13 : I64 = 2i64;
let Test.14 : Builtin(Bool) = lowlevel Eq Test.13 Test.6; let Test.14 : Int1 = lowlevel Eq Test.13 Test.6;
if Test.14 then if Test.14 then
joinpoint Test.8 Test.12: joinpoint Test.8 Test.12:
if Test.12 then if Test.12 then
let Test.7 : Builtin(Int(I64)) = 42i64; let Test.7 : I64 = 42i64;
ret Test.7; ret Test.7;
else else
jump Test.11; jump Test.11;
in in
let Test.9 : Builtin(Bool) = false; let Test.9 : Int1 = false;
jump Test.8 Test.9; jump Test.8 Test.9;
else else
jump Test.11; jump Test.11;
procedure Test.0 (): procedure Test.0 ():
let Test.5 : Struct([]) = Struct {}; let Test.5 : {} = Struct {};
let Test.4 : Builtin(Int(I64)) = CallByName Test.1 Test.5; let Test.4 : I64 = CallByName Test.1 Test.5;
ret Test.4; ret Test.4;

30
compiler/test_mono/generated/has_none.txt
View file

@ -1,30 +1,30 @@
procedure Test.3 (Test.29): procedure Test.3 (Test.29):
joinpoint Test.13 Test.4: joinpoint Test.13 Test.4:
let Test.23 : Builtin(Bool) = 1i64; let Test.23 : Int1 = 1i64;
let Test.24 : Builtin(Bool) = GetTagId Test.4; let Test.24 : Int1 = GetTagId Test.4;
let Test.25 : Builtin(Bool) = lowlevel Eq Test.23 Test.24; let Test.25 : Int1 = lowlevel Eq Test.23 Test.24;
if Test.25 then if Test.25 then
let Test.14 : Builtin(Bool) = false; let Test.14 : Int1 = false;
ret Test.14; ret Test.14;
else else
let Test.19 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.4; let Test.19 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.4;
let Test.20 : Builtin(Int(U8)) = 1i64; let Test.20 : U8 = 1i64;
let Test.21 : Builtin(Int(U8)) = GetTagId Test.19; let Test.21 : U8 = GetTagId Test.19;
let Test.22 : Builtin(Bool) = lowlevel Eq Test.20 Test.21; let Test.22 : Int1 = lowlevel Eq Test.20 Test.21;
if Test.22 then if Test.22 then
let Test.15 : Builtin(Bool) = true; let Test.15 : Int1 = true;
ret Test.15; ret Test.15;
else else
let Test.7 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Union(NonRecursive([[Builtin(Int(I64))], []])), RecursivePointer] }) = UnionAtIndex (Id 0) (Index 1) Test.4; let Test.7 : TODO = UnionAtIndex (Id 0) (Index 1) Test.4;
jump Test.13 Test.7; jump Test.13 Test.7;
in in
jump Test.13 Test.29; jump Test.13 Test.29;
procedure Test.0 (): procedure Test.0 ():
let Test.28 : Builtin(Int(I64)) = 3i64; let Test.28 : I64 = 3i64;
let Test.26 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.28; let Test.26 : [C I64, C ] = Just Test.28;
let Test.27 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Union(NonRecursive([[Builtin(Int(I64))], []])), RecursivePointer] }) = Nil ; let Test.27 : TODO = Nil ;
let Test.12 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Union(NonRecursive([[Builtin(Int(I64))], []])), RecursivePointer] }) = Cons Test.26 Test.27; let Test.12 : TODO = Cons Test.26 Test.27;
let Test.11 : Builtin(Bool) = CallByName Test.3 Test.12; let Test.11 : Int1 = CallByName Test.3 Test.12;
dec Test.12; dec Test.12;
ret Test.11; ret Test.11;

16
compiler/test_mono/generated/if_guard_bind_variable_false.txt
View file

@ -1,22 +1,22 @@
procedure Bool.7 (#Attr.2, #Attr.3): procedure Bool.7 (#Attr.2, #Attr.3):
let Test.11 : Builtin(Bool) = lowlevel Eq #Attr.2 #Attr.3; let Test.11 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Test.11; ret Test.11;
procedure Test.1 (Test.3): procedure Test.1 (Test.3):
let Test.6 : Builtin(Int(I64)) = 10i64; let Test.6 : I64 = 10i64;
joinpoint Test.8 Test.13: joinpoint Test.8 Test.13:
if Test.13 then if Test.13 then
let Test.7 : Builtin(Int(I64)) = 0i64; let Test.7 : I64 = 0i64;
ret Test.7; ret Test.7;
else else
let Test.12 : Builtin(Int(I64)) = 42i64; let Test.12 : I64 = 42i64;
ret Test.12; ret Test.12;
in in
let Test.10 : Builtin(Int(I64)) = 5i64; let Test.10 : I64 = 5i64;
let Test.9 : Builtin(Bool) = CallByName Bool.7 Test.6 Test.10; let Test.9 : Int1 = CallByName Bool.7 Test.6 Test.10;
jump Test.8 Test.9; jump Test.8 Test.9;
procedure Test.0 (): procedure Test.0 ():
let Test.5 : Struct([]) = Struct {}; let Test.5 : {} = Struct {};
let Test.4 : Builtin(Int(I64)) = CallByName Test.1 Test.5; let Test.4 : I64 = CallByName Test.1 Test.5;
ret Test.4; ret Test.4;

10
compiler/test_mono/generated/if_multi_branch.txt
View file

@ -1,13 +1,13 @@
procedure Test.0 (): procedure Test.0 ():
let Test.6 : Builtin(Bool) = true; let Test.6 : Int1 = true;
if Test.6 then if Test.6 then
let Test.7 : Builtin(Int(I64)) = 1i64; let Test.7 : I64 = 1i64;
ret Test.7; ret Test.7;
else else
let Test.4 : Builtin(Bool) = false; let Test.4 : Int1 = false;
if Test.4 then if Test.4 then
let Test.5 : Builtin(Int(I64)) = 2i64; let Test.5 : I64 = 2i64;
ret Test.5; ret Test.5;
else else
let Test.3 : Builtin(Int(I64)) = 3i64; let Test.3 : I64 = 3i64;
ret Test.3; ret Test.3;

2
compiler/test_mono/generated/ir_assignment.txt
View file

@ -1,3 +1,3 @@
procedure Test.0 (): procedure Test.0 ():
let Test.1 : Builtin(Int(I64)) = 5i64; let Test.1 : I64 = 5i64;
ret Test.1; ret Test.1;

20
compiler/test_mono/generated/ir_int_add.txt
View file

@ -1,19 +1,19 @@
procedure List.7 (#Attr.2): procedure List.7 (#Attr.2):
let Test.7 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.7 : U64 = lowlevel ListLen #Attr.2;
ret Test.7; ret Test.7;
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.5 : Builtin(Int(U64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.5 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.5; ret Test.5;
procedure Test.0 (): procedure Test.0 ():
let Test.10 : Builtin(Int(U64)) = 5i64; let Test.10 : U64 = 5i64;
let Test.11 : Builtin(Int(U64)) = 4i64; let Test.11 : U64 = 4i64;
let Test.8 : Builtin(Int(U64)) = CallByName Num.22 Test.10 Test.11; let Test.8 : U64 = CallByName Num.22 Test.10 Test.11;
let Test.9 : Builtin(Int(U64)) = 3i64; let Test.9 : U64 = 3i64;
let Test.3 : Builtin(Int(U64)) = CallByName Num.22 Test.8 Test.9; let Test.3 : U64 = CallByName Num.22 Test.8 Test.9;
let Test.6 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64]; let Test.6 : List I64 = Array [1i64, 2i64];
let Test.4 : Builtin(Int(U64)) = CallByName List.7 Test.6; let Test.4 : U64 = CallByName List.7 Test.6;
dec Test.6; dec Test.6;
let Test.2 : Builtin(Int(U64)) = CallByName Num.22 Test.3 Test.4; let Test.2 : U64 = CallByName Num.22 Test.3 Test.4;
ret Test.2; ret Test.2;

2
compiler/test_mono/generated/ir_int_literal.txt
View file

@ -1,3 +1,3 @@
procedure Test.0 (): procedure Test.0 ():
let Test.1 : Builtin(Int(I64)) = 5i64; let Test.1 : I64 = 5i64;
ret Test.1; ret Test.1;

8
compiler/test_mono/generated/ir_plus.txt
View file

@ -1,9 +1,9 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.4 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.4 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.4; ret Test.4;
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Builtin(Int(I64)) = 1i64; let Test.2 : I64 = 1i64;
let Test.3 : Builtin(Int(I64)) = 2i64; let Test.3 : I64 = 2i64;
let Test.1 : Builtin(Int(I64)) = CallByName Num.22 Test.2 Test.3; let Test.1 : I64 = CallByName Num.22 Test.2 Test.3;
ret Test.1; ret Test.1;

6
compiler/test_mono/generated/ir_round.txt
View file

@ -1,8 +1,8 @@
procedure Num.45 (#Attr.2): procedure Num.45 (#Attr.2):
let Test.3 : Builtin(Int(I64)) = lowlevel NumRound #Attr.2; let Test.3 : I64 = lowlevel NumRound #Attr.2;
ret Test.3; ret Test.3;
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Builtin(Float(F64)) = 3.6f64; let Test.2 : Float64 = 3.6f64;
let Test.1 : Builtin(Int(I64)) = CallByName Num.45 Test.2; let Test.1 : I64 = CallByName Num.45 Test.2;
ret Test.1; ret Test.1;

8
compiler/test_mono/generated/ir_two_defs.txt
View file

@ -1,9 +1,9 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.6 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.6 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.6; ret Test.6;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Builtin(Int(I64)) = 3i64; let Test.4 : I64 = 3i64;
let Test.5 : Builtin(Int(I64)) = 4i64; let Test.5 : I64 = 4i64;
let Test.3 : Builtin(Int(I64)) = CallByName Num.22 Test.4 Test.5; let Test.3 : I64 = CallByName Num.22 Test.4 Test.5;
ret Test.3; ret Test.3;

28
compiler/test_mono/generated/ir_when_idiv.txt
View file

@ -1,25 +1,25 @@
procedure Num.40 (#Attr.2, #Attr.3): procedure Num.40 (#Attr.2, #Attr.3):
let Test.15 : Builtin(Int(I64)) = 0i64; let Test.15 : I64 = 0i64;
let Test.12 : Builtin(Bool) = lowlevel NotEq #Attr.3 Test.15; let Test.12 : Int1 = lowlevel NotEq #Attr.3 Test.15;
if Test.12 then if Test.12 then
let Test.14 : Builtin(Int(I64)) = lowlevel NumDivUnchecked #Attr.2 #Attr.3; let Test.14 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
let Test.13 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Ok Test.14; let Test.13 : [C {}, C I64] = Ok Test.14;
ret Test.13; ret Test.13;
else else
let Test.11 : Struct([]) = Struct {}; let Test.11 : {} = Struct {};
let Test.10 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Err Test.11; let Test.10 : [C {}, C I64] = Err Test.11;
ret Test.10; ret Test.10;
procedure Test.0 (): procedure Test.0 ():
let Test.8 : Builtin(Int(I64)) = 1000i64; let Test.8 : I64 = 1000i64;
let Test.9 : Builtin(Int(I64)) = 10i64; let Test.9 : I64 = 10i64;
let Test.2 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName Num.40 Test.8 Test.9; let Test.2 : [C {}, C I64] = CallByName Num.40 Test.8 Test.9;
let Test.5 : Builtin(Int(U8)) = 1i64; let Test.5 : U8 = 1i64;
let Test.6 : Builtin(Int(U8)) = GetTagId Test.2; let Test.6 : U8 = GetTagId Test.2;
let Test.7 : Builtin(Bool) = lowlevel Eq Test.5 Test.6; let Test.7 : Int1 = lowlevel Eq Test.5 Test.6;
if Test.7 then if Test.7 then
let Test.1 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.2; let Test.1 : I64 = UnionAtIndex (Id 1) (Index 0) Test.2;
ret Test.1; ret Test.1;
else else
let Test.4 : Builtin(Int(I64)) = -1i64; let Test.4 : I64 = -1i64;
ret Test.4; ret Test.4;

20
compiler/test_mono/generated/ir_when_just.txt
View file

@ -1,18 +1,18 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.6 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.6 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.6; ret Test.6;
procedure Test.0 (): procedure Test.0 ():
let Test.11 : Builtin(Int(I64)) = 41i64; let Test.11 : I64 = 41i64;
let Test.1 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.11; let Test.1 : [C I64, C ] = Just Test.11;
let Test.8 : Builtin(Int(U8)) = 0i64; let Test.8 : U8 = 0i64;
let Test.9 : Builtin(Int(U8)) = GetTagId Test.1; let Test.9 : U8 = GetTagId Test.1;
let Test.10 : Builtin(Bool) = lowlevel Eq Test.8 Test.9; let Test.10 : Int1 = lowlevel Eq Test.8 Test.9;
if Test.10 then if Test.10 then
let Test.3 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) Test.1; let Test.3 : I64 = UnionAtIndex (Id 0) (Index 0) Test.1;
let Test.5 : Builtin(Int(I64)) = 1i64; let Test.5 : I64 = 1i64;
let Test.4 : Builtin(Int(I64)) = CallByName Num.22 Test.3 Test.5; let Test.4 : I64 = CallByName Num.22 Test.3 Test.5;
ret Test.4; ret Test.4;
else else
let Test.7 : Builtin(Int(I64)) = 1i64; let Test.7 : I64 = 1i64;
ret Test.7; ret Test.7;

14
compiler/test_mono/generated/ir_when_maybe.txt
View file

@ -1,12 +1,12 @@
procedure Test.0 (): procedure Test.0 ():
let Test.9 : Builtin(Int(I64)) = 3i64; let Test.9 : I64 = 3i64;
let Test.3 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.9; let Test.3 : [C I64, C ] = Just Test.9;
let Test.6 : Builtin(Int(U8)) = 0i64; let Test.6 : U8 = 0i64;
let Test.7 : Builtin(Int(U8)) = GetTagId Test.3; let Test.7 : U8 = GetTagId Test.3;
let Test.8 : Builtin(Bool) = lowlevel Eq Test.6 Test.7; let Test.8 : Int1 = lowlevel Eq Test.6 Test.7;
if Test.8 then if Test.8 then
let Test.2 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) Test.3; let Test.2 : I64 = UnionAtIndex (Id 0) (Index 0) Test.3;
ret Test.2; ret Test.2;
else else
let Test.5 : Builtin(Int(I64)) = 0i64; let Test.5 : I64 = 0i64;
ret Test.5; ret Test.5;

8
compiler/test_mono/generated/ir_when_record.txt
View file

@ -1,6 +1,6 @@
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Builtin(Int(I64)) = 1i64; let Test.4 : I64 = 1i64;
let Test.5 : Builtin(Float(F64)) = 3.14f64; let Test.5 : Float64 = 3.14f64;
let Test.2 : Struct([Builtin(Int(I64)), Builtin(Float(F64))]) = Struct {Test.4, Test.5}; let Test.2 : {I64, Float64} = Struct {Test.4, Test.5};
let Test.1 : Builtin(Int(I64)) = StructAtIndex 0 Test.2; let Test.1 : I64 = StructAtIndex 0 Test.2;
ret Test.1; ret Test.1;

14
compiler/test_mono/generated/ir_when_these.txt
View file

@ -1,18 +1,18 @@
procedure Test.0 (): procedure Test.0 ():
let Test.10 : Builtin(Int(I64)) = 1i64; let Test.10 : I64 = 1i64;
let Test.11 : Builtin(Int(I64)) = 2i64; let Test.11 : I64 = 2i64;
let Test.5 : Union(NonRecursive([[Builtin(Int(I64))], [Builtin(Int(I64)), Builtin(Int(I64))], [Builtin(Int(I64))]])) = These Test.10 Test.11; let Test.5 : [C I64, C I64 I64, C I64] = These Test.10 Test.11;
let Test.9 : Builtin(Int(U8)) = GetTagId Test.5; let Test.9 : U8 = GetTagId Test.5;
switch Test.9: switch Test.9:
case 2: case 2:
let Test.2 : Builtin(Int(I64)) = UnionAtIndex (Id 2) (Index 0) Test.5; let Test.2 : I64 = UnionAtIndex (Id 2) (Index 0) Test.5;
ret Test.2; ret Test.2;
case 0: case 0:
let Test.3 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) Test.5; let Test.3 : I64 = UnionAtIndex (Id 0) (Index 0) Test.5;
ret Test.3; ret Test.3;
default: default:
let Test.4 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.5; let Test.4 : I64 = UnionAtIndex (Id 1) (Index 0) Test.5;
ret Test.4; ret Test.4;

18
compiler/test_mono/generated/is_nil.txt
View file

@ -1,18 +1,18 @@
procedure Test.2 (Test.3): procedure Test.2 (Test.3):
let Test.12 : Builtin(Bool) = 1i64; let Test.12 : Int1 = 1i64;
let Test.13 : Builtin(Bool) = GetTagId Test.3; let Test.13 : Int1 = GetTagId Test.3;
let Test.14 : Builtin(Bool) = lowlevel Eq Test.12 Test.13; let Test.14 : Int1 = lowlevel Eq Test.12 Test.13;
if Test.14 then if Test.14 then
let Test.10 : Builtin(Bool) = true; let Test.10 : Int1 = true;
ret Test.10; ret Test.10;
else else
let Test.11 : Builtin(Bool) = false; let Test.11 : Int1 = false;
ret Test.11; ret Test.11;
procedure Test.0 (): procedure Test.0 ():
let Test.15 : Builtin(Int(I64)) = 2i64; let Test.15 : I64 = 2i64;
let Test.16 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Builtin(Int(I64)), RecursivePointer] }) = Nil ; let Test.16 : TODO = Nil ;
let Test.9 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Builtin(Int(I64)), RecursivePointer] }) = Cons Test.15 Test.16; let Test.9 : TODO = Cons Test.15 Test.16;
let Test.8 : Builtin(Bool) = CallByName Test.2 Test.9; let Test.8 : Int1 = CallByName Test.2 Test.9;
dec Test.9; dec Test.9;
ret Test.8; ret Test.8;

19
compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt Normal file
View file

@ -0,0 +1,19 @@
procedure Test.1 ():
let Test.11 : I64 = 2i64;
let Test.12 : U8 = 1i64;
let Test.10 : {I64, U8} = Struct {Test.11, Test.12};
ret Test.10;
procedure Test.1 ():
let Test.7 : I64 = 1i64;
let Test.8 : U8 = 2i64;
let Test.6 : {I64, U8} = Struct {Test.7, Test.8};
ret Test.6;
procedure Test.0 ():
let Test.9 : {I64, U8} = CallByName Test.1;
let Test.3 : U8 = StructAtIndex 1 Test.9;
let Test.5 : {I64, U8} = CallByName Test.1;
let Test.4 : U8 = StructAtIndex 1 Test.5;
let Test.2 : List U8 = Array [Test.3, Test.4];
ret Test.2;

8
compiler/test_mono/generated/let_with_record_pattern.txt
View file

@ -1,6 +1,6 @@
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Builtin(Int(I64)) = 2i64; let Test.4 : I64 = 2i64;
let Test.5 : Builtin(Float(F64)) = 3.14f64; let Test.5 : Float64 = 3.14f64;
let Test.3 : Struct([Builtin(Int(I64)), Builtin(Float(F64))]) = Struct {Test.4, Test.5}; let Test.3 : {I64, Float64} = Struct {Test.4, Test.5};
let Test.1 : Builtin(Int(I64)) = StructAtIndex 0 Test.3; let Test.1 : I64 = StructAtIndex 0 Test.3;
ret Test.1; ret Test.1;

8
compiler/test_mono/generated/let_with_record_pattern_list.txt
View file

@ -1,8 +1,8 @@
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 3i64, 4i64]; let Test.4 : List I64 = Array [1i64, 3i64, 4i64];
let Test.5 : Builtin(Float(F64)) = 3.14f64; let Test.5 : Float64 = 3.14f64;
let Test.3 : Struct([Builtin(List(Builtin(Int(I64)))), Builtin(Float(F64))]) = Struct {Test.4, Test.5}; let Test.3 : {List I64, Float64} = Struct {Test.4, Test.5};
let Test.1 : Builtin(List(Builtin(Int(I64)))) = StructAtIndex 0 Test.3; let Test.1 : List I64 = StructAtIndex 0 Test.3;
inc Test.1; inc Test.1;
dec Test.3; dec Test.3;
ret Test.1; ret Test.1;

2
compiler/test_mono/generated/let_x_in_x.txt
View file

@ -1,3 +1,3 @@
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Builtin(Int(I64)) = 1337i64; let Test.2 : I64 = 1337i64;
ret Test.2; ret Test.2;

8
compiler/test_mono/generated/let_x_in_x_indirect.txt
View file

@ -1,6 +1,6 @@
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Builtin(Int(I64)) = 1337i64; let Test.2 : I64 = 1337i64;
let Test.3 : Builtin(Int(I64)) = 17i64; let Test.3 : I64 = 17i64;
let Test.7 : Struct([Builtin(Int(I64)), Builtin(Int(I64))]) = Struct {Test.2, Test.3}; let Test.7 : {I64, I64} = Struct {Test.2, Test.3};
let Test.6 : Builtin(Int(I64)) = StructAtIndex 0 Test.7; let Test.6 : I64 = StructAtIndex 0 Test.7;
ret Test.6; ret Test.6;

26
compiler/test_mono/generated/linked_list_length_twice.txt
View file

@ -1,25 +1,25 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.10 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.10 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.10; ret Test.10;
procedure Test.3 (Test.5): procedure Test.3 (Test.5):
let Test.16 : Builtin(Bool) = 1i64; let Test.16 : Int1 = 1i64;
let Test.17 : Builtin(Bool) = GetTagId Test.5; let Test.17 : Int1 = GetTagId Test.5;
let Test.18 : Builtin(Bool) = lowlevel Eq Test.16 Test.17; let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
if Test.18 then if Test.18 then
let Test.12 : Builtin(Int(I64)) = 0i64; let Test.12 : I64 = 0i64;
ret Test.12; ret Test.12;
else else
let Test.6 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Builtin(Int(I64)), RecursivePointer] }) = UnionAtIndex (Id 0) (Index 1) Test.5; let Test.6 : TODO = UnionAtIndex (Id 0) (Index 1) Test.5;
let Test.14 : Builtin(Int(I64)) = 1i64; let Test.14 : I64 = 1i64;
let Test.15 : Builtin(Int(I64)) = CallByName Test.3 Test.6; let Test.15 : I64 = CallByName Test.3 Test.6;
let Test.13 : Builtin(Int(I64)) = CallByName Num.22 Test.14 Test.15; let Test.13 : I64 = CallByName Num.22 Test.14 Test.15;
ret Test.13; ret Test.13;
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Builtin(Int(I64)), RecursivePointer] }) = Nil ; let Test.2 : TODO = Nil ;
let Test.8 : Builtin(Int(I64)) = CallByName Test.3 Test.2; let Test.8 : I64 = CallByName Test.3 Test.2;
let Test.9 : Builtin(Int(I64)) = CallByName Test.3 Test.2; let Test.9 : I64 = CallByName Test.3 Test.2;
dec Test.2; dec Test.2;
let Test.7 : Builtin(Int(I64)) = CallByName Num.22 Test.8 Test.9; let Test.7 : I64 = CallByName Num.22 Test.8 Test.9;
ret Test.7; ret Test.7;

8
compiler/test_mono/generated/list_append.txt
View file

@ -1,9 +1,9 @@
procedure List.5 (#Attr.2, #Attr.3): procedure List.5 (#Attr.2, #Attr.3):
let Test.4 : Builtin(List(Builtin(Int(I64)))) = lowlevel ListAppend #Attr.2 #Attr.3; let Test.4 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret Test.4; ret Test.4;
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Builtin(List(Builtin(Int(I64)))) = Array [1i64]; let Test.2 : List I64 = Array [1i64];
let Test.3 : Builtin(Int(I64)) = 2i64; let Test.3 : I64 = 2i64;
let Test.1 : Builtin(List(Builtin(Int(I64)))) = CallByName List.5 Test.2 Test.3; let Test.1 : List I64 = CallByName List.5 Test.2 Test.3;
ret Test.1; ret Test.1;

10
compiler/test_mono/generated/list_append_closure.txt
View file

@ -1,13 +1,13 @@
procedure List.5 (#Attr.2, #Attr.3): procedure List.5 (#Attr.2, #Attr.3):
let Test.7 : Builtin(List(Builtin(Int(I64)))) = lowlevel ListAppend #Attr.2 #Attr.3; let Test.7 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret Test.7; ret Test.7;
procedure Test.1 (Test.2): procedure Test.1 (Test.2):
let Test.6 : Builtin(Int(I64)) = 42i64; let Test.6 : I64 = 42i64;
let Test.5 : Builtin(List(Builtin(Int(I64)))) = CallByName List.5 Test.2 Test.6; let Test.5 : List I64 = CallByName List.5 Test.2 Test.6;
ret Test.5; ret Test.5;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64]; let Test.4 : List I64 = Array [1i64, 2i64];
let Test.3 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.4; let Test.3 : List I64 = CallByName Test.1 Test.4;
ret Test.3; ret Test.3;

30
compiler/test_mono/generated/list_cannot_update_inplace.txt
View file

@ -1,37 +1,37 @@
procedure List.4 (#Attr.2, #Attr.3, #Attr.4): procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
let Test.19 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.19 : U64 = lowlevel ListLen #Attr.2;
let Test.17 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.19; let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.19;
if Test.17 then if Test.17 then
let Test.18 : Builtin(List(Builtin(Int(I64)))) = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; let Test.18 : List I64 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4;
ret Test.18; ret Test.18;
else else
ret #Attr.2; ret #Attr.2;
procedure List.7 (#Attr.2): procedure List.7 (#Attr.2):
let Test.9 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.9 : U64 = lowlevel ListLen #Attr.2;
ret Test.9; ret Test.9;
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.7 : Builtin(Int(U64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.7 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.7; ret Test.7;
procedure Test.1 (): procedure Test.1 ():
let Test.10 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; let Test.10 : List I64 = Array [1i64, 2i64, 3i64];
ret Test.10; ret Test.10;
procedure Test.2 (Test.3): procedure Test.2 (Test.3):
let Test.14 : Builtin(Int(U64)) = 0i64; let Test.14 : U64 = 0i64;
let Test.15 : Builtin(Int(I64)) = 0i64; let Test.15 : I64 = 0i64;
let Test.13 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.3 Test.14 Test.15; let Test.13 : List I64 = CallByName List.4 Test.3 Test.14 Test.15;
ret Test.13; ret Test.13;
procedure Test.0 (): procedure Test.0 ():
let Test.12 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1; let Test.12 : List I64 = CallByName Test.1;
let Test.11 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.2 Test.12; let Test.11 : List I64 = CallByName Test.2 Test.12;
let Test.5 : Builtin(Int(U64)) = CallByName List.7 Test.11; let Test.5 : U64 = CallByName List.7 Test.11;
dec Test.11; dec Test.11;
let Test.8 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1; let Test.8 : List I64 = CallByName Test.1;
let Test.6 : Builtin(Int(U64)) = CallByName List.7 Test.8; let Test.6 : U64 = CallByName List.7 Test.8;
dec Test.8; dec Test.8;
let Test.4 : Builtin(Int(U64)) = CallByName Num.22 Test.5 Test.6; let Test.4 : U64 = CallByName Num.22 Test.5 Test.6;
ret Test.4; ret Test.4;

22
compiler/test_mono/generated/list_get.txt
View file

@ -1,23 +1,23 @@
procedure List.3 (#Attr.2, #Attr.3): procedure List.3 (#Attr.2, #Attr.3):
let Test.13 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.13 : U64 = lowlevel ListLen #Attr.2;
let Test.10 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.13; let Test.10 : Int1 = lowlevel NumLt #Attr.3 Test.13;
if Test.10 then if Test.10 then
let Test.12 : Builtin(Int(I64)) = lowlevel ListGetUnsafe #Attr.2 #Attr.3; let Test.12 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let Test.11 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Ok Test.12; let Test.11 : [C {}, C I64] = Ok Test.12;
ret Test.11; ret Test.11;
else else
let Test.9 : Struct([]) = Struct {}; let Test.9 : {} = Struct {};
let Test.8 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Err Test.9; let Test.8 : [C {}, C I64] = Err Test.9;
ret Test.8; ret Test.8;
procedure Test.1 (Test.2): procedure Test.1 (Test.2):
let Test.6 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; let Test.6 : List I64 = Array [1i64, 2i64, 3i64];
let Test.7 : Builtin(Int(U64)) = 0i64; let Test.7 : U64 = 0i64;
let Test.5 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName List.3 Test.6 Test.7; let Test.5 : [C {}, C I64] = CallByName List.3 Test.6 Test.7;
dec Test.6; dec Test.6;
ret Test.5; ret Test.5;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Struct([]) = Struct {}; let Test.4 : {} = Struct {};
let Test.3 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName Test.1 Test.4; let Test.3 : [C {}, C I64] = CallByName Test.1 Test.4;
ret Test.3; ret Test.3;

16
compiler/test_mono/generated/list_len.txt
View file

@ -1,21 +1,21 @@
procedure List.7 (#Attr.2): procedure List.7 (#Attr.2):
let Test.10 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.10 : U64 = lowlevel ListLen #Attr.2;
ret Test.10; ret Test.10;
procedure List.7 (#Attr.2): procedure List.7 (#Attr.2):
let Test.8 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.8 : U64 = lowlevel ListLen #Attr.2;
ret Test.8; ret Test.8;
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.6 : Builtin(Int(U64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.6 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.6; ret Test.6;
procedure Test.0 (): procedure Test.0 ():
let Test.9 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; let Test.9 : List I64 = Array [1i64, 2i64, 3i64];
let Test.4 : Builtin(Int(U64)) = CallByName List.7 Test.9; let Test.4 : U64 = CallByName List.7 Test.9;
dec Test.9; dec Test.9;
let Test.7 : Builtin(List(Builtin(Float(F64)))) = Array [1f64]; let Test.7 : List Float64 = Array [1f64];
let Test.5 : Builtin(Int(U64)) = CallByName List.7 Test.7; let Test.5 : U64 = CallByName List.7 Test.7;
dec Test.7; dec Test.7;
let Test.3 : Builtin(Int(U64)) = CallByName Num.22 Test.4 Test.5; let Test.3 : U64 = CallByName Num.22 Test.4 Test.5;
ret Test.3; ret Test.3;

16
compiler/test_mono/generated/list_pass_to_function.txt
View file

@ -1,19 +1,19 @@
procedure List.4 (#Attr.2, #Attr.3, #Attr.4): procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
let Test.11 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.11 : U64 = lowlevel ListLen #Attr.2;
let Test.9 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.11; let Test.9 : Int1 = lowlevel NumLt #Attr.3 Test.11;
if Test.9 then if Test.9 then
let Test.10 : Builtin(List(Builtin(Int(I64)))) = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; let Test.10 : List I64 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4;
ret Test.10; ret Test.10;
else else
ret #Attr.2; ret #Attr.2;
procedure Test.2 (Test.3): procedure Test.2 (Test.3):
let Test.6 : Builtin(Int(U64)) = 0i64; let Test.6 : U64 = 0i64;
let Test.7 : Builtin(Int(I64)) = 0i64; let Test.7 : I64 = 0i64;
let Test.5 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.3 Test.6 Test.7; let Test.5 : List I64 = CallByName List.4 Test.3 Test.6 Test.7;
ret Test.5; ret Test.5;
procedure Test.0 (): procedure Test.0 ():
let Test.1 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; let Test.1 : List I64 = Array [1i64, 2i64, 3i64];
let Test.4 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.2 Test.1; let Test.4 : List I64 = CallByName Test.2 Test.1;
ret Test.4; ret Test.4;

6
compiler/test_mono/generated/mk_pair_of.txt
View file

@ -1,9 +1,9 @@
procedure Test.1 (Test.2): procedure Test.1 (Test.2):
inc Test.2; inc Test.2;
let Test.6 : Struct([Builtin(List(Builtin(Int(I64)))), Builtin(List(Builtin(Int(I64))))]) = Struct {Test.2, Test.2}; let Test.6 : {List I64, List I64} = Struct {Test.2, Test.2};
ret Test.6; ret Test.6;
procedure Test.0 (): procedure Test.0 ():
let Test.5 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; let Test.5 : List I64 = Array [1i64, 2i64, 3i64];
let Test.4 : Struct([Builtin(List(Builtin(Int(I64)))), Builtin(List(Builtin(Int(I64))))]) = CallByName Test.1 Test.5; let Test.4 : {List I64, List I64} = CallByName Test.1 Test.5;
ret Test.4; ret Test.4;

16
compiler/test_mono/generated/monomorphized_applied_tag.txt
View file

@ -1,20 +1,20 @@
procedure Test.2 (Test.4): procedure Test.2 (Test.4):
let Test.11 : Builtin(Int(U8)) = 0i64; let Test.11 : U8 = 0i64;
let Test.12 : Builtin(Int(U8)) = GetTagId Test.4; let Test.12 : U8 = GetTagId Test.4;
let Test.13 : Builtin(Bool) = lowlevel Eq Test.11 Test.12; let Test.13 : Int1 = lowlevel Eq Test.11 Test.12;
if Test.13 then if Test.13 then
let Test.5 : Builtin(Str) = UnionAtIndex (Id 0) (Index 0) Test.4; let Test.5 : Str = UnionAtIndex (Id 0) (Index 0) Test.4;
inc Test.5; inc Test.5;
dec Test.4; dec Test.4;
ret Test.5; ret Test.5;
else else
let Test.6 : Builtin(Str) = UnionAtIndex (Id 1) (Index 0) Test.4; let Test.6 : Str = UnionAtIndex (Id 1) (Index 0) Test.4;
inc Test.6; inc Test.6;
dec Test.4; dec Test.4;
ret Test.6; ret Test.6;
procedure Test.0 (): procedure Test.0 ():
let Test.14 : Builtin(Str) = "A"; let Test.14 : Str = "A";
let Test.8 : Union(NonRecursive([[Builtin(Str)], [Builtin(Str)]])) = A Test.14; let Test.8 : [C Str, C Str] = A Test.14;
let Test.7 : Builtin(Str) = CallByName Test.2 Test.8; let Test.7 : Str = CallByName Test.2 Test.8;
ret Test.7; ret Test.7;

8
compiler/test_mono/generated/monomorphized_floats.txt
View file

@ -1,9 +1,9 @@
procedure Test.2 (Test.3, Test.4): procedure Test.2 (Test.3, Test.4):
let Test.8 : Builtin(Int(U64)) = 18i64; let Test.8 : U64 = 18i64;
ret Test.8; ret Test.8;
procedure Test.0 (): procedure Test.0 ():
let Test.6 : Builtin(Float(F32)) = 100f64; let Test.6 : Float32 = 100f64;
let Test.7 : Builtin(Float(F64)) = 100f64; let Test.7 : Float64 = 100f64;
let Test.5 : Builtin(Int(U64)) = CallByName Test.2 Test.6 Test.7; let Test.5 : U64 = CallByName Test.2 Test.6 Test.7;
ret Test.5; ret Test.5;

8
compiler/test_mono/generated/monomorphized_ints.txt
View file

@ -1,9 +1,9 @@
procedure Test.2 (Test.3, Test.4): procedure Test.2 (Test.3, Test.4):
let Test.8 : Builtin(Int(U64)) = 18i64; let Test.8 : U64 = 18i64;
ret Test.8; ret Test.8;
procedure Test.0 (): procedure Test.0 ():
let Test.6 : Builtin(Int(U8)) = 100i64; let Test.6 : U8 = 100i64;
let Test.7 : Builtin(Int(U32)) = 100i64; let Test.7 : U32 = 100i64;
let Test.5 : Builtin(Int(U64)) = CallByName Test.2 Test.6 Test.7; let Test.5 : U64 = CallByName Test.2 Test.6 Test.7;
ret Test.5; ret Test.5;

24
compiler/test_mono/generated/monomorphized_ints_aliased.txt
View file

@ -1,23 +1,23 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.12 : Builtin(Int(U64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.12 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.12; ret Test.12;
procedure Test.4 (Test.7, Test.8): procedure Test.4 (Test.7, Test.8):
let Test.17 : Builtin(Int(U64)) = 1i64; let Test.17 : U64 = 1i64;
ret Test.17; ret Test.17;
procedure Test.4 (Test.7, Test.8): procedure Test.4 (Test.7, Test.8):
let Test.18 : Builtin(Int(U64)) = 1i64; let Test.18 : U64 = 1i64;
ret Test.18; ret Test.18;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : LambdaSet(LambdaSet { set: [( Test.4, [])], representation: Struct([]) }) = Struct {}; let Test.4 : {} = Struct {};
let Test.4 : LambdaSet(LambdaSet { set: [( Test.4, [])], representation: Struct([]) }) = Struct {}; let Test.4 : {} = Struct {};
let Test.15 : Builtin(Int(U8)) = 100i64; let Test.15 : U8 = 100i64;
let Test.16 : Builtin(Int(U32)) = 100i64; let Test.16 : U32 = 100i64;
let Test.10 : Builtin(Int(U64)) = CallByName Test.4 Test.15 Test.16; let Test.10 : U64 = CallByName Test.4 Test.15 Test.16;
let Test.13 : Builtin(Int(U32)) = 100i64; let Test.13 : U32 = 100i64;
let Test.14 : Builtin(Int(U8)) = 100i64; let Test.14 : U8 = 100i64;
let Test.11 : Builtin(Int(U64)) = CallByName Test.4 Test.13 Test.14; let Test.11 : U64 = CallByName Test.4 Test.13 Test.14;
let Test.9 : Builtin(Int(U64)) = CallByName Num.22 Test.10 Test.11; let Test.9 : U64 = CallByName Num.22 Test.10 Test.11;
ret Test.9; ret Test.9;

8
compiler/test_mono/generated/monomorphized_list.txt
View file

@ -1,11 +1,11 @@
procedure Test.2 (Test.3, Test.4): procedure Test.2 (Test.3, Test.4):
let Test.8 : Builtin(Int(U64)) = 18i64; let Test.8 : U64 = 18i64;
ret Test.8; ret Test.8;
procedure Test.0 (): procedure Test.0 ():
let Test.6 : Builtin(List(Builtin(Int(U8)))) = Array [1i64, 2i64, 3i64]; let Test.6 : List U8 = Array [1i64, 2i64, 3i64];
let Test.7 : Builtin(List(Builtin(Int(U16)))) = Array [1i64, 2i64, 3i64]; let Test.7 : List U16 = Array [1i64, 2i64, 3i64];
let Test.5 : Builtin(Int(U64)) = CallByName Test.2 Test.6 Test.7; let Test.5 : U64 = CallByName Test.2 Test.6 Test.7;
dec Test.7; dec Test.7;
dec Test.6; dec Test.6;
ret Test.5; ret Test.5;

8
compiler/test_mono/generated/monomorphized_tag.txt
View file

@ -1,9 +1,9 @@
procedure Test.2 (Test.4, Test.5): procedure Test.2 (Test.4, Test.5):
let Test.9 : Builtin(Int(U8)) = 18i64; let Test.9 : U8 = 18i64;
ret Test.9; ret Test.9;
procedure Test.0 (): procedure Test.0 ():
let Test.7 : Builtin(Bool) = false; let Test.7 : Int1 = false;
let Test.8 : Builtin(Int(U8)) = 0u8; let Test.8 : U8 = 0u8;
let Test.6 : Builtin(Int(U8)) = CallByName Test.2 Test.7 Test.8; let Test.6 : U8 = CallByName Test.2 Test.7 Test.8;
ret Test.6; ret Test.6;

10
compiler/test_mono/generated/monomorphized_tag_with_aliased_args.txt
View file

@ -1,10 +1,10 @@
procedure Test.4 (Test.8): procedure Test.4 (Test.8):
let Test.11 : Builtin(Int(U64)) = 1i64; let Test.11 : U64 = 1i64;
ret Test.11; ret Test.11;
procedure Test.0 (): procedure Test.0 ():
let Test.13 : Builtin(Bool) = false; let Test.13 : Int1 = false;
let Test.12 : Builtin(Bool) = false; let Test.12 : Int1 = false;
let Test.10 : Struct([Builtin(Bool), Builtin(Bool)]) = Struct {Test.12, Test.13}; let Test.10 : {Int1, Int1} = Struct {Test.12, Test.13};
let Test.9 : Builtin(Int(U64)) = CallByName Test.4 Test.10; let Test.9 : U64 = CallByName Test.4 Test.10;
ret Test.9; ret Test.9;

16
compiler/test_mono/generated/nested_closure.txt
View file

@ -1,16 +1,16 @@
procedure Test.1 (Test.5): procedure Test.1 (Test.5):
let Test.2 : Builtin(Int(I64)) = 42i64; let Test.2 : I64 = 42i64;
let Test.3 : LambdaSet(LambdaSet { set: [( Test.3, [Builtin(Int(I64))])], representation: Struct([Builtin(Int(I64))]) }) = Struct {Test.2}; let Test.3 : {I64} = Struct {Test.2};
ret Test.3; ret Test.3;
procedure Test.3 (Test.10, #Attr.12): procedure Test.3 (Test.10, #Attr.12):
let Test.2 : Builtin(Int(I64)) = StructAtIndex 0 #Attr.12; let Test.2 : I64 = StructAtIndex 0 #Attr.12;
let Test.2 : Builtin(Int(I64)) = 42i64; let Test.2 : I64 = 42i64;
ret Test.2; ret Test.2;
procedure Test.0 (): procedure Test.0 ():
let Test.7 : Struct([]) = Struct {}; let Test.7 : {} = Struct {};
let Test.9 : Struct([]) = Struct {}; let Test.9 : {} = Struct {};
let Test.8 : LambdaSet(LambdaSet { set: [( Test.3, [Builtin(Int(I64))])], representation: Struct([Builtin(Int(I64))]) }) = CallByName Test.1 Test.9; let Test.8 : {I64} = CallByName Test.1 Test.9;
let Test.6 : Builtin(Int(I64)) = CallByName Test.3 Test.7 Test.8; let Test.6 : I64 = CallByName Test.3 Test.7 Test.8;
ret Test.6; ret Test.6;

32
compiler/test_mono/generated/nested_pattern_match.txt
View file

@ -1,28 +1,28 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8; ret Test.8;
procedure Test.0 (): procedure Test.0 ():
let Test.20 : Builtin(Int(I64)) = 41i64; let Test.20 : I64 = 41i64;
let Test.19 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.20; let Test.19 : [C I64, C ] = Just Test.20;
let Test.2 : Union(NonRecursive([[Union(NonRecursive([[Builtin(Int(I64))], []]))], []])) = Just Test.19; let Test.2 : [C [C I64, C ], C ] = Just Test.19;
joinpoint Test.16: joinpoint Test.16:
let Test.9 : Builtin(Int(I64)) = 1i64; let Test.9 : I64 = 1i64;
ret Test.9; ret Test.9;
in in
let Test.14 : Builtin(Int(U8)) = 0i64; let Test.14 : U8 = 0i64;
let Test.15 : Builtin(Int(U8)) = GetTagId Test.2; let Test.15 : U8 = GetTagId Test.2;
let Test.18 : Builtin(Bool) = lowlevel Eq Test.14 Test.15; let Test.18 : Int1 = lowlevel Eq Test.14 Test.15;
if Test.18 then if Test.18 then
let Test.11 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.2; let Test.11 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.12 : Builtin(Int(U8)) = 0i64; let Test.12 : U8 = 0i64;
let Test.13 : Builtin(Int(U8)) = GetTagId Test.11; let Test.13 : U8 = GetTagId Test.11;
let Test.17 : Builtin(Bool) = lowlevel Eq Test.12 Test.13; let Test.17 : Int1 = lowlevel Eq Test.12 Test.13;
if Test.17 then if Test.17 then
let Test.10 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.2; let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) Test.10; let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.10;
let Test.7 : Builtin(Int(I64)) = 1i64; let Test.7 : I64 = 1i64;
let Test.6 : Builtin(Int(I64)) = CallByName Num.22 Test.5 Test.7; let Test.6 : I64 = CallByName Num.22 Test.5 Test.7;
ret Test.6; ret Test.6;
else else
jump Test.16; jump Test.16;

2
compiler/test_mono/generated/one_element_tag.txt
View file

@ -1,3 +1,3 @@
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Builtin(Int(I64)) = 2i64; let Test.4 : I64 = 2i64;
ret Test.4; ret Test.4;

50
compiler/test_mono/generated/optional_when.txt
View file

@ -1,42 +1,42 @@
procedure Num.24 (#Attr.2, #Attr.3): procedure Num.24 (#Attr.2, #Attr.3):
let Test.18 : Builtin(Int(I64)) = lowlevel NumMul #Attr.2 #Attr.3; let Test.18 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.18; ret Test.18;
procedure Test.1 (Test.6): procedure Test.1 (Test.6):
let Test.22 : Builtin(Bool) = false; let Test.22 : Int1 = false;
let Test.23 : Builtin(Bool) = lowlevel Eq Test.22 Test.6; let Test.23 : Int1 = lowlevel Eq Test.22 Test.6;
if Test.23 then if Test.23 then
let Test.8 : Builtin(Int(I64)) = 3i64; let Test.8 : I64 = 3i64;
ret Test.8; ret Test.8;
else else
let Test.10 : Builtin(Int(I64)) = 5i64; let Test.10 : I64 = 5i64;
ret Test.10; ret Test.10;
procedure Test.1 (Test.6): procedure Test.1 (Test.6):
let Test.30 : Builtin(Bool) = StructAtIndex 1 Test.6; let Test.30 : Int1 = StructAtIndex 1 Test.6;
let Test.31 : Builtin(Bool) = false; let Test.31 : Int1 = false;
let Test.32 : Builtin(Bool) = lowlevel Eq Test.31 Test.30; let Test.32 : Int1 = lowlevel Eq Test.31 Test.30;
if Test.32 then if Test.32 then
let Test.8 : Builtin(Int(I64)) = StructAtIndex 0 Test.6; let Test.8 : I64 = StructAtIndex 0 Test.6;
ret Test.8; ret Test.8;
else else
let Test.10 : Builtin(Int(I64)) = StructAtIndex 0 Test.6; let Test.10 : I64 = StructAtIndex 0 Test.6;
ret Test.10; ret Test.10;
procedure Test.0 (): procedure Test.0 ():
let Test.40 : Builtin(Int(I64)) = 7i64; let Test.40 : I64 = 7i64;
let Test.41 : Builtin(Bool) = false; let Test.41 : Int1 = false;
let Test.39 : Struct([Builtin(Int(I64)), Builtin(Bool)]) = Struct {Test.40, Test.41}; let Test.39 : {I64, Int1} = Struct {Test.40, Test.41};
let Test.35 : Builtin(Int(I64)) = CallByName Test.1 Test.39; let Test.35 : I64 = CallByName Test.1 Test.39;
let Test.38 : Builtin(Bool) = false; let Test.38 : Int1 = false;
let Test.36 : Builtin(Int(I64)) = CallByName Test.1 Test.38; let Test.36 : I64 = CallByName Test.1 Test.38;
let Test.25 : Builtin(Int(I64)) = CallByName Num.24 Test.35 Test.36; let Test.25 : I64 = CallByName Num.24 Test.35 Test.36;
let Test.33 : Builtin(Int(I64)) = 11i64; let Test.33 : I64 = 11i64;
let Test.34 : Builtin(Bool) = true; let Test.34 : Int1 = true;
let Test.27 : Struct([Builtin(Int(I64)), Builtin(Bool)]) = Struct {Test.33, Test.34}; let Test.27 : {I64, Int1} = Struct {Test.33, Test.34};
let Test.26 : Builtin(Int(I64)) = CallByName Test.1 Test.27; let Test.26 : I64 = CallByName Test.1 Test.27;
let Test.16 : Builtin(Int(I64)) = CallByName Num.24 Test.25 Test.26; let Test.16 : I64 = CallByName Num.24 Test.25 Test.26;
let Test.24 : Builtin(Bool) = true; let Test.24 : Int1 = true;
let Test.17 : Builtin(Int(I64)) = CallByName Test.1 Test.24; let Test.17 : I64 = CallByName Test.1 Test.24;
let Test.15 : Builtin(Int(I64)) = CallByName Num.24 Test.16 Test.17; let Test.15 : I64 = CallByName Num.24 Test.16 Test.17;
ret Test.15; ret Test.15;

8
compiler/test_mono/generated/peano.txt
View file

@ -1,6 +1,6 @@
procedure Test.0 (): procedure Test.0 ():
let Test.10 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = Z ; let Test.10 : TODO = Z ;
let Test.9 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.10; let Test.9 : TODO = S Test.10;
let Test.8 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.9; let Test.8 : TODO = S Test.9;
let Test.2 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.8; let Test.2 : TODO = S Test.8;
ret Test.2; ret Test.2;

18
compiler/test_mono/generated/peano1.txt
View file

@ -1,15 +1,15 @@
procedure Test.0 (): procedure Test.0 ():
let Test.14 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = Z ; let Test.14 : TODO = Z ;
let Test.13 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.14; let Test.13 : TODO = S Test.14;
let Test.12 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.13; let Test.12 : TODO = S Test.13;
let Test.2 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.12; let Test.2 : TODO = S Test.12;
let Test.9 : Builtin(Bool) = 1i64; let Test.9 : Int1 = 1i64;
let Test.10 : Builtin(Bool) = GetTagId Test.2; let Test.10 : Int1 = GetTagId Test.2;
dec Test.2; dec Test.2;
let Test.11 : Builtin(Bool) = lowlevel Eq Test.9 Test.10; let Test.11 : Int1 = lowlevel Eq Test.9 Test.10;
if Test.11 then if Test.11 then
let Test.7 : Builtin(Int(I64)) = 0i64; let Test.7 : I64 = 0i64;
ret Test.7; ret Test.7;
else else
let Test.8 : Builtin(Int(I64)) = 1i64; let Test.8 : I64 = 1i64;
ret Test.8; ret Test.8;

28
compiler/test_mono/generated/peano2.txt
View file

@ -1,26 +1,26 @@
procedure Test.0 (): procedure Test.0 ():
let Test.20 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = Z ; let Test.20 : TODO = Z ;
let Test.19 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.20; let Test.19 : TODO = S Test.20;
let Test.18 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.19; let Test.18 : TODO = S Test.19;
let Test.2 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.18; let Test.2 : TODO = S Test.18;
let Test.15 : Builtin(Bool) = 0i64; let Test.15 : Int1 = 0i64;
let Test.16 : Builtin(Bool) = GetTagId Test.2; let Test.16 : Int1 = GetTagId Test.2;
let Test.17 : Builtin(Bool) = lowlevel Eq Test.15 Test.16; let Test.17 : Int1 = lowlevel Eq Test.15 Test.16;
if Test.17 then if Test.17 then
let Test.11 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = UnionAtIndex (Id 0) (Index 0) Test.2; let Test.11 : TODO = UnionAtIndex (Id 0) (Index 0) Test.2;
inc Test.11; inc Test.11;
dec Test.2; dec Test.2;
let Test.12 : Builtin(Bool) = 0i64; let Test.12 : Int1 = 0i64;
let Test.13 : Builtin(Bool) = GetTagId Test.11; let Test.13 : Int1 = GetTagId Test.11;
dec Test.11; dec Test.11;
let Test.14 : Builtin(Bool) = lowlevel Eq Test.12 Test.13; let Test.14 : Int1 = lowlevel Eq Test.12 Test.13;
if Test.14 then if Test.14 then
let Test.7 : Builtin(Int(I64)) = 1i64; let Test.7 : I64 = 1i64;
ret Test.7; ret Test.7;
else else
let Test.8 : Builtin(Int(I64)) = 0i64; let Test.8 : I64 = 0i64;
ret Test.8; ret Test.8;
else else
dec Test.2; dec Test.2;
let Test.9 : Builtin(Int(I64)) = 0i64; let Test.9 : I64 = 0i64;
ret Test.9; ret Test.9;

36
compiler/test_mono/generated/quicksort_help.txt
View file

@ -1,32 +1,32 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.19 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.19 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.19; ret Test.19;
procedure Num.23 (#Attr.2, #Attr.3): procedure Num.23 (#Attr.2, #Attr.3):
let Test.22 : Builtin(Int(I64)) = lowlevel NumSub #Attr.2 #Attr.3; let Test.22 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Test.22; ret Test.22;
procedure Num.25 (#Attr.2, #Attr.3): procedure Num.25 (#Attr.2, #Attr.3):
let Test.26 : Builtin(Bool) = lowlevel NumLt #Attr.2 #Attr.3; let Test.26 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Test.26; ret Test.26;
procedure Test.1 (Test.27, Test.28, Test.29): procedure Test.1 (Test.27, Test.28, Test.29):
joinpoint Test.12 Test.2 Test.3 Test.4: joinpoint Test.12 Test.2 Test.3 Test.4:
let Test.14 : Builtin(Bool) = CallByName Num.25 Test.3 Test.4; let Test.14 : Int1 = CallByName Num.25 Test.3 Test.4;
if Test.14 then if Test.14 then
dec Test.2; dec Test.2;
let Test.25 : Builtin(List(Union(NonRecursive([])))) = Array []; let Test.25 : List [] = Array [];
let Test.24 : Builtin(Int(I64)) = 0i64; let Test.24 : I64 = 0i64;
let Test.23 : Struct([Builtin(Int(I64)), Builtin(List(Union(NonRecursive([]))))]) = Struct {Test.24, Test.25}; let Test.23 : {I64, List []} = Struct {Test.24, Test.25};
let Test.5 : Builtin(Int(I64)) = StructAtIndex 0 Test.23; let Test.5 : I64 = StructAtIndex 0 Test.23;
let Test.6 : Builtin(List(Union(NonRecursive([])))) = StructAtIndex 1 Test.23; let Test.6 : List [] = StructAtIndex 1 Test.23;
inc Test.6; inc Test.6;
dec Test.23; dec Test.23;
let Test.21 : Builtin(Int(I64)) = 1i64; let Test.21 : I64 = 1i64;
let Test.20 : Builtin(Int(I64)) = CallByName Num.23 Test.5 Test.21; let Test.20 : I64 = CallByName Num.23 Test.5 Test.21;
let Test.16 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.6 Test.3 Test.20; let Test.16 : List I64 = CallByName Test.1 Test.6 Test.3 Test.20;
let Test.18 : Builtin(Int(I64)) = 1i64; let Test.18 : I64 = 1i64;
let Test.17 : Builtin(Int(I64)) = CallByName Num.22 Test.5 Test.18; let Test.17 : I64 = CallByName Num.22 Test.5 Test.18;
jump Test.12 Test.16 Test.17 Test.4; jump Test.12 Test.16 Test.17 Test.4;
else else
ret Test.2; ret Test.2;
@ -34,8 +34,8 @@ procedure Test.1 (Test.27, Test.28, Test.29):
jump Test.12 Test.27 Test.28 Test.29; jump Test.12 Test.27 Test.28 Test.29;
procedure Test.0 (): procedure Test.0 ():
let Test.9 : Builtin(List(Builtin(Int(I64)))) = Array []; let Test.9 : List I64 = Array [];
let Test.10 : Builtin(Int(I64)) = 0i64; let Test.10 : I64 = 0i64;
let Test.11 : Builtin(Int(I64)) = 0i64; let Test.11 : I64 = 0i64;
let Test.8 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.9 Test.10 Test.11; let Test.8 : List I64 = CallByName Test.1 Test.9 Test.10 Test.11;
ret Test.8; ret Test.8;

66
compiler/test_mono/generated/quicksort_swap.txt
View file

@ -1,52 +1,52 @@
procedure List.3 (#Attr.2, #Attr.3): procedure List.3 (#Attr.2, #Attr.3):
let Test.37 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.37 : U64 = lowlevel ListLen #Attr.2;
let Test.34 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.37; let Test.34 : Int1 = lowlevel NumLt #Attr.3 Test.37;
if Test.34 then if Test.34 then
let Test.36 : Builtin(Int(I64)) = lowlevel ListGetUnsafe #Attr.2 #Attr.3; let Test.36 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let Test.35 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Ok Test.36; let Test.35 : [C {}, C I64] = Ok Test.36;
ret Test.35; ret Test.35;
else else
let Test.33 : Struct([]) = Struct {}; let Test.33 : {} = Struct {};
let Test.32 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Err Test.33; let Test.32 : [C {}, C I64] = Err Test.33;
ret Test.32; ret Test.32;
procedure List.4 (#Attr.2, #Attr.3, #Attr.4): procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
let Test.15 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.15 : U64 = lowlevel ListLen #Attr.2;
let Test.13 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.15; let Test.13 : Int1 = lowlevel NumLt #Attr.3 Test.15;
if Test.13 then if Test.13 then
let Test.14 : Builtin(List(Builtin(Int(I64)))) = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; let Test.14 : List I64 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4;
ret Test.14; ret Test.14;
else else
ret #Attr.2; ret #Attr.2;
procedure Test.1 (Test.2): procedure Test.1 (Test.2):
let Test.38 : Builtin(Int(U64)) = 0i64; let Test.38 : U64 = 0i64;
let Test.30 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName List.3 Test.2 Test.38; let Test.30 : [C {}, C I64] = CallByName List.3 Test.2 Test.38;
let Test.31 : Builtin(Int(U64)) = 0i64; let Test.31 : U64 = 0i64;
let Test.29 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName List.3 Test.2 Test.31; let Test.29 : [C {}, C I64] = CallByName List.3 Test.2 Test.31;
let Test.8 : Struct([Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])), Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]]))]) = Struct {Test.29, Test.30}; let Test.8 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.29, Test.30};
joinpoint Test.26: joinpoint Test.26:
let Test.17 : Builtin(List(Builtin(Int(I64)))) = Array []; let Test.17 : List I64 = Array [];
ret Test.17; ret Test.17;
in in
let Test.23 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 1 Test.8; let Test.23 : [C {}, C I64] = StructAtIndex 1 Test.8;
let Test.24 : Builtin(Int(U8)) = 1i64; let Test.24 : U8 = 1i64;
let Test.25 : Builtin(Int(U8)) = GetTagId Test.23; let Test.25 : U8 = GetTagId Test.23;
let Test.28 : Builtin(Bool) = lowlevel Eq Test.24 Test.25; let Test.28 : Int1 = lowlevel Eq Test.24 Test.25;
if Test.28 then if Test.28 then
let Test.20 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 0 Test.8; let Test.20 : [C {}, C I64] = StructAtIndex 0 Test.8;
let Test.21 : Builtin(Int(U8)) = 1i64; let Test.21 : U8 = 1i64;
let Test.22 : Builtin(Int(U8)) = GetTagId Test.20; let Test.22 : U8 = GetTagId Test.20;
let Test.27 : Builtin(Bool) = lowlevel Eq Test.21 Test.22; let Test.27 : Int1 = lowlevel Eq Test.21 Test.22;
if Test.27 then if Test.27 then
let Test.19 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 0 Test.8; let Test.19 : [C {}, C I64] = StructAtIndex 0 Test.8;
let Test.4 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.19; let Test.4 : I64 = UnionAtIndex (Id 1) (Index 0) Test.19;
let Test.18 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 1 Test.8; let Test.18 : [C {}, C I64] = StructAtIndex 1 Test.8;
let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.18; let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) Test.18;
let Test.16 : Builtin(Int(U64)) = 0i64; let Test.16 : U64 = 0i64;
let Test.10 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.2 Test.16 Test.5; let Test.10 : List I64 = CallByName List.4 Test.2 Test.16 Test.5;
let Test.11 : Builtin(Int(U64)) = 0i64; let Test.11 : U64 = 0i64;
let Test.9 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.10 Test.11 Test.4; let Test.9 : List I64 = CallByName List.4 Test.10 Test.11 Test.4;
ret Test.9; ret Test.9;
else else
dec Test.2; dec Test.2;
@ -56,6 +56,6 @@ procedure Test.1 (Test.2):
jump Test.26; jump Test.26;
procedure Test.0 (): procedure Test.0 ():
let Test.7 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64]; let Test.7 : List I64 = Array [1i64, 2i64];
let Test.6 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.7; let Test.6 : List I64 = CallByName Test.1 Test.7;
ret Test.6; ret Test.6;

16
compiler/test_mono/generated/record_optional_field_function_no_use_default.txt
View file

@ -1,16 +1,16 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8; ret Test.8;
procedure Test.1 (Test.4): procedure Test.1 (Test.4):
let Test.2 : Builtin(Int(I64)) = StructAtIndex 0 Test.4; let Test.2 : I64 = StructAtIndex 0 Test.4;
let Test.3 : Builtin(Int(I64)) = StructAtIndex 1 Test.4; let Test.3 : I64 = StructAtIndex 1 Test.4;
let Test.7 : Builtin(Int(I64)) = CallByName Num.22 Test.2 Test.3; let Test.7 : I64 = CallByName Num.22 Test.2 Test.3;
ret Test.7; ret Test.7;
procedure Test.0 (): procedure Test.0 ():
let Test.9 : Builtin(Int(I64)) = 4i64; let Test.9 : I64 = 4i64;
let Test.10 : Builtin(Int(I64)) = 9i64; let Test.10 : I64 = 9i64;
let Test.6 : Struct([Builtin(Int(I64)), Builtin(Int(I64))]) = Struct {Test.9, Test.10}; let Test.6 : {I64, I64} = Struct {Test.9, Test.10};
let Test.5 : Builtin(Int(I64)) = CallByName Test.1 Test.6; let Test.5 : I64 = CallByName Test.1 Test.6;
ret Test.5; ret Test.5;

10
compiler/test_mono/generated/record_optional_field_function_use_default.txt
View file

@ -1,13 +1,13 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.9 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.9 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.9; ret Test.9;
procedure Test.1 (Test.4): procedure Test.1 (Test.4):
let Test.8 : Builtin(Int(I64)) = 10i64; let Test.8 : I64 = 10i64;
let Test.7 : Builtin(Int(I64)) = CallByName Num.22 Test.8 Test.4; let Test.7 : I64 = CallByName Num.22 Test.8 Test.4;
ret Test.7; ret Test.7;
procedure Test.0 (): procedure Test.0 ():
let Test.10 : Builtin(Int(I64)) = 9i64; let Test.10 : I64 = 9i64;
let Test.5 : Builtin(Int(I64)) = CallByName Test.1 Test.10; let Test.5 : I64 = CallByName Test.1 Test.10;
ret Test.5; ret Test.5;

16
compiler/test_mono/generated/record_optional_field_let_no_use_default.txt
View file

@ -1,16 +1,16 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8; ret Test.8;
procedure Test.1 (Test.2): procedure Test.1 (Test.2):
let Test.3 : Builtin(Int(I64)) = StructAtIndex 0 Test.2; let Test.3 : I64 = StructAtIndex 0 Test.2;
let Test.4 : Builtin(Int(I64)) = StructAtIndex 1 Test.2; let Test.4 : I64 = StructAtIndex 1 Test.2;
let Test.7 : Builtin(Int(I64)) = CallByName Num.22 Test.3 Test.4; let Test.7 : I64 = CallByName Num.22 Test.3 Test.4;
ret Test.7; ret Test.7;
procedure Test.0 (): procedure Test.0 ():
let Test.9 : Builtin(Int(I64)) = 4i64; let Test.9 : I64 = 4i64;
let Test.10 : Builtin(Int(I64)) = 9i64; let Test.10 : I64 = 9i64;
let Test.6 : Struct([Builtin(Int(I64)), Builtin(Int(I64))]) = Struct {Test.9, Test.10}; let Test.6 : {I64, I64} = Struct {Test.9, Test.10};
let Test.5 : Builtin(Int(I64)) = CallByName Test.1 Test.6; let Test.5 : I64 = CallByName Test.1 Test.6;
ret Test.5; ret Test.5;

10
compiler/test_mono/generated/record_optional_field_let_use_default.txt
View file

@ -1,13 +1,13 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8; ret Test.8;
procedure Test.1 (Test.2): procedure Test.1 (Test.2):
let Test.3 : Builtin(Int(I64)) = 10i64; let Test.3 : I64 = 10i64;
let Test.7 : Builtin(Int(I64)) = CallByName Num.22 Test.3 Test.2; let Test.7 : I64 = CallByName Num.22 Test.3 Test.2;
ret Test.7; ret Test.7;
procedure Test.0 (): procedure Test.0 ():
let Test.9 : Builtin(Int(I64)) = 9i64; let Test.9 : I64 = 9i64;
let Test.5 : Builtin(Int(I64)) = CallByName Test.1 Test.9; let Test.5 : I64 = CallByName Test.1 Test.9;
ret Test.5; ret Test.5;

62
compiler/test_mono/generated/rigids.txt
View file

@ -1,48 +1,48 @@
procedure List.3 (#Attr.2, #Attr.3): procedure List.3 (#Attr.2, #Attr.3):
let Test.39 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.39 : U64 = lowlevel ListLen #Attr.2;
let Test.36 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.39; let Test.36 : Int1 = lowlevel NumLt #Attr.3 Test.39;
if Test.36 then if Test.36 then
let Test.38 : Builtin(Int(I64)) = lowlevel ListGetUnsafe #Attr.2 #Attr.3; let Test.38 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let Test.37 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Ok Test.38; let Test.37 : [C {}, C I64] = Ok Test.38;
ret Test.37; ret Test.37;
else else
let Test.35 : Struct([]) = Struct {}; let Test.35 : {} = Struct {};
let Test.34 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Err Test.35; let Test.34 : [C {}, C I64] = Err Test.35;
ret Test.34; ret Test.34;
procedure List.4 (#Attr.2, #Attr.3, #Attr.4): procedure List.4 (#Attr.2, #Attr.3, #Attr.4):
let Test.19 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; let Test.19 : U64 = lowlevel ListLen #Attr.2;
let Test.17 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.19; let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.19;
if Test.17 then if Test.17 then
let Test.18 : Builtin(List(Builtin(Int(I64)))) = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4; let Test.18 : List I64 = lowlevel ListSet #Attr.2 #Attr.3 #Attr.4;
ret Test.18; ret Test.18;
else else
ret #Attr.2; ret #Attr.2;
procedure Test.1 (Test.2, Test.3, Test.4): procedure Test.1 (Test.2, Test.3, Test.4):
let Test.33 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName List.3 Test.4 Test.3; let Test.33 : [C {}, C I64] = CallByName List.3 Test.4 Test.3;
let Test.32 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName List.3 Test.4 Test.2; let Test.32 : [C {}, C I64] = CallByName List.3 Test.4 Test.2;
let Test.13 : Struct([Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])), Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]]))]) = Struct {Test.32, Test.33}; let Test.13 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.32, Test.33};
joinpoint Test.29: joinpoint Test.29:
let Test.20 : Builtin(List(Builtin(Int(I64)))) = Array []; let Test.20 : List I64 = Array [];
ret Test.20; ret Test.20;
in in
let Test.26 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 1 Test.13; let Test.26 : [C {}, C I64] = StructAtIndex 1 Test.13;
let Test.27 : Builtin(Int(U8)) = 1i64; let Test.27 : U8 = 1i64;
let Test.28 : Builtin(Int(U8)) = GetTagId Test.26; let Test.28 : U8 = GetTagId Test.26;
let Test.31 : Builtin(Bool) = lowlevel Eq Test.27 Test.28; let Test.31 : Int1 = lowlevel Eq Test.27 Test.28;
if Test.31 then if Test.31 then
let Test.23 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 0 Test.13; let Test.23 : [C {}, C I64] = StructAtIndex 0 Test.13;
let Test.24 : Builtin(Int(U8)) = 1i64; let Test.24 : U8 = 1i64;
let Test.25 : Builtin(Int(U8)) = GetTagId Test.23; let Test.25 : U8 = GetTagId Test.23;
let Test.30 : Builtin(Bool) = lowlevel Eq Test.24 Test.25; let Test.30 : Int1 = lowlevel Eq Test.24 Test.25;
if Test.30 then if Test.30 then
let Test.22 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 0 Test.13; let Test.22 : [C {}, C I64] = StructAtIndex 0 Test.13;
let Test.6 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.22; let Test.6 : I64 = UnionAtIndex (Id 1) (Index 0) Test.22;
let Test.21 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 1 Test.13; let Test.21 : [C {}, C I64] = StructAtIndex 1 Test.13;
let Test.7 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.21; let Test.7 : I64 = UnionAtIndex (Id 1) (Index 0) Test.21;
let Test.15 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.4 Test.2 Test.7; let Test.15 : List I64 = CallByName List.4 Test.4 Test.2 Test.7;
let Test.14 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.15 Test.3 Test.6; let Test.14 : List I64 = CallByName List.4 Test.15 Test.3 Test.6;
ret Test.14; ret Test.14;
else else
dec Test.4; dec Test.4;
@ -52,8 +52,8 @@ procedure Test.1 (Test.2, Test.3, Test.4):
jump Test.29; jump Test.29;
procedure Test.0 (): procedure Test.0 ():
let Test.10 : Builtin(Int(U64)) = 0i64; let Test.10 : U64 = 0i64;
let Test.11 : Builtin(Int(U64)) = 0i64; let Test.11 : U64 = 0i64;
let Test.12 : Builtin(List(Builtin(Int(I64)))) = Array [1i64]; let Test.12 : List I64 = Array [1i64];
let Test.9 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.10 Test.11 Test.12; let Test.9 : List I64 = CallByName Test.1 Test.10 Test.11 Test.12;
ret Test.9; ret Test.9;

6
compiler/test_mono/generated/simple_if.txt
View file

@ -1,8 +1,8 @@
procedure Test.0 (): procedure Test.0 ():
let Test.3 : Builtin(Bool) = true; let Test.3 : Int1 = true;
if Test.3 then if Test.3 then
let Test.4 : Builtin(Int(I64)) = 1i64; let Test.4 : I64 = 1i64;
ret Test.4; ret Test.4;
else else
let Test.2 : Builtin(Int(I64)) = 2i64; let Test.2 : I64 = 2i64;
ret Test.2; ret Test.2;

30
compiler/test_mono/generated/somehow_drops_definitions.txt
View file

@ -1,27 +1,27 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.27 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.27 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.27; ret Test.27;
procedure Num.24 (#Attr.2, #Attr.3): procedure Num.24 (#Attr.2, #Attr.3):
let Test.22 : Builtin(Int(I64)) = lowlevel NumMul #Attr.2 #Attr.3; let Test.22 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.22; ret Test.22;
procedure Test.1 (): procedure Test.1 ():
let Test.28 : Builtin(Int(I64)) = 1i64; let Test.28 : I64 = 1i64;
ret Test.28; ret Test.28;
procedure Test.2 (): procedure Test.2 ():
let Test.23 : Builtin(Int(I64)) = 2i64; let Test.23 : I64 = 2i64;
ret Test.23; ret Test.23;
procedure Test.3 (Test.6): procedure Test.3 (Test.6):
let Test.26 : Builtin(Int(I64)) = CallByName Test.1; let Test.26 : I64 = CallByName Test.1;
let Test.25 : Builtin(Int(I64)) = CallByName Num.22 Test.6 Test.26; let Test.25 : I64 = CallByName Num.22 Test.6 Test.26;
ret Test.25; ret Test.25;
procedure Test.4 (Test.7): procedure Test.4 (Test.7):
let Test.21 : Builtin(Int(I64)) = CallByName Test.2; let Test.21 : I64 = CallByName Test.2;
let Test.20 : Builtin(Int(I64)) = CallByName Num.24 Test.7 Test.21; let Test.20 : I64 = CallByName Num.24 Test.7 Test.21;
ret Test.20; ret Test.20;
procedure Test.5 (Test.8, Test.9): procedure Test.5 (Test.8, Test.9):
@ -30,24 +30,24 @@ procedure Test.5 (Test.8, Test.9):
in in
switch Test.8: switch Test.8:
case 0: case 0:
let Test.16 : Builtin(Int(I64)) = CallByName Test.3 Test.9; let Test.16 : I64 = CallByName Test.3 Test.9;
jump Test.15 Test.16; jump Test.15 Test.16;
default: default:
let Test.17 : Builtin(Int(I64)) = CallByName Test.4 Test.9; let Test.17 : I64 = CallByName Test.4 Test.9;
jump Test.15 Test.17; jump Test.15 Test.17;
procedure Test.0 (): procedure Test.0 ():
joinpoint Test.19 Test.12: joinpoint Test.19 Test.12:
let Test.13 : Builtin(Int(I64)) = 42i64; let Test.13 : I64 = 42i64;
let Test.11 : Builtin(Int(I64)) = CallByName Test.5 Test.12 Test.13; let Test.11 : I64 = CallByName Test.5 Test.12 Test.13;
ret Test.11; ret Test.11;
in in
let Test.24 : Builtin(Bool) = true; let Test.24 : Int1 = true;
if Test.24 then if Test.24 then
let Test.3 : LambdaSet(LambdaSet { set: [( Test.3, []), ( Test.4, [])], representation: Builtin(Bool) }) = false; let Test.3 : Int1 = false;
jump Test.19 Test.3; jump Test.19 Test.3;
else else
let Test.4 : LambdaSet(LambdaSet { set: [( Test.3, []), ( Test.4, [])], representation: Builtin(Bool) }) = true; let Test.4 : Int1 = true;
jump Test.19 Test.4; jump Test.19 Test.4;

36
compiler/test_mono/generated/specialize_closures.txt
View file

@ -1,53 +1,53 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.28 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.28 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.28; ret Test.28;
procedure Num.24 (#Attr.2, #Attr.3): procedure Num.24 (#Attr.2, #Attr.3):
let Test.25 : Builtin(Int(I64)) = lowlevel NumMul #Attr.2 #Attr.3; let Test.25 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.25; ret Test.25;
procedure Test.1 (Test.2, Test.3): procedure Test.1 (Test.2, Test.3):
let Test.17 : Builtin(Int(U8)) = GetTagId Test.2; let Test.17 : U8 = GetTagId Test.2;
joinpoint Test.18 Test.16: joinpoint Test.18 Test.16:
ret Test.16; ret Test.16;
in in
switch Test.17: switch Test.17:
case 0: case 0:
let Test.19 : Builtin(Int(I64)) = CallByName Test.7 Test.3 Test.2; let Test.19 : I64 = CallByName Test.7 Test.3 Test.2;
jump Test.18 Test.19; jump Test.18 Test.19;
default: default:
let Test.20 : Builtin(Int(I64)) = CallByName Test.8 Test.3 Test.2; let Test.20 : I64 = CallByName Test.8 Test.3 Test.2;
jump Test.18 Test.20; jump Test.18 Test.20;
procedure Test.7 (Test.10, #Attr.12): procedure Test.7 (Test.10, #Attr.12):
let Test.4 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) #Attr.12; let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.27 : Builtin(Int(I64)) = CallByName Num.22 Test.10 Test.4; let Test.27 : I64 = CallByName Num.22 Test.10 Test.4;
ret Test.27; ret Test.27;
procedure Test.8 (Test.11, #Attr.12): procedure Test.8 (Test.11, #Attr.12):
let Test.6 : Builtin(Bool) = UnionAtIndex (Id 1) (Index 1) #Attr.12; let Test.6 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) #Attr.12; let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
if Test.6 then if Test.6 then
let Test.24 : Builtin(Int(I64)) = CallByName Num.24 Test.11 Test.5; let Test.24 : I64 = CallByName Num.24 Test.11 Test.5;
ret Test.24; ret Test.24;
else else
ret Test.11; ret Test.11;
procedure Test.0 (): procedure Test.0 ():
let Test.6 : Builtin(Bool) = true; let Test.6 : Int1 = true;
let Test.4 : Builtin(Int(I64)) = 1i64; let Test.4 : I64 = 1i64;
let Test.5 : Builtin(Int(I64)) = 2i64; let Test.5 : I64 = 2i64;
joinpoint Test.22 Test.14: joinpoint Test.22 Test.14:
let Test.15 : Builtin(Int(I64)) = 42i64; let Test.15 : I64 = 42i64;
let Test.13 : Builtin(Int(I64)) = CallByName Test.1 Test.14 Test.15; let Test.13 : I64 = CallByName Test.1 Test.14 Test.15;
ret Test.13; ret Test.13;
in in
let Test.26 : Builtin(Bool) = true; let Test.26 : Int1 = true;
if Test.26 then if Test.26 then
let Test.7 : LambdaSet(LambdaSet { set: [( Test.7, [Builtin(Int(I64))]), ( Test.8, [Builtin(Int(I64)), Builtin(Bool)])], representation: Union(NonRecursive([[Builtin(Int(I64))], [Builtin(Int(I64)), Builtin(Bool)]])) }) = ClosureTag(Test.7) Test.4; let Test.7 : [C I64, C I64 Int1] = ClosureTag(Test.7) Test.4;
jump Test.22 Test.7; jump Test.22 Test.7;
else else
let Test.8 : LambdaSet(LambdaSet { set: [( Test.7, [Builtin(Int(I64))]), ( Test.8, [Builtin(Int(I64)), Builtin(Bool)])], representation: Union(NonRecursive([[Builtin(Int(I64))], [Builtin(Int(I64)), Builtin(Bool)]])) }) = ClosureTag(Test.8) Test.5 Test.6; let Test.8 : [C I64, C I64 Int1] = ClosureTag(Test.8) Test.5 Test.6;
jump Test.22 Test.8; jump Test.22 Test.8;

30
compiler/test_mono/generated/specialize_lowlevel.txt
View file

@ -1,44 +1,44 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.24 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.24 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.24; ret Test.24;
procedure Num.24 (#Attr.2, #Attr.3): procedure Num.24 (#Attr.2, #Attr.3):
let Test.21 : Builtin(Int(I64)) = lowlevel NumMul #Attr.2 #Attr.3; let Test.21 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Test.21; ret Test.21;
procedure Test.6 (Test.8, #Attr.12): procedure Test.6 (Test.8, #Attr.12):
let Test.4 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) #Attr.12; let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.23 : Builtin(Int(I64)) = CallByName Num.22 Test.8 Test.4; let Test.23 : I64 = CallByName Num.22 Test.8 Test.4;
ret Test.23; ret Test.23;
procedure Test.7 (Test.9, #Attr.12): procedure Test.7 (Test.9, #Attr.12):
let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) #Attr.12; let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.20 : Builtin(Int(I64)) = CallByName Num.24 Test.9 Test.5; let Test.20 : I64 = CallByName Num.24 Test.9 Test.5;
ret Test.20; ret Test.20;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Builtin(Int(I64)) = 1i64; let Test.4 : I64 = 1i64;
let Test.5 : Builtin(Int(I64)) = 2i64; let Test.5 : I64 = 2i64;
let Test.12 : Builtin(Int(I64)) = 42i64; let Test.12 : I64 = 42i64;
joinpoint Test.19 Test.13: joinpoint Test.19 Test.13:
let Test.14 : Builtin(Int(U8)) = GetTagId Test.13; let Test.14 : U8 = GetTagId Test.13;
joinpoint Test.15 Test.11: joinpoint Test.15 Test.11:
ret Test.11; ret Test.11;
in in
switch Test.14: switch Test.14:
case 0: case 0:
let Test.16 : Builtin(Int(I64)) = CallByName Test.6 Test.12 Test.13; let Test.16 : I64 = CallByName Test.6 Test.12 Test.13;
jump Test.15 Test.16; jump Test.15 Test.16;
default: default:
let Test.17 : Builtin(Int(I64)) = CallByName Test.7 Test.12 Test.13; let Test.17 : I64 = CallByName Test.7 Test.12 Test.13;
jump Test.15 Test.17; jump Test.15 Test.17;
in in
let Test.22 : Builtin(Bool) = true; let Test.22 : Int1 = true;
if Test.22 then if Test.22 then
let Test.6 : LambdaSet(LambdaSet { set: [( Test.6, [Builtin(Int(I64))]), ( Test.7, [Builtin(Int(I64))])], representation: Union(NonRecursive([[Builtin(Int(I64))], [Builtin(Int(I64))]])) }) = ClosureTag(Test.6) Test.4; let Test.6 : [C I64, C I64] = ClosureTag(Test.6) Test.4;
jump Test.19 Test.6; jump Test.19 Test.6;
else else
let Test.7 : LambdaSet(LambdaSet { set: [( Test.6, [Builtin(Int(I64))]), ( Test.7, [Builtin(Int(I64))])], representation: Union(NonRecursive([[Builtin(Int(I64))], [Builtin(Int(I64))]])) }) = ClosureTag(Test.7) Test.5; let Test.7 : [C I64, C I64] = ClosureTag(Test.7) Test.5;
jump Test.19 Test.7; jump Test.19 Test.7;

12
compiler/test_mono/generated/when_joinpoint.txt
View file

@ -1,23 +1,23 @@
procedure Test.1 (Test.5): procedure Test.1 (Test.5):
let Test.2 : Builtin(Int(U8)) = 0u8; let Test.2 : U8 = 0u8;
joinpoint Test.9 Test.3: joinpoint Test.9 Test.3:
ret Test.3; ret Test.3;
in in
switch Test.2: switch Test.2:
case 1: case 1:
let Test.10 : Builtin(Int(I64)) = 1i64; let Test.10 : I64 = 1i64;
jump Test.9 Test.10; jump Test.9 Test.10;
case 2: case 2:
let Test.11 : Builtin(Int(I64)) = 2i64; let Test.11 : I64 = 2i64;
jump Test.9 Test.11; jump Test.9 Test.11;
default: default:
let Test.12 : Builtin(Int(I64)) = 3i64; let Test.12 : I64 = 3i64;
jump Test.9 Test.12; jump Test.9 Test.12;
procedure Test.0 (): procedure Test.0 ():
let Test.7 : Struct([]) = Struct {}; let Test.7 : {} = Struct {};
let Test.6 : Builtin(Int(I64)) = CallByName Test.1 Test.7; let Test.6 : I64 = CallByName Test.1 Test.7;
ret Test.6; ret Test.6;

32
compiler/test_mono/generated/when_nested_maybe.txt
View file

@ -1,28 +1,28 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.8 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.8 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.8; ret Test.8;
procedure Test.0 (): procedure Test.0 ():
let Test.20 : Builtin(Int(I64)) = 41i64; let Test.20 : I64 = 41i64;
let Test.19 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.20; let Test.19 : [C I64, C ] = Just Test.20;
let Test.2 : Union(NonRecursive([[Union(NonRecursive([[Builtin(Int(I64))], []]))], []])) = Just Test.19; let Test.2 : [C [C I64, C ], C ] = Just Test.19;
joinpoint Test.16: joinpoint Test.16:
let Test.9 : Builtin(Int(I64)) = 1i64; let Test.9 : I64 = 1i64;
ret Test.9; ret Test.9;
in in
let Test.14 : Builtin(Int(U8)) = 0i64; let Test.14 : U8 = 0i64;
let Test.15 : Builtin(Int(U8)) = GetTagId Test.2; let Test.15 : U8 = GetTagId Test.2;
let Test.18 : Builtin(Bool) = lowlevel Eq Test.14 Test.15; let Test.18 : Int1 = lowlevel Eq Test.14 Test.15;
if Test.18 then if Test.18 then
let Test.11 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.2; let Test.11 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.12 : Builtin(Int(U8)) = 0i64; let Test.12 : U8 = 0i64;
let Test.13 : Builtin(Int(U8)) = GetTagId Test.11; let Test.13 : U8 = GetTagId Test.11;
let Test.17 : Builtin(Bool) = lowlevel Eq Test.12 Test.13; let Test.17 : Int1 = lowlevel Eq Test.12 Test.13;
if Test.17 then if Test.17 then
let Test.10 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.2; let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) Test.10; let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.10;
let Test.7 : Builtin(Int(I64)) = 1i64; let Test.7 : I64 = 1i64;
let Test.6 : Builtin(Int(I64)) = CallByName Num.22 Test.5 Test.7; let Test.6 : I64 = CallByName Num.22 Test.5 Test.7;
ret Test.6; ret Test.6;
else else
jump Test.16; jump Test.16;

8
compiler/test_mono/generated/when_on_record.txt
View file

@ -1,9 +1,9 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.5 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.5 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.5; ret Test.5;
procedure Test.0 (): procedure Test.0 ():
let Test.6 : Builtin(Int(I64)) = 2i64; let Test.6 : I64 = 2i64;
let Test.4 : Builtin(Int(I64)) = 3i64; let Test.4 : I64 = 3i64;
let Test.3 : Builtin(Int(I64)) = CallByName Num.22 Test.6 Test.4; let Test.3 : I64 = CallByName Num.22 Test.6 Test.4;
ret Test.3; ret Test.3;

26
compiler/test_mono/generated/when_on_result.txt
View file

@ -1,27 +1,27 @@
procedure Test.1 (Test.5): procedure Test.1 (Test.5):
let Test.19 : Builtin(Int(I64)) = 2i64; let Test.19 : I64 = 2i64;
let Test.2 : Union(NonRecursive([[Builtin(Int(I64))], [Builtin(Int(I64))]])) = Ok Test.19; let Test.2 : [C I64, C I64] = Ok Test.19;
joinpoint Test.9 Test.3: joinpoint Test.9 Test.3:
ret Test.3; ret Test.3;
in in
let Test.16 : Builtin(Int(U8)) = 1i64; let Test.16 : U8 = 1i64;
let Test.17 : Builtin(Int(U8)) = GetTagId Test.2; let Test.17 : U8 = GetTagId Test.2;
let Test.18 : Builtin(Bool) = lowlevel Eq Test.16 Test.17; let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
if Test.18 then if Test.18 then
let Test.13 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.2; let Test.13 : I64 = UnionAtIndex (Id 1) (Index 0) Test.2;
let Test.14 : Builtin(Int(I64)) = 3i64; let Test.14 : I64 = 3i64;
let Test.15 : Builtin(Bool) = lowlevel Eq Test.14 Test.13; let Test.15 : Int1 = lowlevel Eq Test.14 Test.13;
if Test.15 then if Test.15 then
let Test.10 : Builtin(Int(I64)) = 1i64; let Test.10 : I64 = 1i64;
jump Test.9 Test.10; jump Test.9 Test.10;
else else
let Test.11 : Builtin(Int(I64)) = 2i64; let Test.11 : I64 = 2i64;
jump Test.9 Test.11; jump Test.9 Test.11;
else else
let Test.12 : Builtin(Int(I64)) = 3i64; let Test.12 : I64 = 3i64;
jump Test.9 Test.12; jump Test.9 Test.12;
procedure Test.0 (): procedure Test.0 ():
let Test.7 : Struct([]) = Struct {}; let Test.7 : {} = Struct {};
let Test.6 : Builtin(Int(I64)) = CallByName Test.1 Test.7; let Test.6 : I64 = CallByName Test.1 Test.7;
ret Test.6; ret Test.6;

28
compiler/test_mono/generated/when_on_two_values.txt
View file

@ -1,26 +1,26 @@
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Test.7 : Builtin(Int(I64)) = lowlevel NumAdd #Attr.2 #Attr.3; let Test.7 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Test.7; ret Test.7;
procedure Test.0 (): procedure Test.0 ():
let Test.16 : Builtin(Int(I64)) = 3i64; let Test.16 : I64 = 3i64;
let Test.15 : Builtin(Int(I64)) = 2i64; let Test.15 : I64 = 2i64;
let Test.4 : Struct([Builtin(Int(I64)), Builtin(Int(I64))]) = Struct {Test.15, Test.16}; let Test.4 : {I64, I64} = Struct {Test.15, Test.16};
joinpoint Test.12: joinpoint Test.12:
let Test.2 : Builtin(Int(I64)) = StructAtIndex 0 Test.4; let Test.2 : I64 = StructAtIndex 0 Test.4;
let Test.3 : Builtin(Int(I64)) = StructAtIndex 1 Test.4; let Test.3 : I64 = StructAtIndex 1 Test.4;
let Test.6 : Builtin(Int(I64)) = CallByName Num.22 Test.2 Test.3; let Test.6 : I64 = CallByName Num.22 Test.2 Test.3;
ret Test.6; ret Test.6;
in in
let Test.10 : Builtin(Int(I64)) = StructAtIndex 1 Test.4; let Test.10 : I64 = StructAtIndex 1 Test.4;
let Test.11 : Builtin(Int(I64)) = 3i64; let Test.11 : I64 = 3i64;
let Test.14 : Builtin(Bool) = lowlevel Eq Test.11 Test.10; let Test.14 : Int1 = lowlevel Eq Test.11 Test.10;
if Test.14 then if Test.14 then
let Test.8 : Builtin(Int(I64)) = StructAtIndex 0 Test.4; let Test.8 : I64 = StructAtIndex 0 Test.4;
let Test.9 : Builtin(Int(I64)) = 4i64; let Test.9 : I64 = 4i64;
let Test.13 : Builtin(Bool) = lowlevel Eq Test.9 Test.8; let Test.13 : Int1 = lowlevel Eq Test.9 Test.8;
if Test.13 then if Test.13 then
let Test.5 : Builtin(Int(I64)) = 9i64; let Test.5 : I64 = 9i64;
ret Test.5; ret Test.5;
else else
jump Test.12; jump Test.12;

18
compiler/test_mono/src/tests.rs
View file

@ -1249,6 +1249,24 @@ fn aliased_polymorphic_closure() {
) )
} }
#[mono_test]
fn issue_2535_polymorphic_fields_referenced_in_list() {
indoc!(
r#"
app "test" provides [ nums ] to "./platform"
alpha = { a: 1, b: 2 }
nums : List U8
nums =
[
alpha.a,
alpha.b,
]
"#
)
}
// #[ignore] // #[ignore]
// #[mono_test] // #[mono_test]
// fn static_str_closure() { // fn static_str_closure() {

10
repl_eval/src/eval.rs
View file

@ -331,7 +331,7 @@ fn jit_to_ast_help<'a, A: ReplApp<'a>>(
Layout::Builtin(other) => { Layout::Builtin(other) => {
todo!("add support for rendering builtin {:?} to the REPL", other) todo!("add support for rendering builtin {:?} to the REPL", other)
} }
Layout::Struct(field_layouts) => { Layout::Struct { field_layouts, .. } => {
let struct_addr_to_ast = |mem: &'a A::Memory, addr: usize| match content { let struct_addr_to_ast = |mem: &'a A::Memory, addr: usize| match content {
Content::Structure(FlatType::Record(fields, _)) => { Content::Structure(FlatType::Record(fields, _)) => {
Ok(struct_to_ast(env, mem, addr, field_layouts, *fields)) Ok(struct_to_ast(env, mem, addr, field_layouts, *fields))
@ -382,7 +382,7 @@ fn jit_to_ast_help<'a, A: ReplApp<'a>>(
}; };
let fields = [Layout::u64(), *layout]; let fields = [Layout::u64(), *layout];
let layout = Layout::Struct(&fields); let layout = Layout::struct_no_name_order(&fields);
let result_stack_size = layout.stack_size(env.target_info); let result_stack_size = layout.stack_size(env.target_info);
@ -516,7 +516,7 @@ fn addr_to_ast<'a, M: ReplAppMemory>(
str_to_ast(env.arena, arena_str) str_to_ast(env.arena, arena_str)
} }
(_, Layout::Struct(field_layouts)) => match content { (_, Layout::Struct{field_layouts, ..}) => match content {
Content::Structure(FlatType::Record(fields, _)) => { Content::Structure(FlatType::Record(fields, _)) => {
struct_to_ast(env, mem, addr, field_layouts, *fields) struct_to_ast(env, mem, addr, field_layouts, *fields)
} }
@ -796,7 +796,7 @@ fn single_tag_union_to_ast<'a, M: ReplAppMemory>(
sequence_of_expr(env, mem, addr, it, WhenRecursive::Unreachable).into_bump_slice() sequence_of_expr(env, mem, addr, it, WhenRecursive::Unreachable).into_bump_slice()
} else if field_layouts.is_empty() && !payload_vars.is_empty() { } else if field_layouts.is_empty() && !payload_vars.is_empty() {
// happens for e.g. `Foo Bar` where unit structures are nested and the inner one is dropped // happens for e.g. `Foo Bar` where unit structures are nested and the inner one is dropped
let it = payload_vars.iter().copied().zip([&Layout::Struct(&[])]); let it = payload_vars.iter().copied().zip([&Layout::UNIT]);
sequence_of_expr(env, mem, addr, it, WhenRecursive::Unreachable).into_bump_slice() sequence_of_expr(env, mem, addr, it, WhenRecursive::Unreachable).into_bump_slice()
} else { } else {
unreachable!() unreachable!()
@ -864,7 +864,7 @@ fn struct_to_ast<'a, M: ReplAppMemory>(
env, env,
mem, mem,
addr, addr,
&Layout::Struct(field_layouts), &Layout::struct_no_name_order(field_layouts),
WhenRecursive::Unreachable, WhenRecursive::Unreachable,
inner_content, inner_content,
), ),