From e52d427ac861276d02319e2598ef5b72a7f74190 Mon Sep 17 00:00:00 2001 From: ayazhafiz Date: Sun, 20 Feb 2022 19:51:21 -0500 Subject: [PATCH 1/7] Hash record field name order in generated layouts Closes #2535 See the referenced issue for longer discussion - here's the synopsis. Consider this program ``` app "test" provides [ nums ] to "./platform" alpha = { a: 1, b: 2 } nums : List U8 nums = [ alpha.a, alpha.b, ] ``` Here's its IR: ``` procedure : `#UserApp.alpha` {I64, U8} procedure = `#UserApp.alpha` (): let `#UserApp.5` : Builtin(Int(I64)) = 1i64; let `#UserApp.6` : Builtin(Int(U8)) = 2i64; let `#UserApp.4` : Struct([Builtin(Int(I64)), Builtin(Int(U8))]) = Struct {`#UserApp.5`, `#UserApp.6`}; ret `#UserApp.4`; procedure : `#UserApp.nums` List U8 procedure = `#UserApp.nums` (): let `#UserApp.7` : Struct([Builtin(Int(I64)), Builtin(Int(U8))]) = CallByName `#UserApp.alpha`; let `#UserApp.1` : Builtin(Int(U8)) = StructAtIndex 1 `#UserApp.7`; let `#UserApp.3` : Struct([Builtin(Int(I64)), Builtin(Int(U8))]) = CallByName `#UserApp.alpha`; let `#UserApp.2` : Builtin(Int(U8)) = StructAtIndex 1 `#UserApp.3`; let `#UserApp.0` : Builtin(List(Builtin(Int(U8)))) = Array [`#UserApp.1`, `#UserApp.2`]; ret `#UserApp.0`; ``` What's happening is that we need to specialize `alpha` twice - once for the type of a narrowed to a U8, another time for the type of b narrowed to a U8. We do the specialization for alpha.b first - record fields are sorted by layout, so we generate a record of type {i64, u8}. But then we go to specialize alpha.a, but this has the same layout - {i64, u8} - so we reuse the existing one! So (at least for records), we need to include record field order associated with the sorted layout fields, so that we don't reuse monomorphizations like this incorrectly! --- compiler/gen_dev/src/generic64/storage.rs | 2 +- compiler/gen_llvm/src/llvm/bitcode.rs | 8 +- compiler/gen_llvm/src/llvm/build.rs | 23 +++-- compiler/gen_llvm/src/llvm/build_dict.rs | 3 +- compiler/gen_llvm/src/llvm/build_hash.rs | 10 +- compiler/gen_llvm/src/llvm/compare.rs | 12 +-- compiler/gen_llvm/src/llvm/convert.rs | 10 +- compiler/gen_llvm/src/llvm/refcounting.rs | 15 +-- compiler/gen_wasm/src/backend.rs | 2 +- compiler/gen_wasm/src/layout.rs | 2 +- compiler/gen_wasm/src/low_level.rs | 6 +- compiler/load/src/file.rs | 2 +- compiler/mono/src/alias_analysis.rs | 13 ++- compiler/mono/src/code_gen_help/equality.rs | 2 +- compiler/mono/src/code_gen_help/mod.rs | 16 +++- compiler/mono/src/code_gen_help/refcount.rs | 8 +- compiler/mono/src/decision_tree.rs | 8 +- compiler/mono/src/ir.rs | 45 +++++---- compiler/mono/src/layout.rs | 96 ++++++++++++++----- ..._polymorphic_fields_referenced_in_list.txt | 19 ++++ compiler/test_mono/src/tests.rs | 18 ++++ repl_eval/src/eval.rs | 10 +- 22 files changed, 225 insertions(+), 105 deletions(-) create mode 100644 compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt diff --git a/compiler/gen_dev/src/generic64/storage.rs b/compiler/gen_dev/src/generic64/storage.rs index 93c3734073..c16de57440 100644 --- a/compiler/gen_dev/src/generic64/storage.rs +++ b/compiler/gen_dev/src/generic64/storage.rs @@ -580,7 +580,7 @@ impl< } 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; for (field, field_layout) in fields.iter().zip(field_layouts.iter()) { self.copy_symbol_to_stack_offset(buf, current_offset, field, field_layout); diff --git a/compiler/gen_llvm/src/llvm/bitcode.rs b/compiler/gen_llvm/src/llvm/bitcode.rs index 303d45255f..d80d626036 100644 --- a/compiler/gen_llvm/src/llvm/bitcode.rs +++ b/compiler/gen_llvm/src/llvm/bitcode.rs @@ -374,7 +374,9 @@ fn build_transform_caller_help<'a, 'ctx, 'env>( } match closure_data_layout.runtime_representation() { - Layout::Struct(&[]) => { + Layout::Struct { + field_layouts: &[], .. + } => { // nothing to add } other => { @@ -694,7 +696,9 @@ pub fn build_compare_wrapper<'a, 'ctx, 'env>( let default = [value1.into(), value2.into()]; let arguments_cast = match closure_data_layout.runtime_representation() { - Layout::Struct(&[]) => { + Layout::Struct { + field_layouts: &[], .. + } => { // nothing to add &default } diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 0f989fb0fd..1fb64493f4 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -714,8 +714,7 @@ fn promote_to_main_function<'a, 'ctx, 'env>( ); // NOTE fake layout; it is only used for debug prints - let roc_main_fn = - function_value_by_func_spec(env, *func_spec, symbol, &[], &Layout::Struct(&[])); + let roc_main_fn = function_value_by_func_spec(env, *func_spec, symbol, &[], &Layout::UNIT); let main_fn_name = "$Test.main"; @@ -1188,8 +1187,8 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( // extract field from a record match (value, layout) { - (StructValue(argument), Layout::Struct(fields)) => { - debug_assert!(!fields.is_empty()); + (StructValue(argument), Layout::Struct { field_layouts, .. }) => { + debug_assert!(!field_layouts.is_empty()); let field_value = env .builder @@ -1201,14 +1200,14 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( ) .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") } ( PointerValue(argument), 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 cast_argument = env @@ -1292,7 +1291,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( ) } 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); @@ -1341,7 +1340,7 @@ pub fn build_exp_expr<'a, 'ctx, 'env>( debug_assert_ne!(*tag_id != 0, *nullable_id); 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); @@ -2024,7 +2023,7 @@ fn lookup_at_index_ptr2<'a, 'ctx, 'env>( ) -> BasicValueEnum<'ctx> { 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 wrapper_type = env @@ -3522,7 +3521,7 @@ fn expose_function_to_host_help_c_abi_gen_test<'a, 'ctx, 'env>( call_roc_function( env, roc_wrapper_function, - &Layout::Struct(&[Layout::u64(), return_layout]), + &Layout::struct_no_name_order(&[Layout::u64(), return_layout]), arguments_for_call, ) }; @@ -3903,7 +3902,7 @@ fn roc_result_layout<'a>( ) -> Layout<'a> { 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>( @@ -5363,7 +5362,7 @@ fn run_low_level<'a, 'ctx, 'env>( let (string, _string_layout) = load_symbol_and_layout(scope, &args[0]); 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!(), }; diff --git a/compiler/gen_llvm/src/llvm/build_dict.rs b/compiler/gen_llvm/src/llvm/build_dict.rs index 37b81e9129..cbecc59b9a 100644 --- a/compiler/gen_llvm/src/llvm/build_dict.rs +++ b/compiler/gen_llvm/src/llvm/build_dict.rs @@ -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 alignment = - Alignment::from_key_value_layout(key_layout, &Layout::Struct(&[]), env.target_info); + let alignment = Alignment::from_key_value_layout(key_layout, &Layout::UNIT, env.target_info); let alignment_iv = alignment.as_int_value(env.context); let hash_fn = build_hash_wrapper(env, layout_ids, key_layout); diff --git a/compiler/gen_llvm/src/llvm/build_hash.rs b/compiler/gen_llvm/src/llvm/build_hash.rs index 0db5348d1d..aa89583c77 100644 --- a/compiler/gen_llvm/src/llvm/build_hash.rs +++ b/compiler/gen_llvm/src/llvm/build_hash.rs @@ -50,10 +50,10 @@ fn build_hash_layout<'a, 'ctx, 'env>( 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, layout_ids, - fields, + field_layouts, when_recursive, seed, 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 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 fn_name = layout_ids @@ -248,7 +248,7 @@ fn hash_struct<'a, 'ctx, 'env>( ) -> IntValue<'ctx> { 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 // 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") .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_ptr = env .builder diff --git a/compiler/gen_llvm/src/llvm/compare.rs b/compiler/gen_llvm/src/llvm/compare.rs index f5d596aae1..9f8a0928a6 100644 --- a/compiler/gen_llvm/src/llvm/compare.rs +++ b/compiler/gen_llvm/src/llvm/compare.rs @@ -161,10 +161,10 @@ fn build_eq<'a, 'ctx, 'env>( 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, layout_ids, - fields, + field_layouts, when_recursive, lhs_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) } - Layout::Struct(fields) => { + Layout::Struct { field_layouts, .. } => { let is_equal = build_struct_eq( env, layout_ids, - fields, + field_layouts, when_recursive, lhs_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 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 fn_name = layout_ids @@ -1208,7 +1208,7 @@ fn eq_ptr_to_struct<'a, 'ctx, 'env>( tag1: PointerValue<'ctx>, tag2: PointerValue<'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); debug_assert!(wrapper_type.is_struct_type()); diff --git a/compiler/gen_llvm/src/llvm/convert.rs b/compiler/gen_llvm/src/llvm/convert.rs index c7d3142d40..8d516e539e 100644 --- a/compiler/gen_llvm/src/llvm/convert.rs +++ b/compiler/gen_llvm/src/llvm/convert.rs @@ -28,7 +28,10 @@ pub fn basic_type_from_layout<'a, 'ctx, 'env>( use 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()), Union(union_layout) => { use UnionLayout::*; @@ -86,7 +89,10 @@ pub fn basic_type_from_layout_1<'a, 'ctx, 'env>( use 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_1(env, &lambda_set.runtime_representation()) } diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index 2962361c29..24bf02d093 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -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 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( layout_ids, @@ -440,7 +440,7 @@ fn modify_refcount_builtin<'a, 'ctx, 'env>( } Set(element_layout) => { let key_layout = element_layout; - let value_layout = &Layout::Struct(&[]); + let value_layout = &Layout::UNIT; let function = modify_refcount_dict( env, @@ -619,8 +619,9 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( } } - Struct(layouts) => { - let function = modify_refcount_struct(env, layout_ids, layouts, mode, when_recursive); + Struct { field_layouts, .. } => { + let function = + modify_refcount_struct(env, layout_ids, &field_layouts, mode, when_recursive); Some(function) } @@ -1312,7 +1313,8 @@ fn build_rec_union_recursive_decrement<'a, 'ctx, 'env>( 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 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"); 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()); let opaque_tag_data_ptr = env diff --git a/compiler/gen_wasm/src/backend.rs b/compiler/gen_wasm/src/backend.rs index 716758fc56..d23a54ccb2 100644 --- a/compiler/gen_wasm/src/backend.rs +++ b/compiler/gen_wasm/src/backend.rs @@ -884,7 +884,7 @@ impl<'a> WasmBackend<'a> { storage: &StoredValue, fields: &'a [Symbol], ) { - if matches!(layout, Layout::Struct(_)) { + if matches!(layout, Layout::Struct { .. }) { match storage { StoredValue::StackMemory { location, size, .. } => { if *size > 0 { diff --git a/compiler/gen_wasm/src/layout.rs b/compiler/gen_wasm/src/layout.rs index b7ad18b2ef..1b70e0757a 100644 --- a/compiler/gen_wasm/src/layout.rs +++ b/compiler/gen_wasm/src/layout.rs @@ -88,7 +88,7 @@ impl WasmLayout { }, Layout::Builtin(Str | Dict(_, _) | Set(_) | List(_)) - | Layout::Struct(_) + | Layout::Struct { .. } | Layout::LambdaSet(_) | Layout::Union(NonRecursive(_)) => Self::StackMemory { size, diff --git a/compiler/gen_wasm/src/low_level.rs b/compiler/gen_wasm/src/low_level.rs index acd4a32455..a5875e1813 100644 --- a/compiler/gen_wasm/src/low_level.rs +++ b/compiler/gen_wasm/src/low_level.rs @@ -212,7 +212,7 @@ impl<'a> LowLevelCall<'a> { } StrToNum => { 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) } @@ -711,7 +711,7 @@ impl<'a> LowLevelCall<'a> { // Empty record is always equal to empty record. // 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); } @@ -722,7 +722,7 @@ impl<'a> LowLevelCall<'a> { } Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_) | Builtin::List(_)) - | Layout::Struct(_) + | Layout::Struct { .. } | Layout::Union(_) | Layout::LambdaSet(_) => { // Don't want Zig calling convention here, we're calling internal Roc functions diff --git a/compiler/load/src/file.rs b/compiler/load/src/file.rs index 0a119ecb23..0cfa433b12 100644 --- a/compiler/load/src/file.rs +++ b/compiler/load/src/file.rs @@ -2101,7 +2101,7 @@ fn finish_specialization( EntryPoint { layout: roc_mono::ir::ProcLayout { arguments: &[], - result: Layout::Struct(&[]), + result: Layout::struct_no_name_order(&[]), }, symbol, } diff --git a/compiler/mono/src/alias_analysis.rs b/compiler/mono/src/alias_analysis.rs index f42b554628..810e3c3595 100644 --- a/compiler/mono/src/alias_analysis.rs +++ b/compiler/mono/src/alias_analysis.rs @@ -308,7 +308,7 @@ fn build_entry_point( 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)?; @@ -349,7 +349,10 @@ fn proc_spec<'a>(proc: &Proc<'a>) -> Result<(FuncDef, MutSet>)> let value_id = stmt_spec(&mut builder, &mut env, block, &proc.ret_layout, &proc.body)?; 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 spec = builder.build(arg_type_id, ret_type_id, root)?; @@ -1135,7 +1138,7 @@ fn call_spec( // ListFindUnsafe returns { value: v, found: Bool=Int1 } 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 loop_body = |builder: &mut FuncDefBuilder, block, output| { @@ -1672,7 +1675,9 @@ fn layout_spec_help( match layout { 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( builder, &lambda_set.runtime_representation(), diff --git a/compiler/mono/src/code_gen_help/equality.rs b/compiler/mono/src/code_gen_help/equality.rs index d58d095274..cf4fbcff17 100644 --- a/compiler/mono/src/code_gen_help/equality.rs +++ b/compiler/mono/src/code_gen_help/equality.rs @@ -32,7 +32,7 @@ pub fn eq_generic<'a>( } Layout::Builtin(Builtin::Dict(_, _) | Builtin::Set(_)) => eq_todo(), 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::LambdaSet(_) => unreachable!("`==` is not defined on functions"), Layout::RecursivePointer => { diff --git a/compiler/mono/src/code_gen_help/mod.rs b/compiler/mono/src/code_gen_help/mod.rs index e74e4058ed..55d99fc266 100644 --- a/compiler/mono/src/code_gen_help/mod.rs +++ b/compiler/mono/src/code_gen_help/mod.rs @@ -15,7 +15,7 @@ mod equality; mod refcount; 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_2: Symbol = Symbol::ARG_2; @@ -354,9 +354,15 @@ impl<'a> CodeGenHelp<'a> { Layout::Builtin(_) => layout, - Layout::Struct(fields) => { - let new_fields_iter = fields.iter().map(|f| self.replace_rec_ptr(ctx, *f)); - Layout::Struct(self.arena.alloc_slice_fill_iter(new_fields_iter)) + Layout::Struct { + field_layouts, + 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)) => { @@ -462,7 +468,7 @@ fn layout_needs_helper_proc(layout: &Layout, op: HelperOp) -> bool { 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(), diff --git a/compiler/mono/src/code_gen_help/refcount.rs b/compiler/mono/src/code_gen_help/refcount.rs index 272e503d18..60e15b9f73 100644 --- a/compiler/mono/src/code_gen_help/refcount.rs +++ b/compiler/mono/src/code_gen_help/refcount.rs @@ -12,7 +12,7 @@ use crate::layout::{Builtin, Layout, TagIdIntType, UnionLayout}; use super::{CodeGenHelp, Context, HelperOp}; 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_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 - Layout::Struct(_) => following, + Layout::Struct { .. } => following, Layout::Union(UnionLayout::NonRecursive(_)) => following, // 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) } 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) } 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::List(elem_layout)) => is_rc_implemented_yet(elem_layout), 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 { NonRecursive(tags) => tags .iter() diff --git a/compiler/mono/src/decision_tree.rs b/compiler/mono/src/decision_tree.rs index b37391d9cd..39c28f49d8 100644 --- a/compiler/mono/src/decision_tree.rs +++ b/compiler/mono/src/decision_tree.rs @@ -747,7 +747,11 @@ fn to_relevant_branch_help<'a>( // the test matches the constructor of this pattern match layout { - UnionLayout::NonRecursive([[Layout::Struct([_])]]) => { + UnionLayout::NonRecursive( + [[Layout::Struct { + field_layouts: [_], .. + }]], + ) => { // a one-element record equivalent // Theory: Unbox doesn't have any value for us debug_assert_eq!(arguments.len(), 1); @@ -1235,7 +1239,7 @@ fn path_to_expr_help<'a>( layout = inner_layout; } - Layout::Struct(field_layouts) => { + Layout::Struct { field_layouts, .. } => { debug_assert!(field_layouts.len() > 1); let inner_expr = Expr::StructAtIndex { diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index 6a4c1e5449..c1d7741233 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1125,7 +1125,7 @@ impl<'a> Param<'a> { pub const EMPTY: Self = Param { symbol: Symbol::EMPTY_PARAM, borrow: false, - layout: Layout::Struct(&[]), + layout: Layout::UNIT, }; } @@ -2436,7 +2436,7 @@ fn specialize_external<'a>( let closure_data_layout = match opt_closure_layout { 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? @@ -3985,7 +3985,7 @@ pub fn with_hole<'a>( .unwrap_or_else(|err| panic!("TODO turn fn_var into a RuntimeError {:?}", err)); let field_layouts = match &record_layout { - Layout::Struct(layouts) => *layouts, + Layout::Struct { field_layouts, .. } => *field_layouts, other => arena.alloc([*other]), }; @@ -4701,7 +4701,9 @@ fn construct_closure_data<'a>( Vec::from_iter_in(combined.iter().map(|(_, b)| **b), env.arena).into_bump_slice(); debug_assert_eq!( - Layout::Struct(field_layouts), + // NB: this may be wrong! If it comes up, we may need to hash the closure + // argument name order. + Layout::struct_no_name_order(field_layouts,), lambda_set.runtime_representation() ); @@ -4785,9 +4787,7 @@ fn convert_tag_union<'a>( "The `[]` type has no constructors, source var {:?}", variant_var ), - Unit | UnitWithArguments => { - Stmt::Let(assigned, Expr::Struct(&[]), Layout::Struct(&[]), hole) - } + Unit | UnitWithArguments => Stmt::Let(assigned, Expr::Struct(&[]), Layout::UNIT, hole), BoolUnion { ttrue, .. } => Stmt::Let( assigned, Expr::Literal(Literal::Bool(tag_name == ttrue)), @@ -5096,7 +5096,7 @@ fn sorted_field_symbols<'a>( // Note it does not catch the use of `[]` currently. use roc_can::expr::Expr; arg.value = Expr::RuntimeError(RuntimeError::VoidValue); - Layout::Struct(&[]) + Layout::UNIT } Err(LayoutProblem::Erroneous) => { // something went very wrong @@ -5191,7 +5191,10 @@ fn register_capturing_closure<'a>( Content::Structure(FlatType::Func(_, closure_var, _)) => { match LambdaSet::from_var(env.arena, env.subs, closure_var, env.target_info) { Ok(lambda_set) => { - if let Layout::Struct(&[]) = lambda_set.runtime_representation() { + if let Layout::Struct { + field_layouts: &[], .. + } = lambda_set.runtime_representation() + { CapturedSymbols::None } else { let mut temp = Vec::from_iter_in(captured_symbols, env.arena); @@ -6255,7 +6258,7 @@ fn store_pattern_help<'a>( let mut fields = Vec::with_capacity_in(arguments.len(), env.arena); 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( env, @@ -6676,7 +6679,7 @@ fn force_thunk<'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 @@ -8457,7 +8460,7 @@ where env.arena.alloc(result), ) } - Layout::Struct(_) => match lambda_set.set.get(0) { + Layout::Struct { .. } => match lambda_set.set.get(0) { Some((function_symbol, _)) => { let call_spec_id = env.next_call_specialization_id(); let update_mode = env.next_update_mode_id(); @@ -8630,7 +8633,10 @@ fn match_on_lambda_set<'a>( env.arena.alloc(result), ) } - Layout::Struct(fields) => { + Layout::Struct { + field_layouts, + field_order_hash, + } => { let function_symbol = lambda_set.set[0].0; union_lambda_set_branch_help( @@ -8638,7 +8644,10 @@ fn match_on_lambda_set<'a>( function_symbol, lambda_set, closure_data_symbol, - Layout::Struct(fields), + Layout::Struct { + field_layouts, + field_order_hash, + }, argument_symbols, argument_layouts, return_layout, @@ -8797,7 +8806,9 @@ fn union_lambda_set_branch_help<'a>( hole: &'a Stmt<'a>, ) -> Stmt<'a> { let (argument_layouts, argument_symbols) = match closure_data_layout { - Layout::Struct(&[]) + Layout::Struct { + field_layouts: &[], .. + } | Layout::Builtin(Builtin::Bool) | Layout::Builtin(Builtin::Int(IntWidth::U8)) => { (argument_layouts_slice, argument_symbols_slice) @@ -8924,7 +8935,9 @@ fn enum_lambda_set_branch<'a>( let assigned = result_symbol; let (argument_layouts, argument_symbols) = match closure_data_layout { - Layout::Struct(&[]) + Layout::Struct { + field_layouts: &[], .. + } | Layout::Builtin(Builtin::Bool) | Layout::Builtin(Builtin::Int(IntWidth::U8)) => { (argument_layouts_slice, argument_symbols_slice) diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index b04993c9d6..abf61dd010 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -11,8 +11,9 @@ use roc_types::subs::{ Content, FlatType, RecordFields, Subs, UnionTags, UnsortedUnionTags, Variable, }; 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::hash::{Hash, Hasher}; use ven_pretty::{DocAllocator, DocBuilder}; // if your changes cause this number to go down, great! @@ -26,6 +27,7 @@ static_assertions::assert_eq_size!([usize; 3], LambdaSet); pub type TagIdIntType = u16; pub const MAX_ENUM_SIZE: usize = (std::mem::size_of::() * 8) as usize; const GENERATE_NULLABLE: bool = true; +const IRRELEVANT_FIELD_HASH: u64 = 0; #[derive(Debug, Clone)] pub enum LayoutProblem { @@ -205,10 +207,19 @@ impl<'a> RawFunctionLayout<'a> { #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum Layout<'a> { Builtin(Builtin<'a>), - /// A layout that is empty (turns into the empty struct in LLVM IR - /// but for our purposes, not zero-sized, so it does not get dropped from data structures - /// this is important for closures that capture zero-sized values - Struct(&'a [Layout<'a>]), + Struct { + /// Two different struct types can have the same layout, for example + /// { a: U8, b: I64 } + /// { 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: u64, + field_layouts: &'a [Layout<'a>], + }, Union(UnionLayout<'a>), LambdaSet(LambdaSet<'a>), RecursivePointer, @@ -417,7 +428,9 @@ impl<'a> UnionLayout<'a> { fn tags_alignment_bytes(tags: &[&[Layout]], target_info: TargetInfo) -> u32 { 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() .unwrap_or(0) } @@ -426,14 +439,14 @@ impl<'a> UnionLayout<'a> { let allocation = match self { UnionLayout::NonRecursive(_) => unreachable!("not heap-allocated"), UnionLayout::Recursive(tags) => Self::tags_alignment_bytes(tags, target_info), - UnionLayout::NonNullableUnwrapped(fields) => { - Layout::Struct(fields).alignment_bytes(target_info) + UnionLayout::NonNullableUnwrapped(field_layouts) => { + Layout::struct_no_name_order(field_layouts).alignment_bytes(target_info) } UnionLayout::NullableWrapped { other_tags, .. } => { Self::tags_alignment_bytes(other_tags, target_info) } 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 +508,12 @@ impl<'a> UnionLayout<'a> { let mut alignment_bytes = 0; 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; if let Some(id_layout) = id_data_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); @@ -590,7 +603,10 @@ impl<'a> LambdaSet<'a> { } pub fn is_represented(&self) -> Option> { - if let Layout::Struct(&[]) = self.representation { + if let Layout::Struct { + field_layouts: &[], .. + } = self.representation + { None } else { Some(*self.representation) @@ -648,7 +664,7 @@ impl<'a> LambdaSet<'a> { } => todo!("recursive closures"), } } - Layout::Struct(_) => { + Layout::Struct { .. } => { // get the fields from the set, where they are sorted in alphabetic order // (and not yet sorted by their alignment) let (_, fields) = self @@ -673,7 +689,9 @@ impl<'a> LambdaSet<'a> { argument_layouts } else { match self.representation { - Layout::Struct(&[]) => { + Layout::Struct { + field_layouts: &[], .. + } => { // this function does not have anything in its closure, and the lambda set is a // singleton, so we pass no extra argument argument_layouts @@ -769,7 +787,7 @@ impl<'a> LambdaSet<'a> { } Newtype { arguments: layouts, .. - } => Layout::Struct(layouts.into_bump_slice()), + } => Layout::struct_no_name_order(layouts.into_bump_slice()), Wrapped(variant) => { use WrappedVariant::*; @@ -865,7 +883,10 @@ pub const fn round_up_to_alignment(width: u32, alignment: u32) -> u32 { impl<'a> Layout<'a> { 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: IRRELEVANT_FIELD_HASH, + }; fn new_help<'b>( env: &mut Env<'a, 'b>, @@ -926,7 +947,7 @@ impl<'a> Layout<'a> { match self { Builtin(builtin) => builtin.safe_to_memcpy(), - Struct(fields) => fields + Struct { field_layouts, .. } => field_layouts .iter() .all(|field_layout| field_layout.safe_to_memcpy()), Union(variant) => { @@ -990,10 +1011,10 @@ impl<'a> Layout<'a> { match self { Builtin(builtin) => builtin.stack_size(target_info), - Struct(fields) => { + Struct { field_layouts, .. } => { let mut sum = 0; - for field_layout in *fields { + for field_layout in *field_layouts { sum += field_layout.stack_size(target_info); } @@ -1020,7 +1041,7 @@ impl<'a> Layout<'a> { pub fn alignment_bytes(&self, target_info: TargetInfo) -> u32 { match self { - Layout::Struct(fields) => fields + Layout::Struct { field_layouts, .. } => field_layouts .iter() .map(|x| x.alignment_bytes(target_info)) .max() @@ -1069,7 +1090,7 @@ impl<'a> Layout<'a> { pub fn allocation_alignment_bytes(&self, target_info: TargetInfo) -> u32 { match self { 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::LambdaSet(lambda_set) => lambda_set .runtime_representation() @@ -1103,7 +1124,7 @@ impl<'a> Layout<'a> { match self { 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) => { use UnionLayout::*; @@ -1134,8 +1155,8 @@ impl<'a> Layout<'a> { match self { Builtin(builtin) => builtin.to_doc(alloc, parens), - Struct(fields) => { - let fields_doc = fields.iter().map(|x| x.to_doc(alloc, parens)); + Struct { field_layouts, .. } => { + let fields_doc = field_layouts.iter().map(|x| x.to_doc(alloc, parens)); alloc .text("{") @@ -1147,6 +1168,14 @@ impl<'a> Layout<'a> { 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 { + Self::Struct { + field_layouts, + field_order_hash: IRRELEVANT_FIELD_HASH, + } + } } /// Avoid recomputing Layout from Variable multiple times. @@ -1590,6 +1619,14 @@ fn layout_from_flat_type<'a>( size2.cmp(&size1).then(label1.cmp(label2)) }); + let field_order_hash = { + let mut field_order_hasher = DefaultHasher::new(); + pairs + .iter() + .for_each(|(label, _)| label.hash(&mut field_order_hasher)); + field_order_hasher.finish() + }; + let mut layouts = Vec::from_iter_in(pairs.into_iter().map(|t| t.1), arena); if layouts.len() == 1 { @@ -1597,7 +1634,10 @@ fn layout_from_flat_type<'a>( // unwrap it. Ok(layouts.pop().unwrap()) } else { - Ok(Layout::Struct(layouts.into_bump_slice())) + Ok(Layout::Struct { + field_order_hash, + field_layouts: layouts.into_bump_slice(), + }) } } TagUnion(tags, ext_var) => { @@ -2224,6 +2264,9 @@ pub fn union_sorted_tags_help<'a>( } else { UnionVariant::Newtype { tag_name, + // NB: It may be the case that the order of the layouts chosen here must be + // hashed, in case they differ for two specializations of the same type. If + // there is a problem with newtypes not specializing correctly, this might be why! arguments: layouts, } } @@ -2430,7 +2473,8 @@ fn layout_from_tag_union<'a>( let answer1 = if field_layouts.len() == 1 { field_layouts[0] } else { - Layout::Struct(field_layouts.into_bump_slice()) + // NB: does the field name order here matter, when it comes from the tag payload order? + Layout::struct_no_name_order(field_layouts.into_bump_slice()) }; answer1 diff --git a/compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt b/compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt new file mode 100644 index 0000000000..a30515bee8 --- /dev/null +++ b/compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt @@ -0,0 +1,19 @@ +procedure Test.1 (): + let Test.11 : Builtin(Int(I64)) = 2i64; + let Test.12 : Builtin(Int(U8)) = 1i64; + let Test.10 : Struct { field_order_hash: 4700212371939112988, field_layouts: [Builtin(Int(I64)), Builtin(Int(U8))] } = Struct {Test.11, Test.12}; + ret Test.10; + +procedure Test.1 (): + let Test.7 : Builtin(Int(I64)) = 1i64; + let Test.8 : Builtin(Int(U8)) = 2i64; + let Test.6 : Struct { field_order_hash: 17343052842552570643, field_layouts: [Builtin(Int(I64)), Builtin(Int(U8))] } = Struct {Test.7, Test.8}; + ret Test.6; + +procedure Test.0 (): + let Test.9 : Struct { field_order_hash: 4700212371939112988, field_layouts: [Builtin(Int(I64)), Builtin(Int(U8))] } = CallByName Test.1; + let Test.3 : Builtin(Int(U8)) = StructAtIndex 1 Test.9; + let Test.5 : Struct { field_order_hash: 17343052842552570643, field_layouts: [Builtin(Int(I64)), Builtin(Int(U8))] } = CallByName Test.1; + let Test.4 : Builtin(Int(U8)) = StructAtIndex 1 Test.5; + let Test.2 : Builtin(List(Builtin(Int(U8)))) = Array [Test.3, Test.4]; + ret Test.2; diff --git a/compiler/test_mono/src/tests.rs b/compiler/test_mono/src/tests.rs index 6903714eaa..28bb791955 100644 --- a/compiler/test_mono/src/tests.rs +++ b/compiler/test_mono/src/tests.rs @@ -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] // #[mono_test] // fn static_str_closure() { diff --git a/repl_eval/src/eval.rs b/repl_eval/src/eval.rs index f97ce94494..483d7b6be6 100644 --- a/repl_eval/src/eval.rs +++ b/repl_eval/src/eval.rs @@ -331,7 +331,7 @@ fn jit_to_ast_help<'a, A: ReplApp<'a>>( Layout::Builtin(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 { Content::Structure(FlatType::Record(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 layout = Layout::Struct(&fields); + let layout = Layout::struct_no_name_order(&fields); 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) } - (_, Layout::Struct(field_layouts)) => match content { + (_, Layout::Struct{field_layouts, ..}) => match content { Content::Structure(FlatType::Record(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() } 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 - 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() } else { unreachable!() @@ -864,7 +864,7 @@ fn struct_to_ast<'a, M: ReplAppMemory>( env, mem, addr, - &Layout::Struct(field_layouts), + &Layout::struct_no_name_order(field_layouts), WhenRecursive::Unreachable, inner_content, ), From dfc384aa1fd0b0dc70be398e2a7c8505aebb495f Mon Sep 17 00:00:00 2001 From: ayazhafiz Date: Sun, 20 Feb 2022 19:54:07 -0500 Subject: [PATCH 2/7] Make mono test output prettier --- compiler/mono/src/ir.rs | 4 +- .../test_mono/generated/alias_variable.txt | 2 +- .../alias_variable_and_return_it.txt | 2 +- .../generated/aliased_polymorphic_closure.txt | 18 ++--- .../generated/branch_store_variable.txt | 8 +-- .../test_mono/generated/closure_in_list.txt | 18 ++--- compiler/test_mono/generated/dict.txt | 8 +-- .../generated/empty_list_of_function_type.txt | 40 +++++------ compiler/test_mono/generated/factorial.txt | 20 +++--- compiler/test_mono/generated/fst.txt | 6 +- .../generated/guard_pattern_true.txt | 16 ++--- compiler/test_mono/generated/has_none.txt | 30 ++++----- .../if_guard_bind_variable_false.txt | 16 ++--- .../test_mono/generated/if_multi_branch.txt | 10 +-- .../test_mono/generated/ir_assignment.txt | 2 +- compiler/test_mono/generated/ir_int_add.txt | 20 +++--- .../test_mono/generated/ir_int_literal.txt | 2 +- compiler/test_mono/generated/ir_plus.txt | 8 +-- compiler/test_mono/generated/ir_round.txt | 6 +- compiler/test_mono/generated/ir_two_defs.txt | 8 +-- compiler/test_mono/generated/ir_when_idiv.txt | 28 ++++---- compiler/test_mono/generated/ir_when_just.txt | 20 +++--- .../test_mono/generated/ir_when_maybe.txt | 14 ++-- .../test_mono/generated/ir_when_record.txt | 8 +-- .../test_mono/generated/ir_when_these.txt | 14 ++-- compiler/test_mono/generated/is_nil.txt | 18 ++--- ..._polymorphic_fields_referenced_in_list.txt | 22 +++---- .../generated/let_with_record_pattern.txt | 8 +-- .../let_with_record_pattern_list.txt | 8 +-- compiler/test_mono/generated/let_x_in_x.txt | 2 +- .../generated/let_x_in_x_indirect.txt | 8 +-- .../generated/linked_list_length_twice.txt | 26 ++++---- compiler/test_mono/generated/list_append.txt | 8 +-- .../generated/list_append_closure.txt | 10 +-- .../generated/list_cannot_update_inplace.txt | 30 ++++----- compiler/test_mono/generated/list_get.txt | 22 +++---- compiler/test_mono/generated/list_len.txt | 16 ++--- .../generated/list_pass_to_function.txt | 16 ++--- compiler/test_mono/generated/mk_pair_of.txt | 6 +- .../generated/monomorphized_applied_tag.txt | 16 ++--- .../generated/monomorphized_floats.txt | 8 +-- .../generated/monomorphized_ints.txt | 8 +-- .../generated/monomorphized_ints_aliased.txt | 24 +++---- .../generated/monomorphized_list.txt | 8 +-- .../test_mono/generated/monomorphized_tag.txt | 8 +-- .../monomorphized_tag_with_aliased_args.txt | 10 +-- .../test_mono/generated/nested_closure.txt | 16 ++--- .../generated/nested_pattern_match.txt | 32 ++++----- .../test_mono/generated/one_element_tag.txt | 2 +- .../test_mono/generated/optional_when.txt | 50 +++++++------- compiler/test_mono/generated/peano.txt | 8 +-- compiler/test_mono/generated/peano1.txt | 18 ++--- compiler/test_mono/generated/peano2.txt | 28 ++++---- .../test_mono/generated/quicksort_help.txt | 36 +++++----- .../test_mono/generated/quicksort_swap.txt | 66 +++++++++---------- ...optional_field_function_no_use_default.txt | 16 ++--- ...rd_optional_field_function_use_default.txt | 10 +-- ...cord_optional_field_let_no_use_default.txt | 16 ++--- .../record_optional_field_let_use_default.txt | 10 +-- compiler/test_mono/generated/rigids.txt | 62 ++++++++--------- compiler/test_mono/generated/simple_if.txt | 6 +- .../generated/somehow_drops_definitions.txt | 30 ++++----- .../generated/specialize_closures.txt | 36 +++++----- .../generated/specialize_lowlevel.txt | 30 ++++----- .../test_mono/generated/when_joinpoint.txt | 12 ++-- .../test_mono/generated/when_nested_maybe.txt | 32 ++++----- .../test_mono/generated/when_on_record.txt | 8 +-- .../test_mono/generated/when_on_result.txt | 26 ++++---- .../generated/when_on_two_values.txt | 28 ++++---- 69 files changed, 594 insertions(+), 594 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index c1d7741233..f5eb2a3b44 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -1725,11 +1725,11 @@ impl<'a> Stmt<'a> { use Stmt::*; match self { - Let(symbol, expr, _layout, cont) => alloc + Let(symbol, expr, layout, cont) => alloc .text("let ") .append(symbol_to_doc(alloc, *symbol)) .append(" : ") - .append(alloc.text(format!("{:?}", _layout))) + .append(layout.to_doc(alloc, Parens::NotNeeded)) .append(" = ") .append(expr.to_doc(alloc)) .append(";") diff --git a/compiler/test_mono/generated/alias_variable.txt b/compiler/test_mono/generated/alias_variable.txt index 657376d73a..ccb6249257 100644 --- a/compiler/test_mono/generated/alias_variable.txt +++ b/compiler/test_mono/generated/alias_variable.txt @@ -1,3 +1,3 @@ procedure Test.0 (): - let Test.3 : Builtin(Int(I64)) = 3i64; + let Test.3 : I64 = 3i64; ret Test.3; diff --git a/compiler/test_mono/generated/alias_variable_and_return_it.txt b/compiler/test_mono/generated/alias_variable_and_return_it.txt index 9e5824a185..63fd9ba01e 100644 --- a/compiler/test_mono/generated/alias_variable_and_return_it.txt +++ b/compiler/test_mono/generated/alias_variable_and_return_it.txt @@ -1,3 +1,3 @@ procedure Test.0 (): - let Test.2 : Builtin(Int(I64)) = 5i64; + let Test.2 : I64 = 5i64; ret Test.2; diff --git a/compiler/test_mono/generated/aliased_polymorphic_closure.txt b/compiler/test_mono/generated/aliased_polymorphic_closure.txt index bf1eb3d95d..cd870ec963 100644 --- a/compiler/test_mono/generated/aliased_polymorphic_closure.txt +++ b/compiler/test_mono/generated/aliased_polymorphic_closure.txt @@ -1,17 +1,17 @@ procedure Test.2 (Test.6, #Attr.12): - let Test.1 : Builtin(Int(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.1 : U8 = StructAtIndex 0 #Attr.12; + let Test.11 : {U8} = Struct {Test.1}; ret Test.11; 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; procedure Test.0 (): - let Test.1 : Builtin(Int(U8)) = 1i64; - let Test.8 : Struct([]) = Struct {}; - let Test.10 : Struct([]) = Struct {}; - let Test.14 : LambdaSet(LambdaSet { set: [( Test.2, [Builtin(Int(U8))])], representation: Struct([Builtin(Int(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.7 : Builtin(Int(U8)) = CallByName Test.4 Test.8 Test.9; + let Test.1 : U8 = 1i64; + let Test.8 : {} = Struct {}; + let Test.10 : {} = Struct {}; + let Test.14 : {U8} = Struct {Test.1}; + let Test.9 : {U8} = CallByName Test.2 Test.10 Test.14; + let Test.7 : U8 = CallByName Test.4 Test.8 Test.9; ret Test.7; diff --git a/compiler/test_mono/generated/branch_store_variable.txt b/compiler/test_mono/generated/branch_store_variable.txt index 567b83bd1f..4731462e7b 100644 --- a/compiler/test_mono/generated/branch_store_variable.txt +++ b/compiler/test_mono/generated/branch_store_variable.txt @@ -1,9 +1,9 @@ procedure Test.0 (): - let Test.2 : Builtin(Int(I64)) = 0i64; - let Test.5 : Builtin(Int(I64)) = 1i64; - let Test.6 : Builtin(Bool) = lowlevel Eq Test.5 Test.2; + let Test.2 : I64 = 0i64; + let Test.5 : I64 = 1i64; + let Test.6 : Int1 = lowlevel Eq Test.5 Test.2; if Test.6 then - let Test.3 : Builtin(Int(I64)) = 12i64; + let Test.3 : I64 = 12i64; ret Test.3; else ret Test.2; diff --git a/compiler/test_mono/generated/closure_in_list.txt b/compiler/test_mono/generated/closure_in_list.txt index 0347966c3e..18496e4156 100644 --- a/compiler/test_mono/generated/closure_in_list.txt +++ b/compiler/test_mono/generated/closure_in_list.txt @@ -1,21 +1,21 @@ 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; procedure Test.1 (Test.5): - let Test.2 : Builtin(Int(I64)) = 41i64; - let Test.12 : LambdaSet(LambdaSet { set: [( Test.3, [Builtin(Int(I64))])], representation: Struct([Builtin(Int(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.2 : I64 = 41i64; + let Test.12 : {I64} = Struct {Test.2}; + let Test.11 : List {I64} = Array [Test.12]; ret Test.11; procedure Test.3 (Test.10, #Attr.12): - let Test.2 : Builtin(Int(I64)) = StructAtIndex 0 #Attr.12; - let Test.2 : Builtin(Int(I64)) = 41i64; + let Test.2 : I64 = StructAtIndex 0 #Attr.12; + let Test.2 : I64 = 41i64; ret Test.2; procedure Test.0 (): - let Test.9 : Struct([]) = 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.6 : Builtin(Int(U64)) = CallByName List.7 Test.7; + let Test.9 : {} = Struct {}; + let Test.7 : List {I64} = CallByName Test.1 Test.9; + let Test.6 : U64 = CallByName List.7 Test.7; dec Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/dict.txt b/compiler/test_mono/generated/dict.txt index ad2fbf5701..4244fb0e0c 100644 --- a/compiler/test_mono/generated/dict.txt +++ b/compiler/test_mono/generated/dict.txt @@ -1,13 +1,13 @@ procedure Dict.2 (): - let Test.4 : Builtin(Dict(Union(NonRecursive([])), Union(NonRecursive([])))) = lowlevel DictEmpty ; + let Test.4 : Dict [] [] = lowlevel DictEmpty ; ret Test.4; 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; ret Test.3; procedure Test.0 (): - let Test.2 : Builtin(Dict(Union(NonRecursive([])), Union(NonRecursive([])))) = CallByName Dict.2; - let Test.1 : Builtin(Int(U64)) = CallByName Dict.8 Test.2; + let Test.2 : Dict [] [] = CallByName Dict.2; + let Test.1 : U64 = CallByName Dict.8 Test.2; ret Test.1; diff --git a/compiler/test_mono/generated/empty_list_of_function_type.txt b/compiler/test_mono/generated/empty_list_of_function_type.txt index 44c1c42994..d25fa169f9 100644 --- a/compiler/test_mono/generated/empty_list_of_function_type.txt +++ b/compiler/test_mono/generated/empty_list_of_function_type.txt @@ -1,42 +1,42 @@ procedure List.3 (#Attr.2, #Attr.3): - let Test.20 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; - let Test.17 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.20; + let Test.20 : U64 = lowlevel ListLen #Attr.2; + let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.20; if Test.17 then - let Test.19 : LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) }) = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.18 : Union(NonRecursive([[Struct([])], [LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) })]])) = Ok Test.19; + let Test.19 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.18 : [C {}, C {}] = Ok Test.19; ret Test.18; else - let Test.16 : Struct([]) = Struct {}; - let Test.15 : Union(NonRecursive([[Struct([])], [LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) })]])) = Err Test.16; + let Test.16 : {} = Struct {}; + let Test.15 : [C {}, C {}] = Err Test.16; ret Test.15; procedure Test.2 (Test.6): - let Test.24 : Builtin(Str) = "bar"; + let Test.24 : Str = "bar"; ret Test.24; procedure Test.0 (): joinpoint Test.22 Test.3: - let Test.14 : Builtin(Int(U64)) = 0i64; - let Test.7 : Union(NonRecursive([[Struct([])], [LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) })]])) = CallByName List.3 Test.3 Test.14; + let Test.14 : U64 = 0i64; + let Test.7 : [C {}, C {}] = CallByName List.3 Test.3 Test.14; dec Test.3; - let Test.11 : Builtin(Int(U8)) = 1i64; - let Test.12 : Builtin(Int(U8)) = GetTagId Test.7; - let Test.13 : Builtin(Bool) = lowlevel Eq Test.11 Test.12; + let Test.11 : U8 = 1i64; + let Test.12 : U8 = GetTagId Test.7; + let Test.13 : Int1 = lowlevel Eq Test.11 Test.12; if Test.13 then - let Test.5 : LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) }) = UnionAtIndex (Id 1) (Index 0) Test.7; - let Test.9 : Builtin(Str) = "foo"; - let Test.8 : Builtin(Str) = CallByName Test.2 Test.9; + let Test.5 : {} = UnionAtIndex (Id 1) (Index 0) Test.7; + let Test.9 : Str = "foo"; + let Test.8 : Str = CallByName Test.2 Test.9; dec Test.9; ret Test.8; else - let Test.10 : Builtin(Str) = "bad!"; + let Test.10 : Str = "bad!"; ret Test.10; in - let Test.25 : Builtin(Bool) = false; + let Test.25 : Int1 = false; 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; else - let Test.23 : LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) }) = Struct {}; - let Test.21 : Builtin(List(LambdaSet(LambdaSet { set: [( Test.2, [])], representation: Struct([]) }))) = Array [Test.23]; + let Test.23 : {} = Struct {}; + let Test.21 : List {} = Array [Test.23]; jump Test.22 Test.21; diff --git a/compiler/test_mono/generated/factorial.txt b/compiler/test_mono/generated/factorial.txt index d0c12615da..f318bd7aa3 100644 --- a/compiler/test_mono/generated/factorial.txt +++ b/compiler/test_mono/generated/factorial.txt @@ -1,27 +1,27 @@ 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; 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; procedure Test.1 (Test.17, Test.18): joinpoint Test.7 Test.2 Test.3: - let Test.15 : Builtin(Int(I64)) = 0i64; - let Test.16 : Builtin(Bool) = lowlevel Eq Test.15 Test.2; + let Test.15 : I64 = 0i64; + let Test.16 : Int1 = lowlevel Eq Test.15 Test.2; if Test.16 then ret Test.3; else - let Test.13 : Builtin(Int(I64)) = 1i64; - let Test.10 : Builtin(Int(I64)) = CallByName Num.23 Test.2 Test.13; - let Test.11 : Builtin(Int(I64)) = CallByName Num.24 Test.2 Test.3; + let Test.13 : I64 = 1i64; + let Test.10 : I64 = CallByName Num.23 Test.2 Test.13; + let Test.11 : I64 = CallByName Num.24 Test.2 Test.3; jump Test.7 Test.10 Test.11; in jump Test.7 Test.17 Test.18; procedure Test.0 (): - let Test.5 : Builtin(Int(I64)) = 10i64; - let Test.6 : Builtin(Int(I64)) = 1i64; - let Test.4 : Builtin(Int(I64)) = CallByName Test.1 Test.5 Test.6; + let Test.5 : I64 = 10i64; + let Test.6 : I64 = 1i64; + let Test.4 : I64 = CallByName Test.1 Test.5 Test.6; ret Test.4; diff --git a/compiler/test_mono/generated/fst.txt b/compiler/test_mono/generated/fst.txt index f85b59b85b..c8c3da9a89 100644 --- a/compiler/test_mono/generated/fst.txt +++ b/compiler/test_mono/generated/fst.txt @@ -3,9 +3,9 @@ procedure Test.1 (Test.2, Test.3): ret Test.2; procedure Test.0 (): - let Test.5 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; - let Test.6 : Builtin(List(Builtin(Int(I64)))) = Array [3i64, 2i64, 1i64]; - let Test.4 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.5 Test.6; + let Test.5 : List I64 = Array [1i64, 2i64, 3i64]; + let Test.6 : List I64 = Array [3i64, 2i64, 1i64]; + let Test.4 : List I64 = CallByName Test.1 Test.5 Test.6; dec Test.6; dec Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/guard_pattern_true.txt b/compiler/test_mono/generated/guard_pattern_true.txt index b93ad5f177..47bfc64e1f 100644 --- a/compiler/test_mono/generated/guard_pattern_true.txt +++ b/compiler/test_mono/generated/guard_pattern_true.txt @@ -1,25 +1,25 @@ procedure Test.1 (Test.3): - let Test.6 : Builtin(Int(I64)) = 2i64; + let Test.6 : I64 = 2i64; joinpoint Test.11: - let Test.10 : Builtin(Int(I64)) = 0i64; + let Test.10 : I64 = 0i64; ret Test.10; in - let Test.13 : Builtin(Int(I64)) = 2i64; - let Test.14 : Builtin(Bool) = lowlevel Eq Test.13 Test.6; + let Test.13 : I64 = 2i64; + let Test.14 : Int1 = lowlevel Eq Test.13 Test.6; if Test.14 then joinpoint Test.8 Test.12: if Test.12 then - let Test.7 : Builtin(Int(I64)) = 42i64; + let Test.7 : I64 = 42i64; ret Test.7; else jump Test.11; in - let Test.9 : Builtin(Bool) = false; + let Test.9 : Int1 = false; jump Test.8 Test.9; else jump Test.11; procedure Test.0 (): - let Test.5 : Struct([]) = Struct {}; - let Test.4 : Builtin(Int(I64)) = CallByName Test.1 Test.5; + let Test.5 : {} = Struct {}; + let Test.4 : I64 = CallByName Test.1 Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/has_none.txt b/compiler/test_mono/generated/has_none.txt index b97fc22ad0..5cd44fc90f 100644 --- a/compiler/test_mono/generated/has_none.txt +++ b/compiler/test_mono/generated/has_none.txt @@ -1,30 +1,30 @@ procedure Test.3 (Test.29): joinpoint Test.13 Test.4: - let Test.23 : Builtin(Bool) = 1i64; - let Test.24 : Builtin(Bool) = GetTagId Test.4; - let Test.25 : Builtin(Bool) = lowlevel Eq Test.23 Test.24; + let Test.23 : Int1 = 1i64; + let Test.24 : Int1 = GetTagId Test.4; + let Test.25 : Int1 = lowlevel Eq Test.23 Test.24; if Test.25 then - let Test.14 : Builtin(Bool) = false; + let Test.14 : Int1 = false; ret Test.14; else - let Test.19 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.4; - let Test.20 : Builtin(Int(U8)) = 1i64; - let Test.21 : Builtin(Int(U8)) = GetTagId Test.19; - let Test.22 : Builtin(Bool) = lowlevel Eq Test.20 Test.21; + let Test.19 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.4; + let Test.20 : U8 = 1i64; + let Test.21 : U8 = GetTagId Test.19; + let Test.22 : Int1 = lowlevel Eq Test.20 Test.21; if Test.22 then - let Test.15 : Builtin(Bool) = true; + let Test.15 : Int1 = true; ret Test.15; 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; in jump Test.13 Test.29; procedure Test.0 (): - let Test.28 : Builtin(Int(I64)) = 3i64; - let Test.26 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.28; - let Test.27 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Union(NonRecursive([[Builtin(Int(I64))], []])), RecursivePointer] }) = Nil ; - let Test.12 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Union(NonRecursive([[Builtin(Int(I64))], []])), RecursivePointer] }) = Cons Test.26 Test.27; - let Test.11 : Builtin(Bool) = CallByName Test.3 Test.12; + let Test.28 : I64 = 3i64; + let Test.26 : [C I64, C ] = Just Test.28; + let Test.27 : TODO = Nil ; + let Test.12 : TODO = Cons Test.26 Test.27; + let Test.11 : Int1 = CallByName Test.3 Test.12; dec Test.12; ret Test.11; diff --git a/compiler/test_mono/generated/if_guard_bind_variable_false.txt b/compiler/test_mono/generated/if_guard_bind_variable_false.txt index d5a0da7ccc..abd10f26af 100644 --- a/compiler/test_mono/generated/if_guard_bind_variable_false.txt +++ b/compiler/test_mono/generated/if_guard_bind_variable_false.txt @@ -1,22 +1,22 @@ 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; procedure Test.1 (Test.3): - let Test.6 : Builtin(Int(I64)) = 10i64; + let Test.6 : I64 = 10i64; joinpoint Test.8 Test.13: if Test.13 then - let Test.7 : Builtin(Int(I64)) = 0i64; + let Test.7 : I64 = 0i64; ret Test.7; else - let Test.12 : Builtin(Int(I64)) = 42i64; + let Test.12 : I64 = 42i64; ret Test.12; in - let Test.10 : Builtin(Int(I64)) = 5i64; - let Test.9 : Builtin(Bool) = CallByName Bool.7 Test.6 Test.10; + let Test.10 : I64 = 5i64; + let Test.9 : Int1 = CallByName Bool.7 Test.6 Test.10; jump Test.8 Test.9; procedure Test.0 (): - let Test.5 : Struct([]) = Struct {}; - let Test.4 : Builtin(Int(I64)) = CallByName Test.1 Test.5; + let Test.5 : {} = Struct {}; + let Test.4 : I64 = CallByName Test.1 Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/if_multi_branch.txt b/compiler/test_mono/generated/if_multi_branch.txt index 778549a457..6178c6a0db 100644 --- a/compiler/test_mono/generated/if_multi_branch.txt +++ b/compiler/test_mono/generated/if_multi_branch.txt @@ -1,13 +1,13 @@ procedure Test.0 (): - let Test.6 : Builtin(Bool) = true; + let Test.6 : Int1 = true; if Test.6 then - let Test.7 : Builtin(Int(I64)) = 1i64; + let Test.7 : I64 = 1i64; ret Test.7; else - let Test.4 : Builtin(Bool) = false; + let Test.4 : Int1 = false; if Test.4 then - let Test.5 : Builtin(Int(I64)) = 2i64; + let Test.5 : I64 = 2i64; ret Test.5; else - let Test.3 : Builtin(Int(I64)) = 3i64; + let Test.3 : I64 = 3i64; ret Test.3; diff --git a/compiler/test_mono/generated/ir_assignment.txt b/compiler/test_mono/generated/ir_assignment.txt index ff5f614740..47e452bf72 100644 --- a/compiler/test_mono/generated/ir_assignment.txt +++ b/compiler/test_mono/generated/ir_assignment.txt @@ -1,3 +1,3 @@ procedure Test.0 (): - let Test.1 : Builtin(Int(I64)) = 5i64; + let Test.1 : I64 = 5i64; ret Test.1; diff --git a/compiler/test_mono/generated/ir_int_add.txt b/compiler/test_mono/generated/ir_int_add.txt index e4ef7ac607..bee729da6d 100644 --- a/compiler/test_mono/generated/ir_int_add.txt +++ b/compiler/test_mono/generated/ir_int_add.txt @@ -1,19 +1,19 @@ 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; 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; procedure Test.0 (): - let Test.10 : Builtin(Int(U64)) = 5i64; - let Test.11 : Builtin(Int(U64)) = 4i64; - let Test.8 : Builtin(Int(U64)) = CallByName Num.22 Test.10 Test.11; - let Test.9 : Builtin(Int(U64)) = 3i64; - let Test.3 : Builtin(Int(U64)) = CallByName Num.22 Test.8 Test.9; - let Test.6 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64]; - let Test.4 : Builtin(Int(U64)) = CallByName List.7 Test.6; + let Test.10 : U64 = 5i64; + let Test.11 : U64 = 4i64; + let Test.8 : U64 = CallByName Num.22 Test.10 Test.11; + let Test.9 : U64 = 3i64; + let Test.3 : U64 = CallByName Num.22 Test.8 Test.9; + let Test.6 : List I64 = Array [1i64, 2i64]; + let Test.4 : U64 = CallByName List.7 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; diff --git a/compiler/test_mono/generated/ir_int_literal.txt b/compiler/test_mono/generated/ir_int_literal.txt index ff5f614740..47e452bf72 100644 --- a/compiler/test_mono/generated/ir_int_literal.txt +++ b/compiler/test_mono/generated/ir_int_literal.txt @@ -1,3 +1,3 @@ procedure Test.0 (): - let Test.1 : Builtin(Int(I64)) = 5i64; + let Test.1 : I64 = 5i64; ret Test.1; diff --git a/compiler/test_mono/generated/ir_plus.txt b/compiler/test_mono/generated/ir_plus.txt index b0c0e1a060..3bcafd0029 100644 --- a/compiler/test_mono/generated/ir_plus.txt +++ b/compiler/test_mono/generated/ir_plus.txt @@ -1,9 +1,9 @@ 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; procedure Test.0 (): - let Test.2 : Builtin(Int(I64)) = 1i64; - let Test.3 : Builtin(Int(I64)) = 2i64; - let Test.1 : Builtin(Int(I64)) = CallByName Num.22 Test.2 Test.3; + let Test.2 : I64 = 1i64; + let Test.3 : I64 = 2i64; + let Test.1 : I64 = CallByName Num.22 Test.2 Test.3; ret Test.1; diff --git a/compiler/test_mono/generated/ir_round.txt b/compiler/test_mono/generated/ir_round.txt index 7f16bbcd71..a62c2c4a09 100644 --- a/compiler/test_mono/generated/ir_round.txt +++ b/compiler/test_mono/generated/ir_round.txt @@ -1,8 +1,8 @@ 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; procedure Test.0 (): - let Test.2 : Builtin(Float(F64)) = 3.6f64; - let Test.1 : Builtin(Int(I64)) = CallByName Num.45 Test.2; + let Test.2 : Float64 = 3.6f64; + let Test.1 : I64 = CallByName Num.45 Test.2; ret Test.1; diff --git a/compiler/test_mono/generated/ir_two_defs.txt b/compiler/test_mono/generated/ir_two_defs.txt index b39fc79319..39d09c2318 100644 --- a/compiler/test_mono/generated/ir_two_defs.txt +++ b/compiler/test_mono/generated/ir_two_defs.txt @@ -1,9 +1,9 @@ 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; procedure Test.0 (): - let Test.4 : Builtin(Int(I64)) = 3i64; - let Test.5 : Builtin(Int(I64)) = 4i64; - let Test.3 : Builtin(Int(I64)) = CallByName Num.22 Test.4 Test.5; + let Test.4 : I64 = 3i64; + let Test.5 : I64 = 4i64; + let Test.3 : I64 = CallByName Num.22 Test.4 Test.5; ret Test.3; diff --git a/compiler/test_mono/generated/ir_when_idiv.txt b/compiler/test_mono/generated/ir_when_idiv.txt index 6b60e0547c..999d7f762e 100644 --- a/compiler/test_mono/generated/ir_when_idiv.txt +++ b/compiler/test_mono/generated/ir_when_idiv.txt @@ -1,25 +1,25 @@ procedure Num.40 (#Attr.2, #Attr.3): - let Test.15 : Builtin(Int(I64)) = 0i64; - let Test.12 : Builtin(Bool) = lowlevel NotEq #Attr.3 Test.15; + let Test.15 : I64 = 0i64; + let Test.12 : Int1 = lowlevel NotEq #Attr.3 Test.15; if Test.12 then - let Test.14 : Builtin(Int(I64)) = lowlevel NumDivUnchecked #Attr.2 #Attr.3; - let Test.13 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Ok Test.14; + let Test.14 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3; + let Test.13 : [C {}, C I64] = Ok Test.14; ret Test.13; else - let Test.11 : Struct([]) = Struct {}; - let Test.10 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Err Test.11; + let Test.11 : {} = Struct {}; + let Test.10 : [C {}, C I64] = Err Test.11; ret Test.10; procedure Test.0 (): - let Test.8 : Builtin(Int(I64)) = 1000i64; - let Test.9 : Builtin(Int(I64)) = 10i64; - let Test.2 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName Num.40 Test.8 Test.9; - let Test.5 : Builtin(Int(U8)) = 1i64; - let Test.6 : Builtin(Int(U8)) = GetTagId Test.2; - let Test.7 : Builtin(Bool) = lowlevel Eq Test.5 Test.6; + let Test.8 : I64 = 1000i64; + let Test.9 : I64 = 10i64; + let Test.2 : [C {}, C I64] = CallByName Num.40 Test.8 Test.9; + let Test.5 : U8 = 1i64; + let Test.6 : U8 = GetTagId Test.2; + let Test.7 : Int1 = lowlevel Eq Test.5 Test.6; 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; else - let Test.4 : Builtin(Int(I64)) = -1i64; + let Test.4 : I64 = -1i64; ret Test.4; diff --git a/compiler/test_mono/generated/ir_when_just.txt b/compiler/test_mono/generated/ir_when_just.txt index a2ab04d249..c3e60612d4 100644 --- a/compiler/test_mono/generated/ir_when_just.txt +++ b/compiler/test_mono/generated/ir_when_just.txt @@ -1,18 +1,18 @@ 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; procedure Test.0 (): - let Test.11 : Builtin(Int(I64)) = 41i64; - let Test.1 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.11; - let Test.8 : Builtin(Int(U8)) = 0i64; - let Test.9 : Builtin(Int(U8)) = GetTagId Test.1; - let Test.10 : Builtin(Bool) = lowlevel Eq Test.8 Test.9; + let Test.11 : I64 = 41i64; + let Test.1 : [C I64, C ] = Just Test.11; + let Test.8 : U8 = 0i64; + let Test.9 : U8 = GetTagId Test.1; + let Test.10 : Int1 = lowlevel Eq Test.8 Test.9; if Test.10 then - let Test.3 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) Test.1; - let Test.5 : Builtin(Int(I64)) = 1i64; - let Test.4 : Builtin(Int(I64)) = CallByName Num.22 Test.3 Test.5; + let Test.3 : I64 = UnionAtIndex (Id 0) (Index 0) Test.1; + let Test.5 : I64 = 1i64; + let Test.4 : I64 = CallByName Num.22 Test.3 Test.5; ret Test.4; else - let Test.7 : Builtin(Int(I64)) = 1i64; + let Test.7 : I64 = 1i64; ret Test.7; diff --git a/compiler/test_mono/generated/ir_when_maybe.txt b/compiler/test_mono/generated/ir_when_maybe.txt index 348604c968..e5a573c182 100644 --- a/compiler/test_mono/generated/ir_when_maybe.txt +++ b/compiler/test_mono/generated/ir_when_maybe.txt @@ -1,12 +1,12 @@ procedure Test.0 (): - let Test.9 : Builtin(Int(I64)) = 3i64; - let Test.3 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.9; - let Test.6 : Builtin(Int(U8)) = 0i64; - let Test.7 : Builtin(Int(U8)) = GetTagId Test.3; - let Test.8 : Builtin(Bool) = lowlevel Eq Test.6 Test.7; + let Test.9 : I64 = 3i64; + let Test.3 : [C I64, C ] = Just Test.9; + let Test.6 : U8 = 0i64; + let Test.7 : U8 = GetTagId Test.3; + let Test.8 : Int1 = lowlevel Eq Test.6 Test.7; 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; else - let Test.5 : Builtin(Int(I64)) = 0i64; + let Test.5 : I64 = 0i64; ret Test.5; diff --git a/compiler/test_mono/generated/ir_when_record.txt b/compiler/test_mono/generated/ir_when_record.txt index b9e3ef94fc..bbac521770 100644 --- a/compiler/test_mono/generated/ir_when_record.txt +++ b/compiler/test_mono/generated/ir_when_record.txt @@ -1,6 +1,6 @@ procedure Test.0 (): - let Test.4 : Builtin(Int(I64)) = 1i64; - let Test.5 : Builtin(Float(F64)) = 3.14f64; - let Test.2 : Struct([Builtin(Int(I64)), Builtin(Float(F64))]) = Struct {Test.4, Test.5}; - let Test.1 : Builtin(Int(I64)) = StructAtIndex 0 Test.2; + let Test.4 : I64 = 1i64; + let Test.5 : Float64 = 3.14f64; + let Test.2 : {I64, Float64} = Struct {Test.4, Test.5}; + let Test.1 : I64 = StructAtIndex 0 Test.2; ret Test.1; diff --git a/compiler/test_mono/generated/ir_when_these.txt b/compiler/test_mono/generated/ir_when_these.txt index 08c3614351..0c7453e2b7 100644 --- a/compiler/test_mono/generated/ir_when_these.txt +++ b/compiler/test_mono/generated/ir_when_these.txt @@ -1,18 +1,18 @@ procedure Test.0 (): - let Test.10 : Builtin(Int(I64)) = 1i64; - let Test.11 : Builtin(Int(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.9 : Builtin(Int(U8)) = GetTagId Test.5; + let Test.10 : I64 = 1i64; + let Test.11 : I64 = 2i64; + let Test.5 : [C I64, C I64 I64, C I64] = These Test.10 Test.11; + let Test.9 : U8 = GetTagId Test.5; switch Test.9: 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; 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; 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; diff --git a/compiler/test_mono/generated/is_nil.txt b/compiler/test_mono/generated/is_nil.txt index 5968c5178c..72af4853cd 100644 --- a/compiler/test_mono/generated/is_nil.txt +++ b/compiler/test_mono/generated/is_nil.txt @@ -1,18 +1,18 @@ procedure Test.2 (Test.3): - let Test.12 : Builtin(Bool) = 1i64; - let Test.13 : Builtin(Bool) = GetTagId Test.3; - let Test.14 : Builtin(Bool) = lowlevel Eq Test.12 Test.13; + let Test.12 : Int1 = 1i64; + let Test.13 : Int1 = GetTagId Test.3; + let Test.14 : Int1 = lowlevel Eq Test.12 Test.13; if Test.14 then - let Test.10 : Builtin(Bool) = true; + let Test.10 : Int1 = true; ret Test.10; else - let Test.11 : Builtin(Bool) = false; + let Test.11 : Int1 = false; ret Test.11; procedure Test.0 (): - let Test.15 : Builtin(Int(I64)) = 2i64; - let Test.16 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Builtin(Int(I64)), RecursivePointer] }) = Nil ; - let Test.9 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Builtin(Int(I64)), RecursivePointer] }) = Cons Test.15 Test.16; - let Test.8 : Builtin(Bool) = CallByName Test.2 Test.9; + let Test.15 : I64 = 2i64; + let Test.16 : TODO = Nil ; + let Test.9 : TODO = Cons Test.15 Test.16; + let Test.8 : Int1 = CallByName Test.2 Test.9; dec Test.9; ret Test.8; diff --git a/compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt b/compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt index a30515bee8..0b14e41d86 100644 --- a/compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt +++ b/compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt @@ -1,19 +1,19 @@ procedure Test.1 (): - let Test.11 : Builtin(Int(I64)) = 2i64; - let Test.12 : Builtin(Int(U8)) = 1i64; - let Test.10 : Struct { field_order_hash: 4700212371939112988, field_layouts: [Builtin(Int(I64)), Builtin(Int(U8))] } = Struct {Test.11, Test.12}; + 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 : Builtin(Int(I64)) = 1i64; - let Test.8 : Builtin(Int(U8)) = 2i64; - let Test.6 : Struct { field_order_hash: 17343052842552570643, field_layouts: [Builtin(Int(I64)), Builtin(Int(U8))] } = Struct {Test.7, Test.8}; + 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 : Struct { field_order_hash: 4700212371939112988, field_layouts: [Builtin(Int(I64)), Builtin(Int(U8))] } = CallByName Test.1; - let Test.3 : Builtin(Int(U8)) = StructAtIndex 1 Test.9; - let Test.5 : Struct { field_order_hash: 17343052842552570643, field_layouts: [Builtin(Int(I64)), Builtin(Int(U8))] } = CallByName Test.1; - let Test.4 : Builtin(Int(U8)) = StructAtIndex 1 Test.5; - let Test.2 : Builtin(List(Builtin(Int(U8)))) = Array [Test.3, Test.4]; + 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; diff --git a/compiler/test_mono/generated/let_with_record_pattern.txt b/compiler/test_mono/generated/let_with_record_pattern.txt index 302c1de690..58abbb1866 100644 --- a/compiler/test_mono/generated/let_with_record_pattern.txt +++ b/compiler/test_mono/generated/let_with_record_pattern.txt @@ -1,6 +1,6 @@ procedure Test.0 (): - let Test.4 : Builtin(Int(I64)) = 2i64; - let Test.5 : Builtin(Float(F64)) = 3.14f64; - let Test.3 : Struct([Builtin(Int(I64)), Builtin(Float(F64))]) = Struct {Test.4, Test.5}; - let Test.1 : Builtin(Int(I64)) = StructAtIndex 0 Test.3; + let Test.4 : I64 = 2i64; + let Test.5 : Float64 = 3.14f64; + let Test.3 : {I64, Float64} = Struct {Test.4, Test.5}; + let Test.1 : I64 = StructAtIndex 0 Test.3; ret Test.1; diff --git a/compiler/test_mono/generated/let_with_record_pattern_list.txt b/compiler/test_mono/generated/let_with_record_pattern_list.txt index 1c22f23866..9475864c6c 100644 --- a/compiler/test_mono/generated/let_with_record_pattern_list.txt +++ b/compiler/test_mono/generated/let_with_record_pattern_list.txt @@ -1,8 +1,8 @@ procedure Test.0 (): - let Test.4 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 3i64, 4i64]; - let Test.5 : Builtin(Float(F64)) = 3.14f64; - let Test.3 : Struct([Builtin(List(Builtin(Int(I64)))), Builtin(Float(F64))]) = Struct {Test.4, Test.5}; - let Test.1 : Builtin(List(Builtin(Int(I64)))) = StructAtIndex 0 Test.3; + let Test.4 : List I64 = Array [1i64, 3i64, 4i64]; + let Test.5 : Float64 = 3.14f64; + let Test.3 : {List I64, Float64} = Struct {Test.4, Test.5}; + let Test.1 : List I64 = StructAtIndex 0 Test.3; inc Test.1; dec Test.3; ret Test.1; diff --git a/compiler/test_mono/generated/let_x_in_x.txt b/compiler/test_mono/generated/let_x_in_x.txt index 1ae2b5dd47..72af22119a 100644 --- a/compiler/test_mono/generated/let_x_in_x.txt +++ b/compiler/test_mono/generated/let_x_in_x.txt @@ -1,3 +1,3 @@ procedure Test.0 (): - let Test.2 : Builtin(Int(I64)) = 1337i64; + let Test.2 : I64 = 1337i64; ret Test.2; diff --git a/compiler/test_mono/generated/let_x_in_x_indirect.txt b/compiler/test_mono/generated/let_x_in_x_indirect.txt index 8897207353..6215e7f0af 100644 --- a/compiler/test_mono/generated/let_x_in_x_indirect.txt +++ b/compiler/test_mono/generated/let_x_in_x_indirect.txt @@ -1,6 +1,6 @@ procedure Test.0 (): - let Test.2 : Builtin(Int(I64)) = 1337i64; - let Test.3 : Builtin(Int(I64)) = 17i64; - let Test.7 : Struct([Builtin(Int(I64)), Builtin(Int(I64))]) = Struct {Test.2, Test.3}; - let Test.6 : Builtin(Int(I64)) = StructAtIndex 0 Test.7; + let Test.2 : I64 = 1337i64; + let Test.3 : I64 = 17i64; + let Test.7 : {I64, I64} = Struct {Test.2, Test.3}; + let Test.6 : I64 = StructAtIndex 0 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/linked_list_length_twice.txt b/compiler/test_mono/generated/linked_list_length_twice.txt index c791ad1cd4..3b1d0984f3 100644 --- a/compiler/test_mono/generated/linked_list_length_twice.txt +++ b/compiler/test_mono/generated/linked_list_length_twice.txt @@ -1,25 +1,25 @@ 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; procedure Test.3 (Test.5): - let Test.16 : Builtin(Bool) = 1i64; - let Test.17 : Builtin(Bool) = GetTagId Test.5; - let Test.18 : Builtin(Bool) = lowlevel Eq Test.16 Test.17; + let Test.16 : Int1 = 1i64; + let Test.17 : Int1 = GetTagId Test.5; + let Test.18 : Int1 = lowlevel Eq Test.16 Test.17; if Test.18 then - let Test.12 : Builtin(Int(I64)) = 0i64; + let Test.12 : I64 = 0i64; ret Test.12; else - let Test.6 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Builtin(Int(I64)), RecursivePointer] }) = UnionAtIndex (Id 0) (Index 1) Test.5; - let Test.14 : Builtin(Int(I64)) = 1i64; - let Test.15 : Builtin(Int(I64)) = CallByName Test.3 Test.6; - let Test.13 : Builtin(Int(I64)) = CallByName Num.22 Test.14 Test.15; + let Test.6 : TODO = UnionAtIndex (Id 0) (Index 1) Test.5; + let Test.14 : I64 = 1i64; + let Test.15 : I64 = CallByName Test.3 Test.6; + let Test.13 : I64 = CallByName Num.22 Test.14 Test.15; ret Test.13; procedure Test.0 (): - let Test.2 : Union(NullableUnwrapped { nullable_id: true, other_fields: [Builtin(Int(I64)), RecursivePointer] }) = Nil ; - let Test.8 : Builtin(Int(I64)) = CallByName Test.3 Test.2; - let Test.9 : Builtin(Int(I64)) = CallByName Test.3 Test.2; + let Test.2 : TODO = Nil ; + let Test.8 : I64 = CallByName Test.3 Test.2; + let Test.9 : I64 = CallByName Test.3 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; diff --git a/compiler/test_mono/generated/list_append.txt b/compiler/test_mono/generated/list_append.txt index 2b0be9dd16..c899f2abd7 100644 --- a/compiler/test_mono/generated/list_append.txt +++ b/compiler/test_mono/generated/list_append.txt @@ -1,9 +1,9 @@ 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; procedure Test.0 (): - let Test.2 : Builtin(List(Builtin(Int(I64)))) = Array [1i64]; - let Test.3 : Builtin(Int(I64)) = 2i64; - let Test.1 : Builtin(List(Builtin(Int(I64)))) = CallByName List.5 Test.2 Test.3; + let Test.2 : List I64 = Array [1i64]; + let Test.3 : I64 = 2i64; + let Test.1 : List I64 = CallByName List.5 Test.2 Test.3; ret Test.1; diff --git a/compiler/test_mono/generated/list_append_closure.txt b/compiler/test_mono/generated/list_append_closure.txt index 3cd9bffd51..43227f7089 100644 --- a/compiler/test_mono/generated/list_append_closure.txt +++ b/compiler/test_mono/generated/list_append_closure.txt @@ -1,13 +1,13 @@ 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; procedure Test.1 (Test.2): - let Test.6 : Builtin(Int(I64)) = 42i64; - let Test.5 : Builtin(List(Builtin(Int(I64)))) = CallByName List.5 Test.2 Test.6; + let Test.6 : I64 = 42i64; + let Test.5 : List I64 = CallByName List.5 Test.2 Test.6; ret Test.5; procedure Test.0 (): - let Test.4 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64]; - let Test.3 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.4; + let Test.4 : List I64 = Array [1i64, 2i64]; + let Test.3 : List I64 = CallByName Test.1 Test.4; ret Test.3; diff --git a/compiler/test_mono/generated/list_cannot_update_inplace.txt b/compiler/test_mono/generated/list_cannot_update_inplace.txt index c2087e2d74..08123887b1 100644 --- a/compiler/test_mono/generated/list_cannot_update_inplace.txt +++ b/compiler/test_mono/generated/list_cannot_update_inplace.txt @@ -1,37 +1,37 @@ procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.19 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; - let Test.17 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.19; + let Test.19 : U64 = lowlevel ListLen #Attr.2; + let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.19; 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; else ret #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; 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; 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; procedure Test.2 (Test.3): - let Test.14 : Builtin(Int(U64)) = 0i64; - let Test.15 : Builtin(Int(I64)) = 0i64; - let Test.13 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.3 Test.14 Test.15; + let Test.14 : U64 = 0i64; + let Test.15 : I64 = 0i64; + let Test.13 : List I64 = CallByName List.4 Test.3 Test.14 Test.15; ret Test.13; procedure Test.0 (): - let Test.12 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1; - let Test.11 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.2 Test.12; - let Test.5 : Builtin(Int(U64)) = CallByName List.7 Test.11; + let Test.12 : List I64 = CallByName Test.1; + let Test.11 : List I64 = CallByName Test.2 Test.12; + let Test.5 : U64 = CallByName List.7 Test.11; dec Test.11; - let Test.8 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1; - let Test.6 : Builtin(Int(U64)) = CallByName List.7 Test.8; + let Test.8 : List I64 = CallByName Test.1; + let Test.6 : U64 = CallByName List.7 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; diff --git a/compiler/test_mono/generated/list_get.txt b/compiler/test_mono/generated/list_get.txt index 1ea41edce5..b8d8636c97 100644 --- a/compiler/test_mono/generated/list_get.txt +++ b/compiler/test_mono/generated/list_get.txt @@ -1,23 +1,23 @@ procedure List.3 (#Attr.2, #Attr.3): - let Test.13 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; - let Test.10 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.13; + let Test.13 : U64 = lowlevel ListLen #Attr.2; + let Test.10 : Int1 = lowlevel NumLt #Attr.3 Test.13; if Test.10 then - let Test.12 : Builtin(Int(I64)) = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.11 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Ok Test.12; + let Test.12 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.11 : [C {}, C I64] = Ok Test.12; ret Test.11; else - let Test.9 : Struct([]) = Struct {}; - let Test.8 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Err Test.9; + let Test.9 : {} = Struct {}; + let Test.8 : [C {}, C I64] = Err Test.9; ret Test.8; procedure Test.1 (Test.2): - let Test.6 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; - let Test.7 : Builtin(Int(U64)) = 0i64; - let Test.5 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName List.3 Test.6 Test.7; + let Test.6 : List I64 = Array [1i64, 2i64, 3i64]; + let Test.7 : U64 = 0i64; + let Test.5 : [C {}, C I64] = CallByName List.3 Test.6 Test.7; dec Test.6; ret Test.5; procedure Test.0 (): - let Test.4 : Struct([]) = Struct {}; - let Test.3 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName Test.1 Test.4; + let Test.4 : {} = Struct {}; + let Test.3 : [C {}, C I64] = CallByName Test.1 Test.4; ret Test.3; diff --git a/compiler/test_mono/generated/list_len.txt b/compiler/test_mono/generated/list_len.txt index 80b6093747..13d10a54ce 100644 --- a/compiler/test_mono/generated/list_len.txt +++ b/compiler/test_mono/generated/list_len.txt @@ -1,21 +1,21 @@ 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; 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; 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; procedure Test.0 (): - let Test.9 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; - let Test.4 : Builtin(Int(U64)) = CallByName List.7 Test.9; + let Test.9 : List I64 = Array [1i64, 2i64, 3i64]; + let Test.4 : U64 = CallByName List.7 Test.9; dec Test.9; - let Test.7 : Builtin(List(Builtin(Float(F64)))) = Array [1f64]; - let Test.5 : Builtin(Int(U64)) = CallByName List.7 Test.7; + let Test.7 : List Float64 = Array [1f64]; + let Test.5 : U64 = CallByName List.7 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; diff --git a/compiler/test_mono/generated/list_pass_to_function.txt b/compiler/test_mono/generated/list_pass_to_function.txt index 090b5affdd..b235671dcf 100644 --- a/compiler/test_mono/generated/list_pass_to_function.txt +++ b/compiler/test_mono/generated/list_pass_to_function.txt @@ -1,19 +1,19 @@ procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.11 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; - let Test.9 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.11; + let Test.11 : U64 = lowlevel ListLen #Attr.2; + let Test.9 : Int1 = lowlevel NumLt #Attr.3 Test.11; 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; else ret #Attr.2; procedure Test.2 (Test.3): - let Test.6 : Builtin(Int(U64)) = 0i64; - let Test.7 : Builtin(Int(I64)) = 0i64; - let Test.5 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.3 Test.6 Test.7; + let Test.6 : U64 = 0i64; + let Test.7 : I64 = 0i64; + let Test.5 : List I64 = CallByName List.4 Test.3 Test.6 Test.7; ret Test.5; procedure Test.0 (): - let Test.1 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64, 3i64]; - let Test.4 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.2 Test.1; + let Test.1 : List I64 = Array [1i64, 2i64, 3i64]; + let Test.4 : List I64 = CallByName Test.2 Test.1; ret Test.4; diff --git a/compiler/test_mono/generated/mk_pair_of.txt b/compiler/test_mono/generated/mk_pair_of.txt index 98bd4b0d18..3931112c9e 100644 --- a/compiler/test_mono/generated/mk_pair_of.txt +++ b/compiler/test_mono/generated/mk_pair_of.txt @@ -1,9 +1,9 @@ procedure Test.1 (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; procedure Test.0 (): - let Test.5 : Builtin(List(Builtin(Int(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.5 : List I64 = Array [1i64, 2i64, 3i64]; + let Test.4 : {List I64, List I64} = CallByName Test.1 Test.5; ret Test.4; diff --git a/compiler/test_mono/generated/monomorphized_applied_tag.txt b/compiler/test_mono/generated/monomorphized_applied_tag.txt index 90dd27c931..4e672c7597 100644 --- a/compiler/test_mono/generated/monomorphized_applied_tag.txt +++ b/compiler/test_mono/generated/monomorphized_applied_tag.txt @@ -1,20 +1,20 @@ procedure Test.2 (Test.4): - let Test.11 : Builtin(Int(U8)) = 0i64; - let Test.12 : Builtin(Int(U8)) = GetTagId Test.4; - let Test.13 : Builtin(Bool) = lowlevel Eq Test.11 Test.12; + let Test.11 : U8 = 0i64; + let Test.12 : U8 = GetTagId Test.4; + let Test.13 : Int1 = lowlevel Eq Test.11 Test.12; 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; dec Test.4; ret Test.5; 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; dec Test.4; ret Test.6; procedure Test.0 (): - let Test.14 : Builtin(Str) = "A"; - let Test.8 : Union(NonRecursive([[Builtin(Str)], [Builtin(Str)]])) = A Test.14; - let Test.7 : Builtin(Str) = CallByName Test.2 Test.8; + let Test.14 : Str = "A"; + let Test.8 : [C Str, C Str] = A Test.14; + let Test.7 : Str = CallByName Test.2 Test.8; ret Test.7; diff --git a/compiler/test_mono/generated/monomorphized_floats.txt b/compiler/test_mono/generated/monomorphized_floats.txt index 90eef8acc7..6fc9243f46 100644 --- a/compiler/test_mono/generated/monomorphized_floats.txt +++ b/compiler/test_mono/generated/monomorphized_floats.txt @@ -1,9 +1,9 @@ procedure Test.2 (Test.3, Test.4): - let Test.8 : Builtin(Int(U64)) = 18i64; + let Test.8 : U64 = 18i64; ret Test.8; procedure Test.0 (): - let Test.6 : Builtin(Float(F32)) = 100f64; - let Test.7 : Builtin(Float(F64)) = 100f64; - let Test.5 : Builtin(Int(U64)) = CallByName Test.2 Test.6 Test.7; + let Test.6 : Float32 = 100f64; + let Test.7 : Float64 = 100f64; + let Test.5 : U64 = CallByName Test.2 Test.6 Test.7; ret Test.5; diff --git a/compiler/test_mono/generated/monomorphized_ints.txt b/compiler/test_mono/generated/monomorphized_ints.txt index 5ffdd51f13..408f1ff44b 100644 --- a/compiler/test_mono/generated/monomorphized_ints.txt +++ b/compiler/test_mono/generated/monomorphized_ints.txt @@ -1,9 +1,9 @@ procedure Test.2 (Test.3, Test.4): - let Test.8 : Builtin(Int(U64)) = 18i64; + let Test.8 : U64 = 18i64; ret Test.8; procedure Test.0 (): - let Test.6 : Builtin(Int(U8)) = 100i64; - let Test.7 : Builtin(Int(U32)) = 100i64; - let Test.5 : Builtin(Int(U64)) = CallByName Test.2 Test.6 Test.7; + let Test.6 : U8 = 100i64; + let Test.7 : U32 = 100i64; + let Test.5 : U64 = CallByName Test.2 Test.6 Test.7; ret Test.5; diff --git a/compiler/test_mono/generated/monomorphized_ints_aliased.txt b/compiler/test_mono/generated/monomorphized_ints_aliased.txt index 50bd650f9d..c55c6b4f07 100644 --- a/compiler/test_mono/generated/monomorphized_ints_aliased.txt +++ b/compiler/test_mono/generated/monomorphized_ints_aliased.txt @@ -1,23 +1,23 @@ 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; procedure Test.4 (Test.7, Test.8): - let Test.17 : Builtin(Int(U64)) = 1i64; + let Test.17 : U64 = 1i64; ret Test.17; procedure Test.4 (Test.7, Test.8): - let Test.18 : Builtin(Int(U64)) = 1i64; + let Test.18 : U64 = 1i64; ret Test.18; procedure Test.0 (): - let Test.4 : LambdaSet(LambdaSet { set: [( Test.4, [])], representation: Struct([]) }) = Struct {}; - let Test.4 : LambdaSet(LambdaSet { set: [( Test.4, [])], representation: Struct([]) }) = Struct {}; - let Test.15 : Builtin(Int(U8)) = 100i64; - let Test.16 : Builtin(Int(U32)) = 100i64; - let Test.10 : Builtin(Int(U64)) = CallByName Test.4 Test.15 Test.16; - let Test.13 : Builtin(Int(U32)) = 100i64; - let Test.14 : Builtin(Int(U8)) = 100i64; - let Test.11 : Builtin(Int(U64)) = CallByName Test.4 Test.13 Test.14; - let Test.9 : Builtin(Int(U64)) = CallByName Num.22 Test.10 Test.11; + let Test.4 : {} = Struct {}; + let Test.4 : {} = Struct {}; + let Test.15 : U8 = 100i64; + let Test.16 : U32 = 100i64; + let Test.10 : U64 = CallByName Test.4 Test.15 Test.16; + let Test.13 : U32 = 100i64; + let Test.14 : U8 = 100i64; + let Test.11 : U64 = CallByName Test.4 Test.13 Test.14; + let Test.9 : U64 = CallByName Num.22 Test.10 Test.11; ret Test.9; diff --git a/compiler/test_mono/generated/monomorphized_list.txt b/compiler/test_mono/generated/monomorphized_list.txt index d38a0682ff..813339d654 100644 --- a/compiler/test_mono/generated/monomorphized_list.txt +++ b/compiler/test_mono/generated/monomorphized_list.txt @@ -1,11 +1,11 @@ procedure Test.2 (Test.3, Test.4): - let Test.8 : Builtin(Int(U64)) = 18i64; + let Test.8 : U64 = 18i64; ret Test.8; procedure Test.0 (): - let Test.6 : Builtin(List(Builtin(Int(U8)))) = Array [1i64, 2i64, 3i64]; - let Test.7 : Builtin(List(Builtin(Int(U16)))) = Array [1i64, 2i64, 3i64]; - let Test.5 : Builtin(Int(U64)) = CallByName Test.2 Test.6 Test.7; + let Test.6 : List U8 = Array [1i64, 2i64, 3i64]; + let Test.7 : List U16 = Array [1i64, 2i64, 3i64]; + let Test.5 : U64 = CallByName Test.2 Test.6 Test.7; dec Test.7; dec Test.6; ret Test.5; diff --git a/compiler/test_mono/generated/monomorphized_tag.txt b/compiler/test_mono/generated/monomorphized_tag.txt index a1cb92209d..3e2dd8f0bb 100644 --- a/compiler/test_mono/generated/monomorphized_tag.txt +++ b/compiler/test_mono/generated/monomorphized_tag.txt @@ -1,9 +1,9 @@ procedure Test.2 (Test.4, Test.5): - let Test.9 : Builtin(Int(U8)) = 18i64; + let Test.9 : U8 = 18i64; ret Test.9; procedure Test.0 (): - let Test.7 : Builtin(Bool) = false; - let Test.8 : Builtin(Int(U8)) = 0u8; - let Test.6 : Builtin(Int(U8)) = CallByName Test.2 Test.7 Test.8; + let Test.7 : Int1 = false; + let Test.8 : U8 = 0u8; + let Test.6 : U8 = CallByName Test.2 Test.7 Test.8; ret Test.6; diff --git a/compiler/test_mono/generated/monomorphized_tag_with_aliased_args.txt b/compiler/test_mono/generated/monomorphized_tag_with_aliased_args.txt index 02a88fb375..5126202c19 100644 --- a/compiler/test_mono/generated/monomorphized_tag_with_aliased_args.txt +++ b/compiler/test_mono/generated/monomorphized_tag_with_aliased_args.txt @@ -1,10 +1,10 @@ procedure Test.4 (Test.8): - let Test.11 : Builtin(Int(U64)) = 1i64; + let Test.11 : U64 = 1i64; ret Test.11; procedure Test.0 (): - let Test.13 : Builtin(Bool) = false; - let Test.12 : Builtin(Bool) = false; - let Test.10 : Struct([Builtin(Bool), Builtin(Bool)]) = Struct {Test.12, Test.13}; - let Test.9 : Builtin(Int(U64)) = CallByName Test.4 Test.10; + let Test.13 : Int1 = false; + let Test.12 : Int1 = false; + let Test.10 : {Int1, Int1} = Struct {Test.12, Test.13}; + let Test.9 : U64 = CallByName Test.4 Test.10; ret Test.9; diff --git a/compiler/test_mono/generated/nested_closure.txt b/compiler/test_mono/generated/nested_closure.txt index 9b15123922..fe4e104d86 100644 --- a/compiler/test_mono/generated/nested_closure.txt +++ b/compiler/test_mono/generated/nested_closure.txt @@ -1,16 +1,16 @@ procedure Test.1 (Test.5): - let Test.2 : Builtin(Int(I64)) = 42i64; - let Test.3 : LambdaSet(LambdaSet { set: [( Test.3, [Builtin(Int(I64))])], representation: Struct([Builtin(Int(I64))]) }) = Struct {Test.2}; + let Test.2 : I64 = 42i64; + let Test.3 : {I64} = Struct {Test.2}; ret Test.3; procedure Test.3 (Test.10, #Attr.12): - let Test.2 : Builtin(Int(I64)) = StructAtIndex 0 #Attr.12; - let Test.2 : Builtin(Int(I64)) = 42i64; + let Test.2 : I64 = StructAtIndex 0 #Attr.12; + let Test.2 : I64 = 42i64; ret Test.2; procedure Test.0 (): - let Test.7 : Struct([]) = Struct {}; - let Test.9 : Struct([]) = Struct {}; - let Test.8 : LambdaSet(LambdaSet { set: [( Test.3, [Builtin(Int(I64))])], representation: Struct([Builtin(Int(I64))]) }) = CallByName Test.1 Test.9; - let Test.6 : Builtin(Int(I64)) = CallByName Test.3 Test.7 Test.8; + let Test.7 : {} = Struct {}; + let Test.9 : {} = Struct {}; + let Test.8 : {I64} = CallByName Test.1 Test.9; + let Test.6 : I64 = CallByName Test.3 Test.7 Test.8; ret Test.6; diff --git a/compiler/test_mono/generated/nested_pattern_match.txt b/compiler/test_mono/generated/nested_pattern_match.txt index facbc46055..6bb9eebf35 100644 --- a/compiler/test_mono/generated/nested_pattern_match.txt +++ b/compiler/test_mono/generated/nested_pattern_match.txt @@ -1,28 +1,28 @@ 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; procedure Test.0 (): - let Test.20 : Builtin(Int(I64)) = 41i64; - let Test.19 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.20; - let Test.2 : Union(NonRecursive([[Union(NonRecursive([[Builtin(Int(I64))], []]))], []])) = Just Test.19; + let Test.20 : I64 = 41i64; + let Test.19 : [C I64, C ] = Just Test.20; + let Test.2 : [C [C I64, C ], C ] = Just Test.19; joinpoint Test.16: - let Test.9 : Builtin(Int(I64)) = 1i64; + let Test.9 : I64 = 1i64; ret Test.9; in - let Test.14 : Builtin(Int(U8)) = 0i64; - let Test.15 : Builtin(Int(U8)) = GetTagId Test.2; - let Test.18 : Builtin(Bool) = lowlevel Eq Test.14 Test.15; + let Test.14 : U8 = 0i64; + let Test.15 : U8 = GetTagId Test.2; + let Test.18 : Int1 = lowlevel Eq Test.14 Test.15; if Test.18 then - let Test.11 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.2; - let Test.12 : Builtin(Int(U8)) = 0i64; - let Test.13 : Builtin(Int(U8)) = GetTagId Test.11; - let Test.17 : Builtin(Bool) = lowlevel Eq Test.12 Test.13; + let Test.11 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2; + let Test.12 : U8 = 0i64; + let Test.13 : U8 = GetTagId Test.11; + let Test.17 : Int1 = lowlevel Eq Test.12 Test.13; if Test.17 then - let Test.10 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.2; - let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) Test.10; - let Test.7 : Builtin(Int(I64)) = 1i64; - let Test.6 : Builtin(Int(I64)) = CallByName Num.22 Test.5 Test.7; + let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2; + let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.10; + let Test.7 : I64 = 1i64; + let Test.6 : I64 = CallByName Num.22 Test.5 Test.7; ret Test.6; else jump Test.16; diff --git a/compiler/test_mono/generated/one_element_tag.txt b/compiler/test_mono/generated/one_element_tag.txt index 701a8080f6..1e61737429 100644 --- a/compiler/test_mono/generated/one_element_tag.txt +++ b/compiler/test_mono/generated/one_element_tag.txt @@ -1,3 +1,3 @@ procedure Test.0 (): - let Test.4 : Builtin(Int(I64)) = 2i64; + let Test.4 : I64 = 2i64; ret Test.4; diff --git a/compiler/test_mono/generated/optional_when.txt b/compiler/test_mono/generated/optional_when.txt index 1dc1fdca6b..b2649e0a96 100644 --- a/compiler/test_mono/generated/optional_when.txt +++ b/compiler/test_mono/generated/optional_when.txt @@ -1,42 +1,42 @@ 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; procedure Test.1 (Test.6): - let Test.22 : Builtin(Bool) = false; - let Test.23 : Builtin(Bool) = lowlevel Eq Test.22 Test.6; + let Test.22 : Int1 = false; + let Test.23 : Int1 = lowlevel Eq Test.22 Test.6; if Test.23 then - let Test.8 : Builtin(Int(I64)) = 3i64; + let Test.8 : I64 = 3i64; ret Test.8; else - let Test.10 : Builtin(Int(I64)) = 5i64; + let Test.10 : I64 = 5i64; ret Test.10; procedure Test.1 (Test.6): - let Test.30 : Builtin(Bool) = StructAtIndex 1 Test.6; - let Test.31 : Builtin(Bool) = false; - let Test.32 : Builtin(Bool) = lowlevel Eq Test.31 Test.30; + let Test.30 : Int1 = StructAtIndex 1 Test.6; + let Test.31 : Int1 = false; + let Test.32 : Int1 = lowlevel Eq Test.31 Test.30; 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; else - let Test.10 : Builtin(Int(I64)) = StructAtIndex 0 Test.6; + let Test.10 : I64 = StructAtIndex 0 Test.6; ret Test.10; procedure Test.0 (): - let Test.40 : Builtin(Int(I64)) = 7i64; - let Test.41 : Builtin(Bool) = false; - let Test.39 : Struct([Builtin(Int(I64)), Builtin(Bool)]) = Struct {Test.40, Test.41}; - let Test.35 : Builtin(Int(I64)) = CallByName Test.1 Test.39; - let Test.38 : Builtin(Bool) = false; - let Test.36 : Builtin(Int(I64)) = CallByName Test.1 Test.38; - let Test.25 : Builtin(Int(I64)) = CallByName Num.24 Test.35 Test.36; - let Test.33 : Builtin(Int(I64)) = 11i64; - let Test.34 : Builtin(Bool) = true; - let Test.27 : Struct([Builtin(Int(I64)), Builtin(Bool)]) = Struct {Test.33, Test.34}; - let Test.26 : Builtin(Int(I64)) = CallByName Test.1 Test.27; - let Test.16 : Builtin(Int(I64)) = CallByName Num.24 Test.25 Test.26; - let Test.24 : Builtin(Bool) = true; - let Test.17 : Builtin(Int(I64)) = CallByName Test.1 Test.24; - let Test.15 : Builtin(Int(I64)) = CallByName Num.24 Test.16 Test.17; + let Test.40 : I64 = 7i64; + let Test.41 : Int1 = false; + let Test.39 : {I64, Int1} = Struct {Test.40, Test.41}; + let Test.35 : I64 = CallByName Test.1 Test.39; + let Test.38 : Int1 = false; + let Test.36 : I64 = CallByName Test.1 Test.38; + let Test.25 : I64 = CallByName Num.24 Test.35 Test.36; + let Test.33 : I64 = 11i64; + let Test.34 : Int1 = true; + let Test.27 : {I64, Int1} = Struct {Test.33, Test.34}; + let Test.26 : I64 = CallByName Test.1 Test.27; + let Test.16 : I64 = CallByName Num.24 Test.25 Test.26; + let Test.24 : Int1 = true; + let Test.17 : I64 = CallByName Test.1 Test.24; + let Test.15 : I64 = CallByName Num.24 Test.16 Test.17; ret Test.15; diff --git a/compiler/test_mono/generated/peano.txt b/compiler/test_mono/generated/peano.txt index b20043d155..bee928bf10 100644 --- a/compiler/test_mono/generated/peano.txt +++ b/compiler/test_mono/generated/peano.txt @@ -1,6 +1,6 @@ procedure Test.0 (): - let Test.10 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = Z ; - let Test.9 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.10; - let Test.8 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.9; - let Test.2 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.8; + let Test.10 : TODO = Z ; + let Test.9 : TODO = S Test.10; + let Test.8 : TODO = S Test.9; + let Test.2 : TODO = S Test.8; ret Test.2; diff --git a/compiler/test_mono/generated/peano1.txt b/compiler/test_mono/generated/peano1.txt index 55c0c229b4..8d6b38bd55 100644 --- a/compiler/test_mono/generated/peano1.txt +++ b/compiler/test_mono/generated/peano1.txt @@ -1,15 +1,15 @@ procedure Test.0 (): - let Test.14 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = Z ; - let Test.13 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.14; - let Test.12 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.13; - let Test.2 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.12; - let Test.9 : Builtin(Bool) = 1i64; - let Test.10 : Builtin(Bool) = GetTagId Test.2; + let Test.14 : TODO = Z ; + let Test.13 : TODO = S Test.14; + let Test.12 : TODO = S Test.13; + let Test.2 : TODO = S Test.12; + let Test.9 : Int1 = 1i64; + let Test.10 : Int1 = GetTagId 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 - let Test.7 : Builtin(Int(I64)) = 0i64; + let Test.7 : I64 = 0i64; ret Test.7; else - let Test.8 : Builtin(Int(I64)) = 1i64; + let Test.8 : I64 = 1i64; ret Test.8; diff --git a/compiler/test_mono/generated/peano2.txt b/compiler/test_mono/generated/peano2.txt index 152e09e19f..a708c54baf 100644 --- a/compiler/test_mono/generated/peano2.txt +++ b/compiler/test_mono/generated/peano2.txt @@ -1,26 +1,26 @@ procedure Test.0 (): - let Test.20 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = Z ; - let Test.19 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.20; - let Test.18 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.19; - let Test.2 : Union(NullableUnwrapped { nullable_id: true, other_fields: [RecursivePointer] }) = S Test.18; - let Test.15 : Builtin(Bool) = 0i64; - let Test.16 : Builtin(Bool) = GetTagId Test.2; - let Test.17 : Builtin(Bool) = lowlevel Eq Test.15 Test.16; + let Test.20 : TODO = Z ; + let Test.19 : TODO = S Test.20; + let Test.18 : TODO = S Test.19; + let Test.2 : TODO = S Test.18; + let Test.15 : Int1 = 0i64; + let Test.16 : Int1 = GetTagId Test.2; + let Test.17 : Int1 = lowlevel Eq Test.15 Test.16; 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; dec Test.2; - let Test.12 : Builtin(Bool) = 0i64; - let Test.13 : Builtin(Bool) = GetTagId Test.11; + let Test.12 : Int1 = 0i64; + let Test.13 : Int1 = GetTagId 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 - let Test.7 : Builtin(Int(I64)) = 1i64; + let Test.7 : I64 = 1i64; ret Test.7; else - let Test.8 : Builtin(Int(I64)) = 0i64; + let Test.8 : I64 = 0i64; ret Test.8; else dec Test.2; - let Test.9 : Builtin(Int(I64)) = 0i64; + let Test.9 : I64 = 0i64; ret Test.9; diff --git a/compiler/test_mono/generated/quicksort_help.txt b/compiler/test_mono/generated/quicksort_help.txt index 911b38e71c..c9bad93164 100644 --- a/compiler/test_mono/generated/quicksort_help.txt +++ b/compiler/test_mono/generated/quicksort_help.txt @@ -1,32 +1,32 @@ 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; 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; 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; procedure Test.1 (Test.27, Test.28, Test.29): 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 dec Test.2; - let Test.25 : Builtin(List(Union(NonRecursive([])))) = Array []; - let Test.24 : Builtin(Int(I64)) = 0i64; - let Test.23 : Struct([Builtin(Int(I64)), Builtin(List(Union(NonRecursive([]))))]) = Struct {Test.24, Test.25}; - let Test.5 : Builtin(Int(I64)) = StructAtIndex 0 Test.23; - let Test.6 : Builtin(List(Union(NonRecursive([])))) = StructAtIndex 1 Test.23; + let Test.25 : List [] = Array []; + let Test.24 : I64 = 0i64; + let Test.23 : {I64, List []} = Struct {Test.24, Test.25}; + let Test.5 : I64 = StructAtIndex 0 Test.23; + let Test.6 : List [] = StructAtIndex 1 Test.23; inc Test.6; dec Test.23; - let Test.21 : Builtin(Int(I64)) = 1i64; - let Test.20 : Builtin(Int(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.18 : Builtin(Int(I64)) = 1i64; - let Test.17 : Builtin(Int(I64)) = CallByName Num.22 Test.5 Test.18; + let Test.21 : I64 = 1i64; + let Test.20 : I64 = CallByName Num.23 Test.5 Test.21; + let Test.16 : List I64 = CallByName Test.1 Test.6 Test.3 Test.20; + let Test.18 : I64 = 1i64; + let Test.17 : I64 = CallByName Num.22 Test.5 Test.18; jump Test.12 Test.16 Test.17 Test.4; else 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; procedure Test.0 (): - let Test.9 : Builtin(List(Builtin(Int(I64)))) = Array []; - let Test.10 : Builtin(Int(I64)) = 0i64; - let Test.11 : Builtin(Int(I64)) = 0i64; - let Test.8 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.9 Test.10 Test.11; + let Test.9 : List I64 = Array []; + let Test.10 : I64 = 0i64; + let Test.11 : I64 = 0i64; + let Test.8 : List I64 = CallByName Test.1 Test.9 Test.10 Test.11; ret Test.8; diff --git a/compiler/test_mono/generated/quicksort_swap.txt b/compiler/test_mono/generated/quicksort_swap.txt index 13e3c2824f..d42217aaa2 100644 --- a/compiler/test_mono/generated/quicksort_swap.txt +++ b/compiler/test_mono/generated/quicksort_swap.txt @@ -1,52 +1,52 @@ procedure List.3 (#Attr.2, #Attr.3): - let Test.37 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; - let Test.34 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.37; + let Test.37 : U64 = lowlevel ListLen #Attr.2; + let Test.34 : Int1 = lowlevel NumLt #Attr.3 Test.37; if Test.34 then - let Test.36 : Builtin(Int(I64)) = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.35 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Ok Test.36; + let Test.36 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.35 : [C {}, C I64] = Ok Test.36; ret Test.35; else - let Test.33 : Struct([]) = Struct {}; - let Test.32 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Err Test.33; + let Test.33 : {} = Struct {}; + let Test.32 : [C {}, C I64] = Err Test.33; ret Test.32; procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.15 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; - let Test.13 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.15; + let Test.15 : U64 = lowlevel ListLen #Attr.2; + let Test.13 : Int1 = lowlevel NumLt #Attr.3 Test.15; 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; else ret #Attr.2; procedure Test.1 (Test.2): - let Test.38 : Builtin(Int(U64)) = 0i64; - let Test.30 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = CallByName List.3 Test.2 Test.38; - let Test.31 : Builtin(Int(U64)) = 0i64; - let Test.29 : Union(NonRecursive([[Struct([])], [Builtin(Int(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.38 : U64 = 0i64; + let Test.30 : [C {}, C I64] = CallByName List.3 Test.2 Test.38; + let Test.31 : U64 = 0i64; + let Test.29 : [C {}, C I64] = CallByName List.3 Test.2 Test.31; + let Test.8 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.29, Test.30}; joinpoint Test.26: - let Test.17 : Builtin(List(Builtin(Int(I64)))) = Array []; + let Test.17 : List I64 = Array []; ret Test.17; in - let Test.23 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 1 Test.8; - let Test.24 : Builtin(Int(U8)) = 1i64; - let Test.25 : Builtin(Int(U8)) = GetTagId Test.23; - let Test.28 : Builtin(Bool) = lowlevel Eq Test.24 Test.25; + let Test.23 : [C {}, C I64] = StructAtIndex 1 Test.8; + let Test.24 : U8 = 1i64; + let Test.25 : U8 = GetTagId Test.23; + let Test.28 : Int1 = lowlevel Eq Test.24 Test.25; if Test.28 then - let Test.20 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 0 Test.8; - let Test.21 : Builtin(Int(U8)) = 1i64; - let Test.22 : Builtin(Int(U8)) = GetTagId Test.20; - let Test.27 : Builtin(Bool) = lowlevel Eq Test.21 Test.22; + let Test.20 : [C {}, C I64] = StructAtIndex 0 Test.8; + let Test.21 : U8 = 1i64; + let Test.22 : U8 = GetTagId Test.20; + let Test.27 : Int1 = lowlevel Eq Test.21 Test.22; if Test.27 then - let Test.19 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 0 Test.8; - let Test.4 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.19; - let Test.18 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 1 Test.8; - let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.18; - let Test.16 : Builtin(Int(U64)) = 0i64; - let Test.10 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.2 Test.16 Test.5; - let Test.11 : Builtin(Int(U64)) = 0i64; - let Test.9 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.10 Test.11 Test.4; + let Test.19 : [C {}, C I64] = StructAtIndex 0 Test.8; + let Test.4 : I64 = UnionAtIndex (Id 1) (Index 0) Test.19; + let Test.18 : [C {}, C I64] = StructAtIndex 1 Test.8; + let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) Test.18; + let Test.16 : U64 = 0i64; + let Test.10 : List I64 = CallByName List.4 Test.2 Test.16 Test.5; + let Test.11 : U64 = 0i64; + let Test.9 : List I64 = CallByName List.4 Test.10 Test.11 Test.4; ret Test.9; else dec Test.2; @@ -56,6 +56,6 @@ procedure Test.1 (Test.2): jump Test.26; procedure Test.0 (): - let Test.7 : Builtin(List(Builtin(Int(I64)))) = Array [1i64, 2i64]; - let Test.6 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.7; + let Test.7 : List I64 = Array [1i64, 2i64]; + let Test.6 : List I64 = CallByName Test.1 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt b/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt index 3c98d6876b..efbc0ca6e2 100644 --- a/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt @@ -1,16 +1,16 @@ 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; procedure Test.1 (Test.4): - let Test.2 : Builtin(Int(I64)) = StructAtIndex 0 Test.4; - let Test.3 : Builtin(Int(I64)) = StructAtIndex 1 Test.4; - let Test.7 : Builtin(Int(I64)) = CallByName Num.22 Test.2 Test.3; + let Test.2 : I64 = StructAtIndex 0 Test.4; + let Test.3 : I64 = StructAtIndex 1 Test.4; + let Test.7 : I64 = CallByName Num.22 Test.2 Test.3; ret Test.7; procedure Test.0 (): - let Test.9 : Builtin(Int(I64)) = 4i64; - let Test.10 : Builtin(Int(I64)) = 9i64; - let Test.6 : Struct([Builtin(Int(I64)), Builtin(Int(I64))]) = Struct {Test.9, Test.10}; - let Test.5 : Builtin(Int(I64)) = CallByName Test.1 Test.6; + let Test.9 : I64 = 4i64; + let Test.10 : I64 = 9i64; + let Test.6 : {I64, I64} = Struct {Test.9, Test.10}; + let Test.5 : I64 = CallByName Test.1 Test.6; ret Test.5; diff --git a/compiler/test_mono/generated/record_optional_field_function_use_default.txt b/compiler/test_mono/generated/record_optional_field_function_use_default.txt index aee1aa3793..b3a418d3f3 100644 --- a/compiler/test_mono/generated/record_optional_field_function_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_function_use_default.txt @@ -1,13 +1,13 @@ 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; procedure Test.1 (Test.4): - let Test.8 : Builtin(Int(I64)) = 10i64; - let Test.7 : Builtin(Int(I64)) = CallByName Num.22 Test.8 Test.4; + let Test.8 : I64 = 10i64; + let Test.7 : I64 = CallByName Num.22 Test.8 Test.4; ret Test.7; procedure Test.0 (): - let Test.10 : Builtin(Int(I64)) = 9i64; - let Test.5 : Builtin(Int(I64)) = CallByName Test.1 Test.10; + let Test.10 : I64 = 9i64; + let Test.5 : I64 = CallByName Test.1 Test.10; ret Test.5; diff --git a/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt b/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt index 255130f13b..4c10690d37 100644 --- a/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt @@ -1,16 +1,16 @@ 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; procedure Test.1 (Test.2): - let Test.3 : Builtin(Int(I64)) = StructAtIndex 0 Test.2; - let Test.4 : Builtin(Int(I64)) = StructAtIndex 1 Test.2; - let Test.7 : Builtin(Int(I64)) = CallByName Num.22 Test.3 Test.4; + let Test.3 : I64 = StructAtIndex 0 Test.2; + let Test.4 : I64 = StructAtIndex 1 Test.2; + let Test.7 : I64 = CallByName Num.22 Test.3 Test.4; ret Test.7; procedure Test.0 (): - let Test.9 : Builtin(Int(I64)) = 4i64; - let Test.10 : Builtin(Int(I64)) = 9i64; - let Test.6 : Struct([Builtin(Int(I64)), Builtin(Int(I64))]) = Struct {Test.9, Test.10}; - let Test.5 : Builtin(Int(I64)) = CallByName Test.1 Test.6; + let Test.9 : I64 = 4i64; + let Test.10 : I64 = 9i64; + let Test.6 : {I64, I64} = Struct {Test.9, Test.10}; + let Test.5 : I64 = CallByName Test.1 Test.6; ret Test.5; diff --git a/compiler/test_mono/generated/record_optional_field_let_use_default.txt b/compiler/test_mono/generated/record_optional_field_let_use_default.txt index 978c5b026d..14a00e3638 100644 --- a/compiler/test_mono/generated/record_optional_field_let_use_default.txt +++ b/compiler/test_mono/generated/record_optional_field_let_use_default.txt @@ -1,13 +1,13 @@ 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; procedure Test.1 (Test.2): - let Test.3 : Builtin(Int(I64)) = 10i64; - let Test.7 : Builtin(Int(I64)) = CallByName Num.22 Test.3 Test.2; + let Test.3 : I64 = 10i64; + let Test.7 : I64 = CallByName Num.22 Test.3 Test.2; ret Test.7; procedure Test.0 (): - let Test.9 : Builtin(Int(I64)) = 9i64; - let Test.5 : Builtin(Int(I64)) = CallByName Test.1 Test.9; + let Test.9 : I64 = 9i64; + let Test.5 : I64 = CallByName Test.1 Test.9; ret Test.5; diff --git a/compiler/test_mono/generated/rigids.txt b/compiler/test_mono/generated/rigids.txt index 5f0124657f..9a030e6c5e 100644 --- a/compiler/test_mono/generated/rigids.txt +++ b/compiler/test_mono/generated/rigids.txt @@ -1,48 +1,48 @@ procedure List.3 (#Attr.2, #Attr.3): - let Test.39 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; - let Test.36 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.39; + let Test.39 : U64 = lowlevel ListLen #Attr.2; + let Test.36 : Int1 = lowlevel NumLt #Attr.3 Test.39; if Test.36 then - let Test.38 : Builtin(Int(I64)) = lowlevel ListGetUnsafe #Attr.2 #Attr.3; - let Test.37 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Ok Test.38; + let Test.38 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + let Test.37 : [C {}, C I64] = Ok Test.38; ret Test.37; else - let Test.35 : Struct([]) = Struct {}; - let Test.34 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = Err Test.35; + let Test.35 : {} = Struct {}; + let Test.34 : [C {}, C I64] = Err Test.35; ret Test.34; procedure List.4 (#Attr.2, #Attr.3, #Attr.4): - let Test.19 : Builtin(Int(U64)) = lowlevel ListLen #Attr.2; - let Test.17 : Builtin(Bool) = lowlevel NumLt #Attr.3 Test.19; + let Test.19 : U64 = lowlevel ListLen #Attr.2; + let Test.17 : Int1 = lowlevel NumLt #Attr.3 Test.19; 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; else ret #Attr.2; 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.32 : Union(NonRecursive([[Struct([])], [Builtin(Int(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.33 : [C {}, C I64] = CallByName List.3 Test.4 Test.3; + let Test.32 : [C {}, C I64] = CallByName List.3 Test.4 Test.2; + let Test.13 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.32, Test.33}; joinpoint Test.29: - let Test.20 : Builtin(List(Builtin(Int(I64)))) = Array []; + let Test.20 : List I64 = Array []; ret Test.20; in - let Test.26 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 1 Test.13; - let Test.27 : Builtin(Int(U8)) = 1i64; - let Test.28 : Builtin(Int(U8)) = GetTagId Test.26; - let Test.31 : Builtin(Bool) = lowlevel Eq Test.27 Test.28; + let Test.26 : [C {}, C I64] = StructAtIndex 1 Test.13; + let Test.27 : U8 = 1i64; + let Test.28 : U8 = GetTagId Test.26; + let Test.31 : Int1 = lowlevel Eq Test.27 Test.28; if Test.31 then - let Test.23 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 0 Test.13; - let Test.24 : Builtin(Int(U8)) = 1i64; - let Test.25 : Builtin(Int(U8)) = GetTagId Test.23; - let Test.30 : Builtin(Bool) = lowlevel Eq Test.24 Test.25; + let Test.23 : [C {}, C I64] = StructAtIndex 0 Test.13; + let Test.24 : U8 = 1i64; + let Test.25 : U8 = GetTagId Test.23; + let Test.30 : Int1 = lowlevel Eq Test.24 Test.25; if Test.30 then - let Test.22 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 0 Test.13; - let Test.6 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.22; - let Test.21 : Union(NonRecursive([[Struct([])], [Builtin(Int(I64))]])) = StructAtIndex 1 Test.13; - let Test.7 : Builtin(Int(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.14 : Builtin(List(Builtin(Int(I64)))) = CallByName List.4 Test.15 Test.3 Test.6; + let Test.22 : [C {}, C I64] = StructAtIndex 0 Test.13; + let Test.6 : I64 = UnionAtIndex (Id 1) (Index 0) Test.22; + let Test.21 : [C {}, C I64] = StructAtIndex 1 Test.13; + let Test.7 : I64 = UnionAtIndex (Id 1) (Index 0) Test.21; + let Test.15 : List I64 = CallByName List.4 Test.4 Test.2 Test.7; + let Test.14 : List I64 = CallByName List.4 Test.15 Test.3 Test.6; ret Test.14; else dec Test.4; @@ -52,8 +52,8 @@ procedure Test.1 (Test.2, Test.3, Test.4): jump Test.29; procedure Test.0 (): - let Test.10 : Builtin(Int(U64)) = 0i64; - let Test.11 : Builtin(Int(U64)) = 0i64; - let Test.12 : Builtin(List(Builtin(Int(I64)))) = Array [1i64]; - let Test.9 : Builtin(List(Builtin(Int(I64)))) = CallByName Test.1 Test.10 Test.11 Test.12; + let Test.10 : U64 = 0i64; + let Test.11 : U64 = 0i64; + let Test.12 : List I64 = Array [1i64]; + let Test.9 : List I64 = CallByName Test.1 Test.10 Test.11 Test.12; ret Test.9; diff --git a/compiler/test_mono/generated/simple_if.txt b/compiler/test_mono/generated/simple_if.txt index ba3e24661c..04a1917375 100644 --- a/compiler/test_mono/generated/simple_if.txt +++ b/compiler/test_mono/generated/simple_if.txt @@ -1,8 +1,8 @@ procedure Test.0 (): - let Test.3 : Builtin(Bool) = true; + let Test.3 : Int1 = true; if Test.3 then - let Test.4 : Builtin(Int(I64)) = 1i64; + let Test.4 : I64 = 1i64; ret Test.4; else - let Test.2 : Builtin(Int(I64)) = 2i64; + let Test.2 : I64 = 2i64; ret Test.2; diff --git a/compiler/test_mono/generated/somehow_drops_definitions.txt b/compiler/test_mono/generated/somehow_drops_definitions.txt index 1dd4ed9c40..067e533b9c 100644 --- a/compiler/test_mono/generated/somehow_drops_definitions.txt +++ b/compiler/test_mono/generated/somehow_drops_definitions.txt @@ -1,27 +1,27 @@ 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; 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; procedure Test.1 (): - let Test.28 : Builtin(Int(I64)) = 1i64; + let Test.28 : I64 = 1i64; ret Test.28; procedure Test.2 (): - let Test.23 : Builtin(Int(I64)) = 2i64; + let Test.23 : I64 = 2i64; ret Test.23; procedure Test.3 (Test.6): - let Test.26 : Builtin(Int(I64)) = CallByName Test.1; - let Test.25 : Builtin(Int(I64)) = CallByName Num.22 Test.6 Test.26; + let Test.26 : I64 = CallByName Test.1; + let Test.25 : I64 = CallByName Num.22 Test.6 Test.26; ret Test.25; procedure Test.4 (Test.7): - let Test.21 : Builtin(Int(I64)) = CallByName Test.2; - let Test.20 : Builtin(Int(I64)) = CallByName Num.24 Test.7 Test.21; + let Test.21 : I64 = CallByName Test.2; + let Test.20 : I64 = CallByName Num.24 Test.7 Test.21; ret Test.20; procedure Test.5 (Test.8, Test.9): @@ -30,24 +30,24 @@ procedure Test.5 (Test.8, Test.9): in switch Test.8: 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; 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; procedure Test.0 (): joinpoint Test.19 Test.12: - let Test.13 : Builtin(Int(I64)) = 42i64; - let Test.11 : Builtin(Int(I64)) = CallByName Test.5 Test.12 Test.13; + let Test.13 : I64 = 42i64; + let Test.11 : I64 = CallByName Test.5 Test.12 Test.13; ret Test.11; in - let Test.24 : Builtin(Bool) = true; + let Test.24 : Int1 = true; 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; 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; diff --git a/compiler/test_mono/generated/specialize_closures.txt b/compiler/test_mono/generated/specialize_closures.txt index 772676526b..8d39d6b960 100644 --- a/compiler/test_mono/generated/specialize_closures.txt +++ b/compiler/test_mono/generated/specialize_closures.txt @@ -1,53 +1,53 @@ 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; 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; 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: ret Test.16; in switch Test.17: 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; 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; procedure Test.7 (Test.10, #Attr.12): - let Test.4 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) #Attr.12; - let Test.27 : Builtin(Int(I64)) = CallByName Num.22 Test.10 Test.4; + let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12; + let Test.27 : I64 = CallByName Num.22 Test.10 Test.4; ret Test.27; procedure Test.8 (Test.11, #Attr.12): - let Test.6 : Builtin(Bool) = UnionAtIndex (Id 1) (Index 1) #Attr.12; - let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) #Attr.12; + let Test.6 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12; + let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12; 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; else ret Test.11; procedure Test.0 (): - let Test.6 : Builtin(Bool) = true; - let Test.4 : Builtin(Int(I64)) = 1i64; - let Test.5 : Builtin(Int(I64)) = 2i64; + let Test.6 : Int1 = true; + let Test.4 : I64 = 1i64; + let Test.5 : I64 = 2i64; joinpoint Test.22 Test.14: - let Test.15 : Builtin(Int(I64)) = 42i64; - let Test.13 : Builtin(Int(I64)) = CallByName Test.1 Test.14 Test.15; + let Test.15 : I64 = 42i64; + let Test.13 : I64 = CallByName Test.1 Test.14 Test.15; ret Test.13; in - let Test.26 : Builtin(Bool) = true; + let Test.26 : Int1 = true; 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; 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; diff --git a/compiler/test_mono/generated/specialize_lowlevel.txt b/compiler/test_mono/generated/specialize_lowlevel.txt index 4dba44f752..9706cdd1bf 100644 --- a/compiler/test_mono/generated/specialize_lowlevel.txt +++ b/compiler/test_mono/generated/specialize_lowlevel.txt @@ -1,44 +1,44 @@ 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; 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; procedure Test.6 (Test.8, #Attr.12): - let Test.4 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) #Attr.12; - let Test.23 : Builtin(Int(I64)) = CallByName Num.22 Test.8 Test.4; + let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12; + let Test.23 : I64 = CallByName Num.22 Test.8 Test.4; ret Test.23; procedure Test.7 (Test.9, #Attr.12): - let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) #Attr.12; - let Test.20 : Builtin(Int(I64)) = CallByName Num.24 Test.9 Test.5; + let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12; + let Test.20 : I64 = CallByName Num.24 Test.9 Test.5; ret Test.20; procedure Test.0 (): - let Test.4 : Builtin(Int(I64)) = 1i64; - let Test.5 : Builtin(Int(I64)) = 2i64; - let Test.12 : Builtin(Int(I64)) = 42i64; + let Test.4 : I64 = 1i64; + let Test.5 : I64 = 2i64; + let Test.12 : I64 = 42i64; 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: ret Test.11; in switch Test.14: 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; 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; in - let Test.22 : Builtin(Bool) = true; + let Test.22 : Int1 = true; 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; 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; diff --git a/compiler/test_mono/generated/when_joinpoint.txt b/compiler/test_mono/generated/when_joinpoint.txt index 3366717fca..c3f2529c59 100644 --- a/compiler/test_mono/generated/when_joinpoint.txt +++ b/compiler/test_mono/generated/when_joinpoint.txt @@ -1,23 +1,23 @@ procedure Test.1 (Test.5): - let Test.2 : Builtin(Int(U8)) = 0u8; + let Test.2 : U8 = 0u8; joinpoint Test.9 Test.3: ret Test.3; in switch Test.2: case 1: - let Test.10 : Builtin(Int(I64)) = 1i64; + let Test.10 : I64 = 1i64; jump Test.9 Test.10; case 2: - let Test.11 : Builtin(Int(I64)) = 2i64; + let Test.11 : I64 = 2i64; jump Test.9 Test.11; default: - let Test.12 : Builtin(Int(I64)) = 3i64; + let Test.12 : I64 = 3i64; jump Test.9 Test.12; procedure Test.0 (): - let Test.7 : Struct([]) = Struct {}; - let Test.6 : Builtin(Int(I64)) = CallByName Test.1 Test.7; + let Test.7 : {} = Struct {}; + let Test.6 : I64 = CallByName Test.1 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/when_nested_maybe.txt b/compiler/test_mono/generated/when_nested_maybe.txt index facbc46055..6bb9eebf35 100644 --- a/compiler/test_mono/generated/when_nested_maybe.txt +++ b/compiler/test_mono/generated/when_nested_maybe.txt @@ -1,28 +1,28 @@ 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; procedure Test.0 (): - let Test.20 : Builtin(Int(I64)) = 41i64; - let Test.19 : Union(NonRecursive([[Builtin(Int(I64))], []])) = Just Test.20; - let Test.2 : Union(NonRecursive([[Union(NonRecursive([[Builtin(Int(I64))], []]))], []])) = Just Test.19; + let Test.20 : I64 = 41i64; + let Test.19 : [C I64, C ] = Just Test.20; + let Test.2 : [C [C I64, C ], C ] = Just Test.19; joinpoint Test.16: - let Test.9 : Builtin(Int(I64)) = 1i64; + let Test.9 : I64 = 1i64; ret Test.9; in - let Test.14 : Builtin(Int(U8)) = 0i64; - let Test.15 : Builtin(Int(U8)) = GetTagId Test.2; - let Test.18 : Builtin(Bool) = lowlevel Eq Test.14 Test.15; + let Test.14 : U8 = 0i64; + let Test.15 : U8 = GetTagId Test.2; + let Test.18 : Int1 = lowlevel Eq Test.14 Test.15; if Test.18 then - let Test.11 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.2; - let Test.12 : Builtin(Int(U8)) = 0i64; - let Test.13 : Builtin(Int(U8)) = GetTagId Test.11; - let Test.17 : Builtin(Bool) = lowlevel Eq Test.12 Test.13; + let Test.11 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2; + let Test.12 : U8 = 0i64; + let Test.13 : U8 = GetTagId Test.11; + let Test.17 : Int1 = lowlevel Eq Test.12 Test.13; if Test.17 then - let Test.10 : Union(NonRecursive([[Builtin(Int(I64))], []])) = UnionAtIndex (Id 0) (Index 0) Test.2; - let Test.5 : Builtin(Int(I64)) = UnionAtIndex (Id 0) (Index 0) Test.10; - let Test.7 : Builtin(Int(I64)) = 1i64; - let Test.6 : Builtin(Int(I64)) = CallByName Num.22 Test.5 Test.7; + let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2; + let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.10; + let Test.7 : I64 = 1i64; + let Test.6 : I64 = CallByName Num.22 Test.5 Test.7; ret Test.6; else jump Test.16; diff --git a/compiler/test_mono/generated/when_on_record.txt b/compiler/test_mono/generated/when_on_record.txt index b606928426..b313695135 100644 --- a/compiler/test_mono/generated/when_on_record.txt +++ b/compiler/test_mono/generated/when_on_record.txt @@ -1,9 +1,9 @@ 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; procedure Test.0 (): - let Test.6 : Builtin(Int(I64)) = 2i64; - let Test.4 : Builtin(Int(I64)) = 3i64; - let Test.3 : Builtin(Int(I64)) = CallByName Num.22 Test.6 Test.4; + let Test.6 : I64 = 2i64; + let Test.4 : I64 = 3i64; + let Test.3 : I64 = CallByName Num.22 Test.6 Test.4; ret Test.3; diff --git a/compiler/test_mono/generated/when_on_result.txt b/compiler/test_mono/generated/when_on_result.txt index 84144767fc..6fbe2699d4 100644 --- a/compiler/test_mono/generated/when_on_result.txt +++ b/compiler/test_mono/generated/when_on_result.txt @@ -1,27 +1,27 @@ procedure Test.1 (Test.5): - let Test.19 : Builtin(Int(I64)) = 2i64; - let Test.2 : Union(NonRecursive([[Builtin(Int(I64))], [Builtin(Int(I64))]])) = Ok Test.19; + let Test.19 : I64 = 2i64; + let Test.2 : [C I64, C I64] = Ok Test.19; joinpoint Test.9 Test.3: ret Test.3; in - let Test.16 : Builtin(Int(U8)) = 1i64; - let Test.17 : Builtin(Int(U8)) = GetTagId Test.2; - let Test.18 : Builtin(Bool) = lowlevel Eq Test.16 Test.17; + let Test.16 : U8 = 1i64; + let Test.17 : U8 = GetTagId Test.2; + let Test.18 : Int1 = lowlevel Eq Test.16 Test.17; if Test.18 then - let Test.13 : Builtin(Int(I64)) = UnionAtIndex (Id 1) (Index 0) Test.2; - let Test.14 : Builtin(Int(I64)) = 3i64; - let Test.15 : Builtin(Bool) = lowlevel Eq Test.14 Test.13; + let Test.13 : I64 = UnionAtIndex (Id 1) (Index 0) Test.2; + let Test.14 : I64 = 3i64; + let Test.15 : Int1 = lowlevel Eq Test.14 Test.13; if Test.15 then - let Test.10 : Builtin(Int(I64)) = 1i64; + let Test.10 : I64 = 1i64; jump Test.9 Test.10; else - let Test.11 : Builtin(Int(I64)) = 2i64; + let Test.11 : I64 = 2i64; jump Test.9 Test.11; else - let Test.12 : Builtin(Int(I64)) = 3i64; + let Test.12 : I64 = 3i64; jump Test.9 Test.12; procedure Test.0 (): - let Test.7 : Struct([]) = Struct {}; - let Test.6 : Builtin(Int(I64)) = CallByName Test.1 Test.7; + let Test.7 : {} = Struct {}; + let Test.6 : I64 = CallByName Test.1 Test.7; ret Test.6; diff --git a/compiler/test_mono/generated/when_on_two_values.txt b/compiler/test_mono/generated/when_on_two_values.txt index 4af8530b49..2085f6c7df 100644 --- a/compiler/test_mono/generated/when_on_two_values.txt +++ b/compiler/test_mono/generated/when_on_two_values.txt @@ -1,26 +1,26 @@ 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; procedure Test.0 (): - let Test.16 : Builtin(Int(I64)) = 3i64; - let Test.15 : Builtin(Int(I64)) = 2i64; - let Test.4 : Struct([Builtin(Int(I64)), Builtin(Int(I64))]) = Struct {Test.15, Test.16}; + let Test.16 : I64 = 3i64; + let Test.15 : I64 = 2i64; + let Test.4 : {I64, I64} = Struct {Test.15, Test.16}; joinpoint Test.12: - let Test.2 : Builtin(Int(I64)) = StructAtIndex 0 Test.4; - let Test.3 : Builtin(Int(I64)) = StructAtIndex 1 Test.4; - let Test.6 : Builtin(Int(I64)) = CallByName Num.22 Test.2 Test.3; + let Test.2 : I64 = StructAtIndex 0 Test.4; + let Test.3 : I64 = StructAtIndex 1 Test.4; + let Test.6 : I64 = CallByName Num.22 Test.2 Test.3; ret Test.6; in - let Test.10 : Builtin(Int(I64)) = StructAtIndex 1 Test.4; - let Test.11 : Builtin(Int(I64)) = 3i64; - let Test.14 : Builtin(Bool) = lowlevel Eq Test.11 Test.10; + let Test.10 : I64 = StructAtIndex 1 Test.4; + let Test.11 : I64 = 3i64; + let Test.14 : Int1 = lowlevel Eq Test.11 Test.10; if Test.14 then - let Test.8 : Builtin(Int(I64)) = StructAtIndex 0 Test.4; - let Test.9 : Builtin(Int(I64)) = 4i64; - let Test.13 : Builtin(Bool) = lowlevel Eq Test.9 Test.8; + let Test.8 : I64 = StructAtIndex 0 Test.4; + let Test.9 : I64 = 4i64; + let Test.13 : Int1 = lowlevel Eq Test.9 Test.8; if Test.13 then - let Test.5 : Builtin(Int(I64)) = 9i64; + let Test.5 : I64 = 9i64; ret Test.5; else jump Test.12; From 475be2363c5dc337d61e24c162f33c477541ea9e Mon Sep 17 00:00:00 2001 From: ayazhafiz Date: Sun, 20 Feb 2022 20:05:15 -0500 Subject: [PATCH 3/7] Add a gen test for #2535 --- compiler/test_gen/src/gen_records.rs | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/compiler/test_gen/src/gen_records.rs b/compiler/test_gen/src/gen_records.rs index 5377da5afc..d10f846d43 100644 --- a/compiler/test_gen/src/gen_records.rs +++ b/compiler/test_gen/src/gen_records.rs @@ -13,6 +13,9 @@ use crate::helpers::wasm::assert_evals_to; // use crate::assert_wasm_evals_to as assert_evals_to; use indoc::indoc; +#[cfg(test)] +use roc_std::RocList; + #[test] #[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))] fn basic_record() { @@ -1007,6 +1010,30 @@ fn both_have_unique_fields() { ); } +#[test] +#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))] +// 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 + ); +} + #[test] #[cfg(any(feature = "gen-llvm"))] #[should_panic( From 148dbb4efe9769bc0a8384b1e4761bbc02510dd7 Mon Sep 17 00:00:00 2001 From: ayazhafiz Date: Sun, 20 Feb 2022 20:06:56 -0500 Subject: [PATCH 4/7] Unnecessary reference --- compiler/gen_llvm/src/llvm/refcounting.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/compiler/gen_llvm/src/llvm/refcounting.rs b/compiler/gen_llvm/src/llvm/refcounting.rs index 24bf02d093..da820087bf 100644 --- a/compiler/gen_llvm/src/llvm/refcounting.rs +++ b/compiler/gen_llvm/src/llvm/refcounting.rs @@ -621,7 +621,7 @@ fn modify_refcount_layout_build_function<'a, 'ctx, 'env>( Struct { field_layouts, .. } => { let function = - modify_refcount_struct(env, layout_ids, &field_layouts, mode, when_recursive); + modify_refcount_struct(env, layout_ids, field_layouts, mode, when_recursive); Some(function) } From 395e0a33e09bb64d1a2be2c71c4ba88ca1280d8c Mon Sep 17 00:00:00 2001 From: ayazhafiz Date: Mon, 21 Feb 2022 12:50:23 -0500 Subject: [PATCH 5/7] Make sure unit structs are always units --- compiler/mono/src/ir.rs | 4 +-- compiler/mono/src/layout.rs | 51 ++++++++++++++++++++++++------------- 2 files changed, 35 insertions(+), 20 deletions(-) diff --git a/compiler/mono/src/ir.rs b/compiler/mono/src/ir.rs index f5eb2a3b44..87242e8069 100644 --- a/compiler/mono/src/ir.rs +++ b/compiler/mono/src/ir.rs @@ -4701,9 +4701,7 @@ fn construct_closure_data<'a>( Vec::from_iter_in(combined.iter().map(|(_, b)| **b), env.arena).into_bump_slice(); debug_assert_eq!( - // NB: this may be wrong! If it comes up, we may need to hash the closure - // argument name order. - Layout::struct_no_name_order(field_layouts,), + Layout::struct_no_name_order(field_layouts), lambda_set.runtime_representation() ); diff --git a/compiler/mono/src/layout.rs b/compiler/mono/src/layout.rs index abf61dd010..21661dae6b 100644 --- a/compiler/mono/src/layout.rs +++ b/compiler/mono/src/layout.rs @@ -27,7 +27,6 @@ static_assertions::assert_eq_size!([usize; 3], LambdaSet); pub type TagIdIntType = u16; pub const MAX_ENUM_SIZE: usize = (std::mem::size_of::() * 8) as usize; const GENERATE_NULLABLE: bool = true; -const IRRELEVANT_FIELD_HASH: u64 = 0; #[derive(Debug, Clone)] pub enum LayoutProblem { @@ -203,6 +202,27 @@ 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! #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] pub enum Layout<'a> { @@ -217,7 +237,7 @@ pub enum Layout<'a> { /// in collisions, but it's unlikely. /// /// See also https://github.com/rtfeldman/roc/issues/2535. - field_order_hash: u64, + field_order_hash: FieldOrderHash, field_layouts: &'a [Layout<'a>], }, Union(UnionLayout<'a>), @@ -885,7 +905,7 @@ impl<'a> Layout<'a> { pub const VOID: Self = Layout::Union(UnionLayout::NonRecursive(&[])); pub const UNIT: Self = Layout::Struct { field_layouts: &[], - field_order_hash: IRRELEVANT_FIELD_HASH, + field_order_hash: FieldOrderHash::ZERO_FIELD_HASH, }; fn new_help<'b>( @@ -1171,9 +1191,13 @@ impl<'a> Layout<'a> { /// Used to build a `Layout::Struct` where the field name order is irrelevant. pub fn struct_no_name_order(field_layouts: &'a [Layout]) -> Self { - Self::Struct { - field_layouts, - field_order_hash: IRRELEVANT_FIELD_HASH, + if field_layouts.is_empty() { + Self::UNIT + } else { + Self::Struct { + field_layouts, + field_order_hash: FieldOrderHash::IRRELEVANT_NON_ZERO_FIELD_HASH, + } } } } @@ -1619,13 +1643,10 @@ fn layout_from_flat_type<'a>( size2.cmp(&size1).then(label1.cmp(label2)) }); - let field_order_hash = { - let mut field_order_hasher = DefaultHasher::new(); - pairs - .iter() - .for_each(|(label, _)| label.hash(&mut field_order_hasher)); - field_order_hasher.finish() - }; + 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); @@ -2264,9 +2285,6 @@ pub fn union_sorted_tags_help<'a>( } else { UnionVariant::Newtype { tag_name, - // NB: It may be the case that the order of the layouts chosen here must be - // hashed, in case they differ for two specializations of the same type. If - // there is a problem with newtypes not specializing correctly, this might be why! arguments: layouts, } } @@ -2473,7 +2491,6 @@ fn layout_from_tag_union<'a>( let answer1 = if field_layouts.len() == 1 { field_layouts[0] } else { - // NB: does the field name order here matter, when it comes from the tag payload order? Layout::struct_no_name_order(field_layouts.into_bump_slice()) }; From dd2b3097e1b1ba1dd461ab8c3df7136a1deb9638 Mon Sep 17 00:00:00 2001 From: ayazhafiz Date: Mon, 21 Feb 2022 14:06:22 -0500 Subject: [PATCH 6/7] Disable WASM test for now --- compiler/test_gen/src/gen_records.rs | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/compiler/test_gen/src/gen_records.rs b/compiler/test_gen/src/gen_records.rs index d10f846d43..7a21e13fc7 100644 --- a/compiler/test_gen/src/gen_records.rs +++ b/compiler/test_gen/src/gen_records.rs @@ -1011,7 +1011,8 @@ fn both_have_unique_fields() { } #[test] -#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))] +// 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!( From 2151e715dd2f8abfa267c04278cfba8b76cb205c Mon Sep 17 00:00:00 2001 From: ayazhafiz Date: Mon, 21 Feb 2022 14:12:49 -0500 Subject: [PATCH 7/7] Fix rebased compile error --- compiler/gen_llvm/src/llvm/build.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/compiler/gen_llvm/src/llvm/build.rs b/compiler/gen_llvm/src/llvm/build.rs index 1fb64493f4..af42090989 100644 --- a/compiler/gen_llvm/src/llvm/build.rs +++ b/compiler/gen_llvm/src/llvm/build.rs @@ -6976,9 +6976,9 @@ fn build_int_unary_op<'a, 'ctx, 'env>( // return_layout : Result N [ OutOfBounds ]* ~ { result: N, out_of_bounds: bool } let target_int_width = match return_layout { - Layout::Struct(layouts) if layouts.len() == 2 => { - debug_assert!(matches!(layouts[1], Layout::Builtin(Builtin::Bool))); - match layouts[0] { + Layout::Struct { field_layouts, .. } if field_layouts.len() == 2 => { + debug_assert!(matches!(field_layouts[1], Layout::Builtin(Builtin::Bool))); + match field_layouts[0] { Layout::Builtin(Builtin::Int(iw)) => iw, layout => internal_error!( "There can only be an int layout here, found {:?}!",