From fc0a9ec4cfd5c68008100010b5ebfbf7a7fc1c86 Mon Sep 17 00:00:00 2001 From: Norbert Hajagos Date: Thu, 23 Jan 2025 12:59:52 +0100 Subject: [PATCH] add with_ascii_uppercased and caseless_ascii_equals to Str --- crates/compiler/builtins/bitcode/src/main.zig | 2 + crates/compiler/builtins/bitcode/src/str.zig | 129 ++++++++ crates/compiler/builtins/roc/Str.roc | 70 ++++- crates/compiler/builtins/src/bitcode.rs | 2 + crates/compiler/can/src/builtins.rs | 2 + crates/compiler/gen_dev/src/lib.rs | 14 + crates/compiler/gen_llvm/src/llvm/lowlevel.rs | 22 ++ crates/compiler/gen_wasm/src/low_level.rs | 6 + crates/compiler/module/src/low_level.rs | 4 + crates/compiler/module/src/symbol.rs | 10 +- .../compiler/mono/src/drop_specialization.rs | 2 + crates/compiler/mono/src/inc_dec.rs | 2 + crates/compiler/solve/tests/solve_expr.rs | 24 ++ crates/compiler/test_gen/src/gen_str.rs | 24 ++ ...lambda_set_productive_nullable_wrapped.txt | 4 +- .../compiler/test_mono/generated/dbg_expr.txt | 4 +- .../test_mono/generated/dbg_in_expect.txt | 292 ++++++++--------- .../test_mono/generated/dbg_inside_string.txt | 292 ++++++++--------- .../test_mono/generated/dbg_nested_expr.txt | 4 +- .../generated/dbg_str_followed_by_number.txt | 292 ++++++++--------- ...unt_for_usage_after_early_return_in_if.txt | 4 +- .../encode_derived_nested_record_string.txt | 38 +-- ...encode_derived_record_one_field_string.txt | 38 +-- ...ncode_derived_record_two_field_strings.txt | 38 +-- .../generated/encode_derived_string.txt | 38 +-- .../encode_derived_tag_one_field_string.txt | 38 +-- ...encode_derived_tag_two_payloads_string.txt | 38 +-- .../generated/inspect_derived_dict.txt | 296 +++++++++--------- .../generated/inspect_derived_list.txt | 4 +- .../inspect_derived_nested_record_string.txt | 292 ++++++++--------- .../generated/inspect_derived_record.txt | 4 +- ...nspect_derived_record_one_field_string.txt | 292 ++++++++--------- ...spect_derived_record_two_field_strings.txt | 292 ++++++++--------- .../generated/inspect_derived_string.txt | 292 ++++++++--------- .../inspect_derived_tag_one_field_string.txt | 292 ++++++++--------- ...nspect_derived_tag_two_payloads_string.txt | 292 ++++++++--------- ...cialize_errors_behind_unified_branches.txt | 34 +- ..._4772_weakened_monomorphic_destructure.txt | 38 +-- ...pture_niches_with_other_lambda_capture.txt | 4 +- .../generated/list_map_closure_borrows.txt | 8 +- .../generated/list_map_closure_owns.txt | 4 +- .../test_mono/generated/pizza_dbg.txt | 4 +- .../polymorphic_expression_unification.txt | 4 +- .../generated/recursively_build_effect.txt | 4 +- .../test_mono/generated/return_annotated.txt | 34 +- ...not_duplicate_identical_concrete_types.txt | 8 +- ...types_without_unification_of_unifiable.txt | 8 +- .../specialize/inspect/opaque_automatic.txt | 4 +- .../inspect/opaque_automatic_late.txt | 4 +- 49 files changed, 1974 insertions(+), 1673 deletions(-) diff --git a/crates/compiler/builtins/bitcode/src/main.zig b/crates/compiler/builtins/bitcode/src/main.zig index c3aa0312eb..3054508cfa 100644 --- a/crates/compiler/builtins/bitcode/src/main.zig +++ b/crates/compiler/builtins/bitcode/src/main.zig @@ -213,6 +213,8 @@ comptime { exportStrFn(str.strAllocationPtr, "allocation_ptr"); exportStrFn(str.strReleaseExcessCapacity, "release_excess_capacity"); exportStrFn(str.strWithAsciiLowercased, "with_ascii_lowercased"); + exportStrFn(str.strWithAsciiUppercased, "with_ascii_uppercased"); + exportStrFn(str.strCaselessAsciiEquals, "caseless_ascii_equals"); for (INTEGERS) |T| { str.exportFromInt(T, ROC_BUILTINS ++ "." ++ STR ++ ".from_int."); diff --git a/crates/compiler/builtins/bitcode/src/str.zig b/crates/compiler/builtins/bitcode/src/str.zig index a413ac70df..b75fd5234e 100644 --- a/crates/compiler/builtins/bitcode/src/str.zig +++ b/crates/compiler/builtins/bitcode/src/str.zig @@ -2195,6 +2195,135 @@ test "withAsciiLowercased: seamless slice" { try expect(str_result.eq(expected)); } +// Str.with_ascii_uppercased +pub fn strWithAsciiUppercased(string: RocStr) callconv(.C) RocStr { + var new_str = if (string.isUnique()) + string + else blk: { + string.decref(); + break :blk RocStr.fromSlice(string.asSlice()); + }; + + const new_str_bytes = new_str.asU8ptrMut()[0..string.len()]; + for (new_str_bytes) |*c| { + c.* = ascii.toUpper(c.*); + } + return new_str; +} + +test "withAsciiUppercased: small str" { + const original = RocStr.fromSlice("coffé"); + try expect(original.isSmallStr()); + + const expected = RocStr.fromSlice("COFFé"); + defer expected.decref(); + + const str_result = strWithAsciiUppercased(original); + defer str_result.decref(); + + try expect(str_result.isSmallStr()); + try expect(str_result.eq(expected)); +} + +test "withAsciiUppercased: non small str" { + const original = RocStr.fromSlice("coffé coffé coffé coffé coffé coffé"); + defer original.decref(); + try expect(!original.isSmallStr()); + + const expected = RocStr.fromSlice("COFFé COFFé COFFé COFFé COFFé COFFé"); + defer expected.decref(); + + const str_result = strWithAsciiUppercased(original); + + try expect(!str_result.isSmallStr()); + try expect(str_result.eq(expected)); +} + +test "withAsciiUppercased: seamless slice" { + const l = RocStr.fromSlice("coffé coffé coffé coffé coffé coffé"); + const original = substringUnsafeC(l, 1, l.len() - 1); + defer original.decref(); + + try expect(original.isSeamlessSlice()); + + const expected = RocStr.fromSlice("OFFé COFFé COFFé COFFé COFFé COFFé"); + defer expected.decref(); + + const str_result = strWithAsciiUppercased(original); + + try expect(!str_result.isSmallStr()); + try expect(str_result.eq(expected)); +} + +pub fn strCaselessAsciiEquals(self: RocStr, other: RocStr) callconv(.C) bool { + // If they are byte-for-byte equal, they're definitely equal! + if (self.bytes == other.bytes and self.length == other.length and self.capacity_or_alloc_ptr == other.capacity_or_alloc_ptr) { + return true; + } + + return ascii.eqlIgnoreCase(self.asSlice(), other.asSlice()); +} + +test "caselessAsciiEquals: same str" { + const str1 = RocStr.fromSlice("coFféÉ"); + defer str1.decref(); + + const are_equal = strCaselessAsciiEquals(str1, str1); + try expect(are_equal); +} + +test "caselessAsciiEquals: differently capitalized non-ascii char" { + const str1 = RocStr.fromSlice("coffé"); + defer str1.decref(); + try expect(str1.isSmallStr()); + + const str2 = RocStr.fromSlice("coffÉ"); + defer str2.decref(); + + const are_equal = strCaselessAsciiEquals(str1, str2); + try expect(!are_equal); +} + +test "caselessAsciiEquals: small str" { + const str1 = RocStr.fromSlice("coffé"); + defer str1.decref(); + try expect(str1.isSmallStr()); + + const str2 = RocStr.fromSlice("COFFé"); + defer str2.decref(); + + const are_equal = strCaselessAsciiEquals(str1, str2); + try expect(are_equal); +} + +test "caselessAsciiEquals: non small str" { + const str1 = RocStr.fromSlice("coffé coffé coffé coffé coffé coffé"); + defer str1.decref(); + try expect(!str1.isSmallStr()); + + const str2 = RocStr.fromSlice("COFFé COFFé COFFé COFFé COFFé COFFé"); + defer str2.decref(); + + const are_equal = strCaselessAsciiEquals(str1, str2); + + try expect(are_equal); +} + +test "caselessAsciiEquals: seamless slice" { + const l = RocStr.fromSlice("coffé coffé coffé coffé coffé coffé"); + const str1 = substringUnsafeC(l, 1, l.len() - 1); + defer str1.decref(); + + try expect(str1.isSeamlessSlice()); + + const str2 = RocStr.fromSlice("OFFé COFFé COFFé COFFé COFFé COFFé"); + defer str2.decref(); + + const are_equal = strCaselessAsciiEquals(str1, str2); + + try expect(are_equal); +} + fn rcNone(_: ?[*]u8) callconv(.C) void {} fn decStr(ptr: ?[*]u8) callconv(.C) void { diff --git a/crates/compiler/builtins/roc/Str.roc b/crates/compiler/builtins/roc/Str.roc index ebab44c284..bf62fe6030 100644 --- a/crates/compiler/builtins/roc/Str.roc +++ b/crates/compiler/builtins/roc/Str.roc @@ -374,6 +374,8 @@ module [ drop_prefix, drop_suffix, with_ascii_lowercased, + with_ascii_uppercased, + caseless_ascii_equals, ] import Bool exposing [Bool] @@ -1348,7 +1350,71 @@ drop_suffix = |haystack, suffix| ## for Unicode capitalization that can be upgraded independently from the language's builtins. ## ## To do a case-insensitive comparison of the ASCII characters in a string, -## use [`caseless_ascii_equals`](#caseless_ascii_equals). +## use [Str.caseless_ascii_equals]. with_ascii_lowercased : Str -> Str -expect Str.with_ascii_lowercased("cOFFÉ") == "coffÉ" +expect Str.with_ascii_lowercased("CAFÉ") == "cafÉ" + +## Returns a version of the string with all [ASCII characters](https://en.wikipedia.org/wiki/ASCII) uppercased. +## Non-ASCII characters are left unmodified. For example: +## +## ```roc +## expect "café".with_ascii_uppercased() == "CAFé" +## ``` +## +## This function is useful for things like +## [command-line options](https://en.wikipedia.org/wiki/Command-line_interface#Command-line_option) +## and [environment variables](https://en.wikipedia.org/wiki/Environment_variable) +## know in advance that you're dealing with a hardcoded string containing only ASCII characters. +## It has better performance than lowercasing operations which take Unicode into account. +## +## That said, strings received from user input can always contain +## non-ASCII Unicode characters, and uppercasing [Unicode](https://unicode.org) +## works differently in different languages. +## For example, the string `"i"` uppercases to `"I"` in English and to `"İ"` +## (a [dotted I](https://en.wikipedia.org/wiki/%C4%B0)) in Turkish. +## These rules can also change in each Unicode release, +## so we have a separate [`unicode` package](https://github.com/roc-lang/unicode) for Unicode capitalization +## that can be upgraded independently from the language's builtins. +## +## To do a case-insensitive comparison of the ASCII characters in a string, +## use [Str.caseless_ascii_equals]. +with_ascii_uppercased : Str -> Str + +expect Str.with_ascii_uppercased("café") == "CAFé" + +## Returns `True` if all the [ASCII characters](https://en.wikipedia.org/wiki/ASCII) in the string are the same +## when ignoring differences in capitalization. +## Non-ASCII characters must all be exactly the same, +## including capitalization. For example: +## +## ```roc +## expect "café".caseless_ascii_equals("CAFé") +## +## expect !"café".caseless_ascii_equals("CAFÉ") +## ``` +## +## The first call returns `True` because all the ASCII characters are the same +## when ignoring differences in capitalization, and the only non-ASCII character +## (`é`) is the same in both strings. The second call returns `False`because +## `é` and `É` are not ASCII characters, and they are different. +## +## This function is useful for things like [command-line options](https://en.wikipedia.org/wiki/Command-line_interface#Command-line_option) +## and [environment variables](https://en.wikipedia.org/wiki/Environment_variable) +## know in advance that you're dealing with a hardcoded string containing only ASCII characters. +## It has better performance than lowercasing operations which take Unicode into account. +## +## That said, strings received from user input can always contain +## non-ASCII Unicode characters, and lowercasing [Unicode](https://unicode.org) works +## differently in different languages. For example, the string `"I"` lowercases to `"i"` +## in English and to `"ı"` (a [dotless i](https://en.wikipedia.org/wiki/Dotless_I)) +## in Turkish. These rules can also change in each [Unicode release](https://www.unicode.org/releases/), +## so we have separate [`unicode` package](https://github.com/roc-lang/unicode) +## for Unicode capitalization that can be upgraded independently from the language's builtins. +## +## To convert a string's ASCII characters to uppercase or lowercase, use [Str.with_ascii_uppercased] +## and [Str.with_ascii_lowercased]. +caseless_ascii_equals : Str, Str -> Bool + +expect Str.caseless_ascii_equals("café", "CAFé") +expect !Str.caseless_ascii_equals("café", "CAFÉ") diff --git a/crates/compiler/builtins/src/bitcode.rs b/crates/compiler/builtins/src/bitcode.rs index 4110dc08f8..6526e66712 100644 --- a/crates/compiler/builtins/src/bitcode.rs +++ b/crates/compiler/builtins/src/bitcode.rs @@ -360,6 +360,8 @@ pub const STR_WITH_CAPACITY: &str = "roc_builtins.str.with_capacity"; pub const STR_ALLOCATION_PTR: &str = "roc_builtins.str.allocation_ptr"; pub const STR_RELEASE_EXCESS_CAPACITY: &str = "roc_builtins.str.release_excess_capacity"; pub const STR_WITH_ASCII_LOWERCASED: &str = "roc_builtins.str.with_ascii_lowercased"; +pub const STR_WITH_ASCII_UPPERCASED: &str = "roc_builtins.str.with_ascii_uppercased"; +pub const STR_CASELESS_ASCII_EQUALS: &str = "roc_builtins.str.caseless_ascii_equals"; pub const LIST_MAP: &str = "roc_builtins.list.map"; pub const LIST_MAP2: &str = "roc_builtins.list.map2"; diff --git a/crates/compiler/can/src/builtins.rs b/crates/compiler/can/src/builtins.rs index 27ea956385..a84af73cc8 100644 --- a/crates/compiler/can/src/builtins.rs +++ b/crates/compiler/can/src/builtins.rs @@ -132,6 +132,8 @@ map_symbol_to_lowlevel_and_arity! { StrWithCapacity; STR_WITH_CAPACITY; 1, StrReleaseExcessCapacity; STR_RELEASE_EXCESS_CAPACITY; 1, StrWithAsciiLowercased; STR_WITH_ASCII_LOWERCASED; 1, + StrWithAsciiUppercased; STR_WITH_ASCII_UPPERCASED; 1, + StrCaselessAsciiEquals; STR_CASELESS_ASCII_EQUALS; 2, ListLenUsize; LIST_LEN_USIZE; 1, ListLenU64; LIST_LEN_U64; 1, diff --git a/crates/compiler/gen_dev/src/lib.rs b/crates/compiler/gen_dev/src/lib.rs index 9fde41e9e5..19f63c5f29 100644 --- a/crates/compiler/gen_dev/src/lib.rs +++ b/crates/compiler/gen_dev/src/lib.rs @@ -1726,6 +1726,20 @@ trait Backend<'a> { arg_layouts, ret_layout, ), + LowLevel::StrWithAsciiUppercased => self.build_fn_call( + sym, + bitcode::STR_WITH_ASCII_UPPERCASED.to_string(), + args, + arg_layouts, + ret_layout, + ), + LowLevel::StrCaselessAsciiEquals => self.build_fn_call( + sym, + bitcode::STR_CASELESS_ASCII_EQUALS.to_string(), + args, + arg_layouts, + ret_layout, + ), LowLevel::StrToNum => { let number_layout = match self.interner().get_repr(*ret_layout) { LayoutRepr::Struct(field_layouts) => field_layouts[0], // TODO: why is it sometimes a struct? diff --git a/crates/compiler/gen_llvm/src/llvm/lowlevel.rs b/crates/compiler/gen_llvm/src/llvm/lowlevel.rs index a9e48fc49c..16dffe7451 100644 --- a/crates/compiler/gen_llvm/src/llvm/lowlevel.rs +++ b/crates/compiler/gen_llvm/src/llvm/lowlevel.rs @@ -626,6 +626,28 @@ pub(crate) fn run_low_level<'a, 'ctx>( bitcode::STR_WITH_ASCII_LOWERCASED, ) } + StrWithAsciiUppercased => { + arguments!(string); + + call_str_bitcode_fn( + env, + &[string], + &[], + BitcodeReturns::Str, + bitcode::STR_WITH_ASCII_UPPERCASED, + ) + } + StrCaselessAsciiEquals => { + arguments!(string1, string2); + + call_str_bitcode_fn( + env, + &[string1, string2], + &[], + BitcodeReturns::Basic, + bitcode::STR_CASELESS_ASCII_EQUALS, + ) + } ListConcat => { debug_assert_eq!(args.len(), 2); diff --git a/crates/compiler/gen_wasm/src/low_level.rs b/crates/compiler/gen_wasm/src/low_level.rs index f5e07109a2..3b6b47a8c2 100644 --- a/crates/compiler/gen_wasm/src/low_level.rs +++ b/crates/compiler/gen_wasm/src/low_level.rs @@ -262,6 +262,12 @@ impl<'a> LowLevelCall<'a> { StrWithAsciiLowercased => { self.load_args_and_call_zig(backend, bitcode::STR_WITH_ASCII_LOWERCASED) } + StrWithAsciiUppercased => { + self.load_args_and_call_zig(backend, bitcode::STR_WITH_ASCII_UPPERCASED) + } + StrCaselessAsciiEquals => { + self.load_args_and_call_zig(backend, bitcode::STR_CASELESS_ASCII_EQUALS) + } // List ListLenU64 => { diff --git a/crates/compiler/module/src/low_level.rs b/crates/compiler/module/src/low_level.rs index 631fdcdd28..c948da99be 100644 --- a/crates/compiler/module/src/low_level.rs +++ b/crates/compiler/module/src/low_level.rs @@ -28,6 +28,8 @@ pub enum LowLevel { StrWithCapacity, StrReleaseExcessCapacity, StrWithAsciiLowercased, + StrWithAsciiUppercased, + StrCaselessAsciiEquals, ListLenUsize, ListLenU64, ListWithCapacity, @@ -269,6 +271,8 @@ map_symbol_to_lowlevel! { StrWithCapacity <= STR_WITH_CAPACITY; StrReleaseExcessCapacity <= STR_RELEASE_EXCESS_CAPACITY; StrWithAsciiLowercased <= STR_WITH_ASCII_LOWERCASED; + StrWithAsciiUppercased <= STR_WITH_ASCII_UPPERCASED; + StrCaselessAsciiEquals <= STR_CASELESS_ASCII_EQUALS; ListLenU64 <= LIST_LEN_U64; ListLenUsize <= LIST_LEN_USIZE; ListGetCapacity <= LIST_CAPACITY; diff --git a/crates/compiler/module/src/symbol.rs b/crates/compiler/module/src/symbol.rs index bd36f27cf6..c80b0932d5 100644 --- a/crates/compiler/module/src/symbol.rs +++ b/crates/compiler/module/src/symbol.rs @@ -1421,10 +1421,12 @@ define_builtins! { 49 STR_DROP_PREFIX: "drop_prefix" 50 STR_DROP_SUFFIX: "drop_suffix" 51 STR_WITH_ASCII_LOWERCASED: "with_ascii_lowercased" - 52 STR_FROM_UTF16: "from_utf16" - 53 STR_FROM_UTF16_LOSSY: "from_utf16_lossy" - 54 STR_FROM_UTF32: "from_utf32" - 55 STR_FROM_UTF32_LOSSY: "from_utf32_lossy" + 52 STR_WITH_ASCII_UPPERCASED: "with_ascii_uppercased" + 53 STR_CASELESS_ASCII_EQUALS: "caseless_ascii_equals" + 54 STR_FROM_UTF16: "from_utf16" + 55 STR_FROM_UTF16_LOSSY: "from_utf16_lossy" + 56 STR_FROM_UTF32: "from_utf32" + 57 STR_FROM_UTF32_LOSSY: "from_utf32_lossy" } 6 LIST: "List" => { 0 LIST_LIST: "List" exposed_apply_type=true // the List.List type alias diff --git a/crates/compiler/mono/src/drop_specialization.rs b/crates/compiler/mono/src/drop_specialization.rs index e2bcf74aa7..f641237d25 100644 --- a/crates/compiler/mono/src/drop_specialization.rs +++ b/crates/compiler/mono/src/drop_specialization.rs @@ -1550,6 +1550,8 @@ fn low_level_no_rc(lowlevel: &LowLevel) -> RC { StrJoinWith => RC::NoRc, ListSortWith => RC::Rc, StrWithAsciiLowercased => RC::Rc, + StrWithAsciiUppercased => RC::Rc, + StrCaselessAsciiEquals => RC::NoRc, ListAppendUnsafe | ListReserve diff --git a/crates/compiler/mono/src/inc_dec.rs b/crates/compiler/mono/src/inc_dec.rs index 69667961f3..9e3091cdf6 100644 --- a/crates/compiler/mono/src/inc_dec.rs +++ b/crates/compiler/mono/src/inc_dec.rs @@ -1259,6 +1259,8 @@ pub(crate) fn lowlevel_borrow_signature(op: LowLevel) -> &'static [Ownership] { ListIncref => &[OWNED], ListDecref => &[OWNED], StrWithAsciiLowercased => &[OWNED], + StrWithAsciiUppercased => &[OWNED], + StrCaselessAsciiEquals => &[BORROWED, BORROWED], Eq | NotEq => &[BORROWED, BORROWED], diff --git a/crates/compiler/solve/tests/solve_expr.rs b/crates/compiler/solve/tests/solve_expr.rs index af1d37454d..299bb05c16 100644 --- a/crates/compiler/solve/tests/solve_expr.rs +++ b/crates/compiler/solve/tests/solve_expr.rs @@ -3838,6 +3838,30 @@ mod solve_expr { ); } + #[test] + fn str_with_ascii_uppercased() { + infer_eq_without_problem( + indoc!( + r" + Str.with_ascii_uppercased + " + ), + "Str -> Str", + ); + } + + #[test] + fn str_caseless_ascii_equals() { + infer_eq_without_problem( + indoc!( + r" + Str.caseless_ascii_equals + " + ), + "Str, Str -> Bool", + ); + } + #[test] fn list_take_first() { infer_eq_without_problem( diff --git a/crates/compiler/test_gen/src/gen_str.rs b/crates/compiler/test_gen/src/gen_str.rs index da27017878..e98ec4ebfb 100644 --- a/crates/compiler/test_gen/src/gen_str.rs +++ b/crates/compiler/test_gen/src/gen_str.rs @@ -2244,3 +2244,27 @@ fn with_ascii_lowercased_non_zero_refcount() { RocStr ); } + +#[test] +#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))] +fn with_ascii_uppercased() { + assert_evals_to!( + r#" + Str.with_ascii_uppercased("café") + "#, + RocStr::from("CAFé"), + RocStr + ); +} + +#[test] +#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))] +fn caseless_ascii_equals() { + assert_evals_to!( + r#" + Str.caseless_ascii_equals("CAfé", "caFé") + "#, + true, + bool + ); +} diff --git a/crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt b/crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt index f7ad8dbcf9..62450ede64 100644 --- a/crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt +++ b/crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt @@ -41,8 +41,8 @@ procedure Num.51 (#Attr.2, #Attr.3): ret Num.283; procedure Str.3 (#Attr.2, #Attr.3): - let Str.382 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.382; + let Str.387 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.387; procedure Test.1 (Test.5): ret Test.5; diff --git a/crates/compiler/test_mono/generated/dbg_expr.txt b/crates/compiler/test_mono/generated/dbg_expr.txt index eff3de04f6..eff38c6166 100644 --- a/crates/compiler/test_mono/generated/dbg_expr.txt +++ b/crates/compiler/test_mono/generated/dbg_expr.txt @@ -43,8 +43,8 @@ procedure Num.96 (#Attr.2): ret Num.284; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Test.0 (): let Test.4 : I64 = 1i64; diff --git a/crates/compiler/test_mono/generated/dbg_in_expect.txt b/crates/compiler/test_mono/generated/dbg_in_expect.txt index 2f11d82ff7..0407556d5c 100644 --- a/crates/compiler/test_mono/generated/dbg_in_expect.txt +++ b/crates/compiler/test_mono/generated/dbg_in_expect.txt @@ -104,184 +104,184 @@ procedure Num.77 (#Attr.2, #Attr.3): ret Num.293; procedure Str.20 (#Attr.2): - let Str.448 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.448; + let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.453; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Str.35 (#Attr.2, #Attr.3): - let Str.438 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.438; + let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.443; procedure Str.36 (#Attr.2): - let Str.400 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.400; + let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.405; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.398; + let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.403; -procedure Str.38 (Str.211, Str.212): - let Str.394 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.407 : U8 = 1i64; - let Str.408 : U8 = GetTagId Str.394; - let Str.409 : Int1 = lowlevel Eq Str.407 Str.408; - if Str.409 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.394; - let Str.403 : U64 = CallByName Str.36 Str.211; - let Str.404 : U64 = CallByName Str.36 Str.212; - let Str.402 : U64 = CallByName Num.20 Str.403 Str.404; - let Str.214 : U64 = CallByName Num.20 Str.402 Str.213; - let Str.401 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.401 Str.213; - let Str.399 : U64 = CallByName Str.36 Str.212; - let Str.397 : U64 = CallByName Num.51 Str.213 Str.399; - let Str.216 : Str = CallByName Str.37 Str.211 Str.397 Str.214; - let Str.396 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.395 : [C {}, C {Str, Str}] = TagId(1) Str.396; - ret Str.395; +procedure Str.38 (Str.213, Str.214): + let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.412 : U8 = 1i64; + let Str.413 : U8 = GetTagId Str.399; + let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; + if Str.414 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; + let Str.408 : U64 = CallByName Str.36 Str.213; + let Str.409 : U64 = CallByName Str.36 Str.214; + let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; + let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; + let Str.406 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; + let Str.404 : U64 = CallByName Str.36 Str.214; + let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; + let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; + let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; + ret Str.400; else - dec Str.211; - let Str.406 : {} = Struct {}; - let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406; - ret Str.405; + dec Str.213; + let Str.411 : {} = Struct {}; + let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; + ret Str.410; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.476 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.484 : U8 = 1i64; - let Str.485 : U8 = GetTagId Str.476; - let Str.486 : Int1 = lowlevel Eq Str.484 Str.485; - if Str.486 then - let Str.483 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.476; - let Str.194 : Str = StructAtIndex 0 Str.483; - let Str.193 : Str = StructAtIndex 1 Str.483; - let Str.481 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.480 : Str = CallByName Str.20 Str.481; - let Str.479 : Str = CallByName Str.3 Str.480 Str.193; - dec Str.193; - let Str.478 : Str = CallByName Str.3 Str.479 Str.192; - let Str.477 : Str = CallByName Str.62 Str.478 Str.194 Str.191 Str.192; - ret Str.477; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.489 : U8 = 1i64; + let Str.490 : U8 = GetTagId Str.481; + let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; + if Str.491 then + let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; + let Str.196 : Str = StructAtIndex 0 Str.488; + let Str.195 : Str = StructAtIndex 1 Str.488; + let Str.486 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.485 : Str = CallByName Str.20 Str.486; + let Str.484 : Str = CallByName Str.3 Str.485 Str.195; + dec Str.195; + let Str.483 : Str = CallByName Str.3 Str.484 Str.194; + let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; + ret Str.482; else - dec Str.476; - ret Str.190; + dec Str.481; + ret Str.192; -procedure Str.62 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3): - joinpoint Str.384 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.391 : U8 = 1i64; - let Str.392 : U8 = GetTagId Str.385; - let Str.393 : Int1 = lowlevel Eq Str.391 Str.392; - if Str.393 then - dec Str.196; - let Str.390 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385; - let Str.200 : Str = StructAtIndex 0 Str.390; - let Str.199 : Str = StructAtIndex 1 Str.390; - let Str.388 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.387 : Str = CallByName Str.3 Str.388 Str.198; - jump Str.384 Str.387 Str.200 Str.197 Str.198; - else - dec Str.385; +procedure Str.64 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3): + joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.396 : U8 = 1i64; + let Str.397 : U8 = GetTagId Str.390; + let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; + if Str.398 then dec Str.198; - dec Str.197; - let Str.389 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.389; + let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390; + let Str.202 : Str = StructAtIndex 0 Str.395; + let Str.201 : Str = StructAtIndex 1 Str.395; + let Str.393 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.392 : Str = CallByName Str.3 Str.393 Str.200; + jump Str.389 Str.392 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.390; + dec Str.200; + let Str.394 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.394; in inc #Derived_gen.3; inc #Derived_gen.2; - jump Str.384 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3; + jump Str.389 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.411 : U64 = 0i64; - let Str.410 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.411 Str.224; - ret Str.410; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.416 : U64 = 0i64; + let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; + ret Str.415; -procedure Str.64 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7): - joinpoint Str.412 Str.225 Str.226 Str.227 Str.228: - let Str.414 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.414 then - let Str.418 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.418 then - dec Str.226; - dec Str.225; - let Str.419 : [C , C U64] = TagId(1) Str.227; - ret Str.419; +procedure Str.66 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7): + joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: + let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.419 then + let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.423 then + dec Str.227; + dec Str.228; + let Str.424 : [C , C U64] = TagId(1) Str.229; + ret Str.424; else - let Str.417 : U64 = 1i64; - let Str.416 : U64 = CallByName Num.51 Str.227 Str.417; - jump Str.412 Str.225 Str.226 Str.416 Str.228; + let Str.422 : U64 = 1i64; + let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; + jump Str.417 Str.227 Str.228 Str.421 Str.230; else - dec Str.226; - dec Str.225; - let Str.413 : [C , C U64] = TagId(0) ; - ret Str.413; + dec Str.227; + dec Str.228; + let Str.418 : [C , C U64] = TagId(0) ; + ret Str.418; in inc #Derived_gen.5; inc #Derived_gen.4; - jump Str.412 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7; + jump Str.417 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7; -procedure Str.67 (Str.251, Str.252): - let Str.443 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.443 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.448 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.441 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.441 Str.256; - let Str.440 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; + let Str.445 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.421 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.440, Str.257}; - let Str.420 : Int1 = CallByName Str.69 Str.421; - ret Str.420; + inc Str.257; + let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259}; + let Str.425 : Int1 = CallByName Str.71 Str.426; + ret Str.425; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.436 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.437 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.436 Str.437; - let Str.426 : U64 = StructAtIndex 0 Str.259; - let Str.427 : Str = StructAtIndex 1 Str.259; - let Str.429 : Str = StructAtIndex 3 Str.259; - let Str.431 : U64 = StructAtIndex 5 Str.259; - let Str.435 : U64 = 1i64; - let Str.433 : U64 = CallByName Num.51 Str.263 Str.435; - let Str.434 : U64 = 1i64; - let Str.432 : U64 = CallByName Num.51 Str.261 Str.434; - let Str.425 : {U64, Str, U64, Str, U64, U64} = Struct {Str.426, Str.427, Str.432, Str.429, Str.433, Str.431}; - let Str.269 : Int1 = CallByName Str.69 Str.425; - if Str.268 then - ret Str.269; + let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; + let Str.431 : U64 = StructAtIndex 0 Str.261; + let Str.432 : Str = StructAtIndex 1 Str.261; + let Str.434 : Str = StructAtIndex 3 Str.261; + let Str.436 : U64 = StructAtIndex 5 Str.261; + let Str.440 : U64 = 1i64; + let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; + let Str.439 : U64 = 1i64; + let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; + let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; + let Str.271 : Int1 = CallByName Str.71 Str.430; + if Str.270 then + ret Str.271; else - let Str.423 : Int1 = CallByName Bool.1; - ret Str.423; + let Str.428 : Int1 = CallByName Bool.1; + ret Str.428; procedure Test.1 (): let Test.4 : Str = ""; diff --git a/crates/compiler/test_mono/generated/dbg_inside_string.txt b/crates/compiler/test_mono/generated/dbg_inside_string.txt index 5f633e0d15..ec65f87521 100644 --- a/crates/compiler/test_mono/generated/dbg_inside_string.txt +++ b/crates/compiler/test_mono/generated/dbg_inside_string.txt @@ -100,184 +100,184 @@ procedure Num.77 (#Attr.2, #Attr.3): ret Num.293; procedure Str.20 (#Attr.2): - let Str.450 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.450; + let Str.455 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.455; procedure Str.3 (#Attr.2, #Attr.3): - let Str.382 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.382; + let Str.387 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.387; procedure Str.35 (#Attr.2, #Attr.3): - let Str.440 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.440; + let Str.445 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.445; procedure Str.36 (#Attr.2): - let Str.402 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.402; + let Str.407 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.407; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.400 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.400; + let Str.405 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.405; -procedure Str.38 (Str.211, Str.212): - let Str.396 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.409 : U8 = 1i64; - let Str.410 : U8 = GetTagId Str.396; - let Str.411 : Int1 = lowlevel Eq Str.409 Str.410; - if Str.411 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.396; - let Str.405 : U64 = CallByName Str.36 Str.211; - let Str.406 : U64 = CallByName Str.36 Str.212; - let Str.404 : U64 = CallByName Num.20 Str.405 Str.406; - let Str.214 : U64 = CallByName Num.20 Str.404 Str.213; - let Str.403 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.403 Str.213; - let Str.401 : U64 = CallByName Str.36 Str.212; - let Str.399 : U64 = CallByName Num.51 Str.213 Str.401; - let Str.216 : Str = CallByName Str.37 Str.211 Str.399 Str.214; - let Str.398 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.397 : [C {}, C {Str, Str}] = TagId(1) Str.398; - ret Str.397; +procedure Str.38 (Str.213, Str.214): + let Str.401 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.414 : U8 = 1i64; + let Str.415 : U8 = GetTagId Str.401; + let Str.416 : Int1 = lowlevel Eq Str.414 Str.415; + if Str.416 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.401; + let Str.410 : U64 = CallByName Str.36 Str.213; + let Str.411 : U64 = CallByName Str.36 Str.214; + let Str.409 : U64 = CallByName Num.20 Str.410 Str.411; + let Str.216 : U64 = CallByName Num.20 Str.409 Str.215; + let Str.408 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.408 Str.215; + let Str.406 : U64 = CallByName Str.36 Str.214; + let Str.404 : U64 = CallByName Num.51 Str.215 Str.406; + let Str.218 : Str = CallByName Str.37 Str.213 Str.404 Str.216; + let Str.403 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.402 : [C {}, C {Str, Str}] = TagId(1) Str.403; + ret Str.402; else - dec Str.211; - let Str.408 : {} = Struct {}; - let Str.407 : [C {}, C {Str, Str}] = TagId(0) Str.408; - ret Str.407; + dec Str.213; + let Str.413 : {} = Struct {}; + let Str.412 : [C {}, C {Str, Str}] = TagId(0) Str.413; + ret Str.412; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.478 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.486 : U8 = 1i64; - let Str.487 : U8 = GetTagId Str.478; - let Str.488 : Int1 = lowlevel Eq Str.486 Str.487; - if Str.488 then - let Str.485 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.478; - let Str.194 : Str = StructAtIndex 0 Str.485; - let Str.193 : Str = StructAtIndex 1 Str.485; - let Str.483 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.482 : Str = CallByName Str.20 Str.483; - let Str.481 : Str = CallByName Str.3 Str.482 Str.193; - dec Str.193; - let Str.480 : Str = CallByName Str.3 Str.481 Str.192; - let Str.479 : Str = CallByName Str.62 Str.480 Str.194 Str.191 Str.192; - ret Str.479; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.483 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.491 : U8 = 1i64; + let Str.492 : U8 = GetTagId Str.483; + let Str.493 : Int1 = lowlevel Eq Str.491 Str.492; + if Str.493 then + let Str.490 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.483; + let Str.196 : Str = StructAtIndex 0 Str.490; + let Str.195 : Str = StructAtIndex 1 Str.490; + let Str.488 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.487 : Str = CallByName Str.20 Str.488; + let Str.486 : Str = CallByName Str.3 Str.487 Str.195; + dec Str.195; + let Str.485 : Str = CallByName Str.3 Str.486 Str.194; + let Str.484 : Str = CallByName Str.64 Str.485 Str.196 Str.193 Str.194; + ret Str.484; else - dec Str.478; - ret Str.190; + dec Str.483; + ret Str.192; -procedure Str.62 (Bool.24, Bool.25, Bool.26, Bool.27): - joinpoint Str.386 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.387 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.393 : U8 = 1i64; - let Str.394 : U8 = GetTagId Str.387; - let Str.395 : Int1 = lowlevel Eq Str.393 Str.394; - if Str.395 then - dec Str.196; - let Str.392 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.387; - let Str.200 : Str = StructAtIndex 0 Str.392; - let Str.199 : Str = StructAtIndex 1 Str.392; - let Str.390 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.389 : Str = CallByName Str.3 Str.390 Str.198; - jump Str.386 Str.389 Str.200 Str.197 Str.198; - else +procedure Str.64 (Bool.24, Bool.25, Bool.26, Bool.27): + joinpoint Str.391 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.392 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.398 : U8 = 1i64; + let Str.399 : U8 = GetTagId Str.392; + let Str.400 : Int1 = lowlevel Eq Str.398 Str.399; + if Str.400 then dec Str.198; - dec Str.197; - dec Str.387; - let Str.391 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.391; + let Str.397 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.392; + let Str.202 : Str = StructAtIndex 0 Str.397; + let Str.201 : Str = StructAtIndex 1 Str.397; + let Str.395 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.394 : Str = CallByName Str.3 Str.395 Str.200; + jump Str.391 Str.394 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.392; + dec Str.200; + let Str.396 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.396; in inc Bool.26; inc Bool.27; - jump Str.386 Bool.24 Bool.25 Bool.26 Bool.27; + jump Str.391 Bool.24 Bool.25 Bool.26 Bool.27; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.413 : U64 = 0i64; - let Str.412 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.413 Str.224; - ret Str.412; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.418 : U64 = 0i64; + let Str.417 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.418 Str.226; + ret Str.417; -procedure Str.64 (Bool.28, Bool.29, Bool.30, Bool.31): - joinpoint Str.414 Str.225 Str.226 Str.227 Str.228: - let Str.416 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.416 then - let Str.420 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.420 then - dec Str.226; - dec Str.225; - let Str.421 : [C , C U64] = TagId(1) Str.227; - ret Str.421; +procedure Str.66 (Bool.28, Bool.29, Bool.30, Bool.31): + joinpoint Str.419 Str.227 Str.228 Str.229 Str.230: + let Str.421 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.421 then + let Str.425 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.425 then + dec Str.227; + dec Str.228; + let Str.426 : [C , C U64] = TagId(1) Str.229; + ret Str.426; else - let Str.419 : U64 = 1i64; - let Str.418 : U64 = CallByName Num.51 Str.227 Str.419; - jump Str.414 Str.225 Str.226 Str.418 Str.228; + let Str.424 : U64 = 1i64; + let Str.423 : U64 = CallByName Num.51 Str.229 Str.424; + jump Str.419 Str.227 Str.228 Str.423 Str.230; else - dec Str.226; - dec Str.225; - let Str.415 : [C , C U64] = TagId(0) ; - ret Str.415; + dec Str.227; + dec Str.228; + let Str.420 : [C , C U64] = TagId(0) ; + ret Str.420; in inc Bool.29; inc Bool.28; - jump Str.414 Bool.28 Bool.29 Bool.30 Bool.31; + jump Str.419 Bool.28 Bool.29 Bool.30 Bool.31; -procedure Str.67 (Str.251, Str.252): - let Str.445 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.445 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.450 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.450 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.443 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.443 Str.256; - let Str.442 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.448 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.448 Str.258; + let Str.447 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.423 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.442, Str.257}; - let Str.422 : Int1 = CallByName Str.69 Str.423; - ret Str.422; + inc Str.257; + let Str.428 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.447, Str.259}; + let Str.427 : Int1 = CallByName Str.71 Str.428; + ret Str.427; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.438 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.439 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.438 Str.439; - let Str.428 : U64 = StructAtIndex 0 Str.259; - let Str.429 : Str = StructAtIndex 1 Str.259; - let Str.431 : Str = StructAtIndex 3 Str.259; - let Str.433 : U64 = StructAtIndex 5 Str.259; - let Str.437 : U64 = 1i64; - let Str.435 : U64 = CallByName Num.51 Str.263 Str.437; - let Str.436 : U64 = 1i64; - let Str.434 : U64 = CallByName Num.51 Str.261 Str.436; - let Str.427 : {U64, Str, U64, Str, U64, U64} = Struct {Str.428, Str.429, Str.434, Str.431, Str.435, Str.433}; - let Str.269 : Int1 = CallByName Str.69 Str.427; - if Str.268 then - ret Str.269; + let Str.443 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.444 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.443 Str.444; + let Str.433 : U64 = StructAtIndex 0 Str.261; + let Str.434 : Str = StructAtIndex 1 Str.261; + let Str.436 : Str = StructAtIndex 3 Str.261; + let Str.438 : U64 = StructAtIndex 5 Str.261; + let Str.442 : U64 = 1i64; + let Str.440 : U64 = CallByName Num.51 Str.265 Str.442; + let Str.441 : U64 = 1i64; + let Str.439 : U64 = CallByName Num.51 Str.263 Str.441; + let Str.432 : {U64, Str, U64, Str, U64, U64} = Struct {Str.433, Str.434, Str.439, Str.436, Str.440, Str.438}; + let Str.271 : Int1 = CallByName Str.71 Str.432; + if Str.270 then + ret Str.271; else - let Str.425 : Int1 = CallByName Bool.1; - ret Str.425; + let Str.430 : Int1 = CallByName Bool.1; + ret Str.430; procedure Test.0 (): let Test.4 : Str = "Hello "; diff --git a/crates/compiler/test_mono/generated/dbg_nested_expr.txt b/crates/compiler/test_mono/generated/dbg_nested_expr.txt index 4d8a861cab..2b1f5c6994 100644 --- a/crates/compiler/test_mono/generated/dbg_nested_expr.txt +++ b/crates/compiler/test_mono/generated/dbg_nested_expr.txt @@ -39,8 +39,8 @@ procedure Num.96 (#Attr.2): ret Num.283; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Test.0 (): let Test.3 : I64 = 1i64; diff --git a/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt b/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt index 124011850d..f95e57b371 100644 --- a/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt +++ b/crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt @@ -100,184 +100,184 @@ procedure Num.77 (#Attr.2, #Attr.3): ret Num.293; procedure Str.20 (#Attr.2): - let Str.448 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.448; + let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.453; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Str.35 (#Attr.2, #Attr.3): - let Str.438 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.438; + let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.443; procedure Str.36 (#Attr.2): - let Str.400 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.400; + let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.405; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.398; + let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.403; -procedure Str.38 (Str.211, Str.212): - let Str.394 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.407 : U8 = 1i64; - let Str.408 : U8 = GetTagId Str.394; - let Str.409 : Int1 = lowlevel Eq Str.407 Str.408; - if Str.409 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.394; - let Str.403 : U64 = CallByName Str.36 Str.211; - let Str.404 : U64 = CallByName Str.36 Str.212; - let Str.402 : U64 = CallByName Num.20 Str.403 Str.404; - let Str.214 : U64 = CallByName Num.20 Str.402 Str.213; - let Str.401 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.401 Str.213; - let Str.399 : U64 = CallByName Str.36 Str.212; - let Str.397 : U64 = CallByName Num.51 Str.213 Str.399; - let Str.216 : Str = CallByName Str.37 Str.211 Str.397 Str.214; - let Str.396 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.395 : [C {}, C {Str, Str}] = TagId(1) Str.396; - ret Str.395; +procedure Str.38 (Str.213, Str.214): + let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.412 : U8 = 1i64; + let Str.413 : U8 = GetTagId Str.399; + let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; + if Str.414 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; + let Str.408 : U64 = CallByName Str.36 Str.213; + let Str.409 : U64 = CallByName Str.36 Str.214; + let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; + let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; + let Str.406 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; + let Str.404 : U64 = CallByName Str.36 Str.214; + let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; + let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; + let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; + ret Str.400; else - dec Str.211; - let Str.406 : {} = Struct {}; - let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406; - ret Str.405; + dec Str.213; + let Str.411 : {} = Struct {}; + let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; + ret Str.410; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.476 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.484 : U8 = 1i64; - let Str.485 : U8 = GetTagId Str.476; - let Str.486 : Int1 = lowlevel Eq Str.484 Str.485; - if Str.486 then - let Str.483 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.476; - let Str.194 : Str = StructAtIndex 0 Str.483; - let Str.193 : Str = StructAtIndex 1 Str.483; - let Str.481 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.480 : Str = CallByName Str.20 Str.481; - let Str.479 : Str = CallByName Str.3 Str.480 Str.193; - dec Str.193; - let Str.478 : Str = CallByName Str.3 Str.479 Str.192; - let Str.477 : Str = CallByName Str.62 Str.478 Str.194 Str.191 Str.192; - ret Str.477; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.489 : U8 = 1i64; + let Str.490 : U8 = GetTagId Str.481; + let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; + if Str.491 then + let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; + let Str.196 : Str = StructAtIndex 0 Str.488; + let Str.195 : Str = StructAtIndex 1 Str.488; + let Str.486 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.485 : Str = CallByName Str.20 Str.486; + let Str.484 : Str = CallByName Str.3 Str.485 Str.195; + dec Str.195; + let Str.483 : Str = CallByName Str.3 Str.484 Str.194; + let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; + ret Str.482; else - dec Str.476; - ret Str.190; + dec Str.481; + ret Str.192; -procedure Str.62 (Bool.24, Bool.25, Bool.26, Bool.27): - joinpoint Str.384 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.391 : U8 = 1i64; - let Str.392 : U8 = GetTagId Str.385; - let Str.393 : Int1 = lowlevel Eq Str.391 Str.392; - if Str.393 then - dec Str.196; - let Str.390 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385; - let Str.200 : Str = StructAtIndex 0 Str.390; - let Str.199 : Str = StructAtIndex 1 Str.390; - let Str.388 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.387 : Str = CallByName Str.3 Str.388 Str.198; - jump Str.384 Str.387 Str.200 Str.197 Str.198; - else - dec Str.385; +procedure Str.64 (Bool.24, Bool.25, Bool.26, Bool.27): + joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.396 : U8 = 1i64; + let Str.397 : U8 = GetTagId Str.390; + let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; + if Str.398 then dec Str.198; - dec Str.197; - let Str.389 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.389; + let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390; + let Str.202 : Str = StructAtIndex 0 Str.395; + let Str.201 : Str = StructAtIndex 1 Str.395; + let Str.393 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.392 : Str = CallByName Str.3 Str.393 Str.200; + jump Str.389 Str.392 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.390; + dec Str.200; + let Str.394 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.394; in inc Bool.26; inc Bool.27; - jump Str.384 Bool.24 Bool.25 Bool.26 Bool.27; + jump Str.389 Bool.24 Bool.25 Bool.26 Bool.27; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.411 : U64 = 0i64; - let Str.410 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.411 Str.224; - ret Str.410; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.416 : U64 = 0i64; + let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; + ret Str.415; -procedure Str.64 (Bool.28, Bool.29, Bool.30, Bool.31): - joinpoint Str.412 Str.225 Str.226 Str.227 Str.228: - let Str.414 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.414 then - let Str.418 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.418 then - dec Str.226; - dec Str.225; - let Str.419 : [C , C U64] = TagId(1) Str.227; - ret Str.419; +procedure Str.66 (Bool.28, Bool.29, Bool.30, Bool.31): + joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: + let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.419 then + let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.423 then + dec Str.227; + dec Str.228; + let Str.424 : [C , C U64] = TagId(1) Str.229; + ret Str.424; else - let Str.417 : U64 = 1i64; - let Str.416 : U64 = CallByName Num.51 Str.227 Str.417; - jump Str.412 Str.225 Str.226 Str.416 Str.228; + let Str.422 : U64 = 1i64; + let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; + jump Str.417 Str.227 Str.228 Str.421 Str.230; else - dec Str.226; - dec Str.225; - let Str.413 : [C , C U64] = TagId(0) ; - ret Str.413; + dec Str.227; + dec Str.228; + let Str.418 : [C , C U64] = TagId(0) ; + ret Str.418; in inc Bool.29; inc Bool.28; - jump Str.412 Bool.28 Bool.29 Bool.30 Bool.31; + jump Str.417 Bool.28 Bool.29 Bool.30 Bool.31; -procedure Str.67 (Str.251, Str.252): - let Str.443 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.443 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.448 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.441 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.441 Str.256; - let Str.440 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; + let Str.445 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.421 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.440, Str.257}; - let Str.420 : Int1 = CallByName Str.69 Str.421; - ret Str.420; + inc Str.257; + let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259}; + let Str.425 : Int1 = CallByName Str.71 Str.426; + ret Str.425; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.436 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.437 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.436 Str.437; - let Str.426 : U64 = StructAtIndex 0 Str.259; - let Str.427 : Str = StructAtIndex 1 Str.259; - let Str.429 : Str = StructAtIndex 3 Str.259; - let Str.431 : U64 = StructAtIndex 5 Str.259; - let Str.435 : U64 = 1i64; - let Str.433 : U64 = CallByName Num.51 Str.263 Str.435; - let Str.434 : U64 = 1i64; - let Str.432 : U64 = CallByName Num.51 Str.261 Str.434; - let Str.425 : {U64, Str, U64, Str, U64, U64} = Struct {Str.426, Str.427, Str.432, Str.429, Str.433, Str.431}; - let Str.269 : Int1 = CallByName Str.69 Str.425; - if Str.268 then - ret Str.269; + let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; + let Str.431 : U64 = StructAtIndex 0 Str.261; + let Str.432 : Str = StructAtIndex 1 Str.261; + let Str.434 : Str = StructAtIndex 3 Str.261; + let Str.436 : U64 = StructAtIndex 5 Str.261; + let Str.440 : U64 = 1i64; + let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; + let Str.439 : U64 = 1i64; + let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; + let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; + let Str.271 : Int1 = CallByName Str.71 Str.430; + if Str.270 then + ret Str.271; else - let Str.423 : Int1 = CallByName Bool.1; - ret Str.423; + let Str.428 : Int1 = CallByName Bool.1; + ret Str.428; procedure Test.0 (): let Test.3 : Str = ""; diff --git a/crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt b/crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt index 3260a716af..ffcf58d294 100644 --- a/crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt +++ b/crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt @@ -11,8 +11,8 @@ procedure Num.96 (#Attr.2): ret Num.284; procedure Str.3 (#Attr.2, #Attr.3): - let Str.381 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.381; + let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.386; procedure Test.1 (Test.2): let Test.3 : Str = CallByName Num.96 Test.2; diff --git a/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt b/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt index 108cc62f22..a6169ca940 100644 --- a/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt @@ -164,32 +164,32 @@ procedure Num.96 (#Attr.2): ret Num.287; procedure Str.12 (#Attr.2): - let Str.393 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.393; + let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.398; procedure Str.36 (#Attr.2): - let Str.394 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.394; + let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.399; procedure Str.43 (#Attr.2): - let Str.388 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; - ret Str.388; + let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; + ret Str.393; -procedure Str.9 (Str.77): - let Str.78 : {U64, Str, Int1, U8} = CallByName Str.43 Str.77; - let Str.385 : Int1 = StructAtIndex 2 Str.78; - if Str.385 then - let Str.387 : Str = StructAtIndex 1 Str.78; - let Str.386 : [C {U64, U8}, C Str] = TagId(1) Str.387; - ret Str.386; +procedure Str.9 (Str.79): + let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; + let Str.390 : Int1 = StructAtIndex 2 Str.80; + if Str.390 then + let Str.392 : Str = StructAtIndex 1 Str.80; + let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; + ret Str.391; else - let Str.383 : U64 = StructAtIndex 0 Str.78; - let Str.384 : U8 = StructAtIndex 3 Str.78; - let #Derived_gen.45 : Str = StructAtIndex 1 Str.78; + let Str.388 : U64 = StructAtIndex 0 Str.80; + let Str.389 : U8 = StructAtIndex 3 Str.80; + let #Derived_gen.45 : Str = StructAtIndex 1 Str.80; dec #Derived_gen.45; - let Str.382 : {U64, U8} = Struct {Str.383, Str.384}; - let Str.380 : [C {U64, U8}, C Str] = TagId(0) Str.382; - ret Str.380; + let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; + let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; + ret Str.385; procedure Test.20 (Test.56): let Test.325 : Str = CallByName Encode.23 Test.56; diff --git a/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt b/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt index 2bac379a6d..df8b9a15fd 100644 --- a/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt @@ -105,32 +105,32 @@ procedure Num.96 (#Attr.2): ret Num.283; procedure Str.12 (#Attr.2): - let Str.390 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.390; + let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.395; procedure Str.36 (#Attr.2): - let Str.391 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.391; + let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.396; procedure Str.43 (#Attr.2): - let Str.388 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; - ret Str.388; + let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; + ret Str.393; -procedure Str.9 (Str.77): - let Str.78 : {U64, Str, Int1, U8} = CallByName Str.43 Str.77; - let Str.385 : Int1 = StructAtIndex 2 Str.78; - if Str.385 then - let Str.387 : Str = StructAtIndex 1 Str.78; - let Str.386 : [C {U64, U8}, C Str] = TagId(1) Str.387; - ret Str.386; +procedure Str.9 (Str.79): + let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; + let Str.390 : Int1 = StructAtIndex 2 Str.80; + if Str.390 then + let Str.392 : Str = StructAtIndex 1 Str.80; + let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; + ret Str.391; else - let Str.383 : U64 = StructAtIndex 0 Str.78; - let Str.384 : U8 = StructAtIndex 3 Str.78; - let #Derived_gen.24 : Str = StructAtIndex 1 Str.78; + let Str.388 : U64 = StructAtIndex 0 Str.80; + let Str.389 : U8 = StructAtIndex 3 Str.80; + let #Derived_gen.24 : Str = StructAtIndex 1 Str.80; dec #Derived_gen.24; - let Str.382 : {U64, U8} = Struct {Str.383, Str.384}; - let Str.380 : [C {U64, U8}, C Str] = TagId(0) Str.382; - ret Str.380; + let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; + let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; + ret Str.385; procedure Test.20 (Test.56): let Test.292 : Str = CallByName Encode.23 Test.56; diff --git a/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt b/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt index 1c1b720eb6..082024ff67 100644 --- a/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt +++ b/crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt @@ -112,32 +112,32 @@ procedure Num.96 (#Attr.2): ret Num.283; procedure Str.12 (#Attr.2): - let Str.390 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.390; + let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.395; procedure Str.36 (#Attr.2): - let Str.391 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.391; + let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.396; procedure Str.43 (#Attr.2): - let Str.388 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; - ret Str.388; + let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; + ret Str.393; -procedure Str.9 (Str.77): - let Str.78 : {U64, Str, Int1, U8} = CallByName Str.43 Str.77; - let Str.385 : Int1 = StructAtIndex 2 Str.78; - if Str.385 then - let Str.387 : Str = StructAtIndex 1 Str.78; - let Str.386 : [C {U64, U8}, C Str] = TagId(1) Str.387; - ret Str.386; +procedure Str.9 (Str.79): + let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; + let Str.390 : Int1 = StructAtIndex 2 Str.80; + if Str.390 then + let Str.392 : Str = StructAtIndex 1 Str.80; + let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; + ret Str.391; else - let Str.383 : U64 = StructAtIndex 0 Str.78; - let Str.384 : U8 = StructAtIndex 3 Str.78; - let #Derived_gen.28 : Str = StructAtIndex 1 Str.78; + let Str.388 : U64 = StructAtIndex 0 Str.80; + let Str.389 : U8 = StructAtIndex 3 Str.80; + let #Derived_gen.28 : Str = StructAtIndex 1 Str.80; dec #Derived_gen.28; - let Str.382 : {U64, U8} = Struct {Str.383, Str.384}; - let Str.380 : [C {U64, U8}, C Str] = TagId(0) Str.382; - ret Str.380; + let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; + let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; + ret Str.385; procedure Test.20 (Test.56): let Test.296 : Str = CallByName Encode.23 Test.56; diff --git a/crates/compiler/test_mono/generated/encode_derived_string.txt b/crates/compiler/test_mono/generated/encode_derived_string.txt index 158782f712..0926f43ff6 100644 --- a/crates/compiler/test_mono/generated/encode_derived_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_string.txt @@ -38,32 +38,32 @@ procedure Num.96 (#Attr.2): ret Num.283; procedure Str.12 (#Attr.2): - let Str.390 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.390; + let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.395; procedure Str.36 (#Attr.2): - let Str.391 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.391; + let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.396; procedure Str.43 (#Attr.2): - let Str.388 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; - ret Str.388; + let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; + ret Str.393; -procedure Str.9 (Str.77): - let Str.78 : {U64, Str, Int1, U8} = CallByName Str.43 Str.77; - let Str.385 : Int1 = StructAtIndex 2 Str.78; - if Str.385 then - let Str.387 : Str = StructAtIndex 1 Str.78; - let Str.386 : [C {U64, U8}, C Str] = TagId(1) Str.387; - ret Str.386; +procedure Str.9 (Str.79): + let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; + let Str.390 : Int1 = StructAtIndex 2 Str.80; + if Str.390 then + let Str.392 : Str = StructAtIndex 1 Str.80; + let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; + ret Str.391; else - let Str.383 : U64 = StructAtIndex 0 Str.78; - let Str.384 : U8 = StructAtIndex 3 Str.78; - let #Derived_gen.3 : Str = StructAtIndex 1 Str.78; + let Str.388 : U64 = StructAtIndex 0 Str.80; + let Str.389 : U8 = StructAtIndex 3 Str.80; + let #Derived_gen.3 : Str = StructAtIndex 1 Str.80; dec #Derived_gen.3; - let Str.382 : {U64, U8} = Struct {Str.383, Str.384}; - let Str.380 : [C {U64, U8}, C Str] = TagId(0) Str.382; - ret Str.380; + let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; + let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; + ret Str.385; procedure Test.20 (Test.56): let Test.259 : Str = CallByName Encode.23 Test.56; diff --git a/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt b/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt index 4d0dff4622..abffb5efd2 100644 --- a/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt @@ -110,32 +110,32 @@ procedure Num.96 (#Attr.2): ret Num.283; procedure Str.12 (#Attr.2): - let Str.390 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.390; + let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.395; procedure Str.36 (#Attr.2): - let Str.391 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.391; + let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.396; procedure Str.43 (#Attr.2): - let Str.388 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; - ret Str.388; + let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; + ret Str.393; -procedure Str.9 (Str.77): - let Str.78 : {U64, Str, Int1, U8} = CallByName Str.43 Str.77; - let Str.385 : Int1 = StructAtIndex 2 Str.78; - if Str.385 then - let Str.387 : Str = StructAtIndex 1 Str.78; - let Str.386 : [C {U64, U8}, C Str] = TagId(1) Str.387; - ret Str.386; +procedure Str.9 (Str.79): + let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; + let Str.390 : Int1 = StructAtIndex 2 Str.80; + if Str.390 then + let Str.392 : Str = StructAtIndex 1 Str.80; + let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; + ret Str.391; else - let Str.383 : U64 = StructAtIndex 0 Str.78; - let Str.384 : U8 = StructAtIndex 3 Str.78; - let #Derived_gen.27 : Str = StructAtIndex 1 Str.78; + let Str.388 : U64 = StructAtIndex 0 Str.80; + let Str.389 : U8 = StructAtIndex 3 Str.80; + let #Derived_gen.27 : Str = StructAtIndex 1 Str.80; dec #Derived_gen.27; - let Str.382 : {U64, U8} = Struct {Str.383, Str.384}; - let Str.380 : [C {U64, U8}, C Str] = TagId(0) Str.382; - ret Str.380; + let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; + let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; + ret Str.385; procedure Test.20 (Test.56): let Test.297 : Str = CallByName Encode.23 Test.56; diff --git a/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt b/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt index 90f36ce91b..8d20512a8d 100644 --- a/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt +++ b/crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt @@ -113,32 +113,32 @@ procedure Num.96 (#Attr.2): ret Num.283; procedure Str.12 (#Attr.2): - let Str.390 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.390; + let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.395; procedure Str.36 (#Attr.2): - let Str.391 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.391; + let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.396; procedure Str.43 (#Attr.2): - let Str.388 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; - ret Str.388; + let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; + ret Str.393; -procedure Str.9 (Str.77): - let Str.78 : {U64, Str, Int1, U8} = CallByName Str.43 Str.77; - let Str.385 : Int1 = StructAtIndex 2 Str.78; - if Str.385 then - let Str.387 : Str = StructAtIndex 1 Str.78; - let Str.386 : [C {U64, U8}, C Str] = TagId(1) Str.387; - ret Str.386; +procedure Str.9 (Str.79): + let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; + let Str.390 : Int1 = StructAtIndex 2 Str.80; + if Str.390 then + let Str.392 : Str = StructAtIndex 1 Str.80; + let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; + ret Str.391; else - let Str.383 : U64 = StructAtIndex 0 Str.78; - let Str.384 : U8 = StructAtIndex 3 Str.78; - let #Derived_gen.28 : Str = StructAtIndex 1 Str.78; + let Str.388 : U64 = StructAtIndex 0 Str.80; + let Str.389 : U8 = StructAtIndex 3 Str.80; + let #Derived_gen.28 : Str = StructAtIndex 1 Str.80; dec #Derived_gen.28; - let Str.382 : {U64, U8} = Struct {Str.383, Str.384}; - let Str.380 : [C {U64, U8}, C Str] = TagId(0) Str.382; - ret Str.380; + let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; + let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; + ret Str.385; procedure Test.20 (Test.56): let Test.301 : Str = CallByName Encode.23 Test.56; diff --git a/crates/compiler/test_mono/generated/inspect_derived_dict.txt b/crates/compiler/test_mono/generated/inspect_derived_dict.txt index 3065fa676b..f09b5c92c9 100644 --- a/crates/compiler/test_mono/generated/inspect_derived_dict.txt +++ b/crates/compiler/test_mono/generated/inspect_derived_dict.txt @@ -1204,188 +1204,188 @@ procedure Num.96 (#Attr.2): ret Num.440; procedure Str.12 (#Attr.2): - let Str.382 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.382; + let Str.387 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.387; procedure Str.20 (#Attr.2): - let Str.451 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.451; + let Str.456 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.456; procedure Str.3 (#Attr.2, #Attr.3): - let Str.383 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.383; + let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.388; procedure Str.35 (#Attr.2, #Attr.3): - let Str.441 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.441; + let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.446; procedure Str.36 (#Attr.2): - let Str.403 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.403; + let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.408; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.401 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.401; + let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.406; -procedure Str.38 (Str.211, Str.212): - let Str.397 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.410 : U8 = 1i64; - let Str.411 : U8 = GetTagId Str.397; - let Str.412 : Int1 = lowlevel Eq Str.410 Str.411; - if Str.412 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.397; - let Str.406 : U64 = CallByName Str.36 Str.211; - let Str.407 : U64 = CallByName Str.36 Str.212; - let Str.405 : U64 = CallByName Num.20 Str.406 Str.407; - let Str.214 : U64 = CallByName Num.20 Str.405 Str.213; - let Str.404 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.404 Str.213; - let Str.402 : U64 = CallByName Str.36 Str.212; - let Str.400 : U64 = CallByName Num.51 Str.213 Str.402; - let Str.216 : Str = CallByName Str.37 Str.211 Str.400 Str.214; - let Str.399 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.398 : [C {}, C {Str, Str}] = TagId(1) Str.399; - ret Str.398; +procedure Str.38 (Str.213, Str.214): + let Str.402 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.415 : U8 = 1i64; + let Str.416 : U8 = GetTagId Str.402; + let Str.417 : Int1 = lowlevel Eq Str.415 Str.416; + if Str.417 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402; + let Str.411 : U64 = CallByName Str.36 Str.213; + let Str.412 : U64 = CallByName Str.36 Str.214; + let Str.410 : U64 = CallByName Num.20 Str.411 Str.412; + let Str.216 : U64 = CallByName Num.20 Str.410 Str.215; + let Str.409 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.409 Str.215; + let Str.407 : U64 = CallByName Str.36 Str.214; + let Str.405 : U64 = CallByName Num.51 Str.215 Str.407; + let Str.218 : Str = CallByName Str.37 Str.213 Str.405 Str.216; + let Str.404 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404; + ret Str.403; else - dec Str.211; - let Str.409 : {} = Struct {}; - let Str.408 : [C {}, C {Str, Str}] = TagId(0) Str.409; - ret Str.408; + dec Str.213; + let Str.414 : {} = Struct {}; + let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414; + ret Str.413; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.479 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.487 : U8 = 1i64; - let Str.488 : U8 = GetTagId Str.479; - let Str.489 : Int1 = lowlevel Eq Str.487 Str.488; - if Str.489 then - let Str.486 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.479; - let Str.194 : Str = StructAtIndex 0 Str.486; - let Str.193 : Str = StructAtIndex 1 Str.486; - let Str.484 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.483 : Str = CallByName Str.20 Str.484; - let Str.482 : Str = CallByName Str.3 Str.483 Str.193; - dec Str.193; - let Str.481 : Str = CallByName Str.3 Str.482 Str.192; - let Str.480 : Str = CallByName Str.62 Str.481 Str.194 Str.191 Str.192; - ret Str.480; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.492 : U8 = 1i64; + let Str.493 : U8 = GetTagId Str.484; + let Str.494 : Int1 = lowlevel Eq Str.492 Str.493; + if Str.494 then + let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484; + let Str.196 : Str = StructAtIndex 0 Str.491; + let Str.195 : Str = StructAtIndex 1 Str.491; + let Str.489 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.488 : Str = CallByName Str.20 Str.489; + let Str.487 : Str = CallByName Str.3 Str.488 Str.195; + dec Str.195; + let Str.486 : Str = CallByName Str.3 Str.487 Str.194; + let Str.485 : Str = CallByName Str.64 Str.486 Str.196 Str.193 Str.194; + ret Str.485; else - dec Str.479; - ret Str.190; + dec Str.484; + ret Str.192; -procedure Str.62 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12): - joinpoint Str.387 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.388 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.394 : U8 = 1i64; - let Str.395 : U8 = GetTagId Str.388; - let Str.396 : Int1 = lowlevel Eq Str.394 Str.395; - if Str.396 then - dec Str.196; - let Str.393 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.388; - let Str.200 : Str = StructAtIndex 0 Str.393; - let Str.199 : Str = StructAtIndex 1 Str.393; - let Str.391 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.390 : Str = CallByName Str.3 Str.391 Str.198; - jump Str.387 Str.390 Str.200 Str.197 Str.198; - else +procedure Str.64 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12): + joinpoint Str.392 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.399 : U8 = 1i64; + let Str.400 : U8 = GetTagId Str.393; + let Str.401 : Int1 = lowlevel Eq Str.399 Str.400; + if Str.401 then dec Str.198; - dec Str.388; - dec Str.197; - let Str.392 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.392; + let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393; + let Str.202 : Str = StructAtIndex 0 Str.398; + let Str.201 : Str = StructAtIndex 1 Str.398; + let Str.396 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.395 : Str = CallByName Str.3 Str.396 Str.200; + jump Str.392 Str.395 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.393; + dec Str.200; + let Str.397 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.397; in inc #Derived_gen.12; inc #Derived_gen.11; - jump Str.387 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12; + jump Str.392 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.414 : U64 = 0i64; - let Str.413 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.414 Str.224; - ret Str.413; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.419 : U64 = 0i64; + let Str.418 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.419 Str.226; + ret Str.418; -procedure Str.64 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16): - joinpoint Str.415 Str.225 Str.226 Str.227 Str.228: - let Str.417 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.417 then - let Str.421 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.421 then - dec Str.226; - dec Str.225; - let Str.422 : [C , C U64] = TagId(1) Str.227; - ret Str.422; +procedure Str.66 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16): + joinpoint Str.420 Str.227 Str.228 Str.229 Str.230: + let Str.422 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.422 then + let Str.426 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.426 then + dec Str.227; + dec Str.228; + let Str.427 : [C , C U64] = TagId(1) Str.229; + ret Str.427; else - let Str.420 : U64 = 1i64; - let Str.419 : U64 = CallByName Num.51 Str.227 Str.420; - jump Str.415 Str.225 Str.226 Str.419 Str.228; + let Str.425 : U64 = 1i64; + let Str.424 : U64 = CallByName Num.51 Str.229 Str.425; + jump Str.420 Str.227 Str.228 Str.424 Str.230; else - dec Str.226; - dec Str.225; - let Str.416 : [C , C U64] = TagId(0) ; - ret Str.416; + dec Str.227; + dec Str.228; + let Str.421 : [C , C U64] = TagId(0) ; + ret Str.421; in inc #Derived_gen.14; inc #Derived_gen.13; - jump Str.415 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16; + jump Str.420 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16; -procedure Str.67 (Str.251, Str.252): - let Str.446 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.446 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.451 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.451 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.444 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.444 Str.256; - let Str.443 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.449 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.449 Str.258; + let Str.448 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.424 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.443, Str.257}; - let Str.423 : Int1 = CallByName Str.69 Str.424; - ret Str.423; + inc Str.257; + let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.448, Str.259}; + let Str.428 : Int1 = CallByName Str.71 Str.429; + ret Str.428; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.439 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.440 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.439 Str.440; - let Str.429 : U64 = StructAtIndex 0 Str.259; - let Str.430 : Str = StructAtIndex 1 Str.259; - let Str.432 : Str = StructAtIndex 3 Str.259; - let Str.434 : U64 = StructAtIndex 5 Str.259; - let Str.438 : U64 = 1i64; - let Str.436 : U64 = CallByName Num.51 Str.263 Str.438; - let Str.437 : U64 = 1i64; - let Str.435 : U64 = CallByName Num.51 Str.261 Str.437; - let Str.428 : {U64, Str, U64, Str, U64, U64} = Struct {Str.429, Str.430, Str.435, Str.432, Str.436, Str.434}; - let Str.269 : Int1 = CallByName Str.69 Str.428; - if Str.268 then - ret Str.269; + let Str.444 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.445 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.444 Str.445; + let Str.434 : U64 = StructAtIndex 0 Str.261; + let Str.435 : Str = StructAtIndex 1 Str.261; + let Str.437 : Str = StructAtIndex 3 Str.261; + let Str.439 : U64 = StructAtIndex 5 Str.261; + let Str.443 : U64 = 1i64; + let Str.441 : U64 = CallByName Num.51 Str.265 Str.443; + let Str.442 : U64 = 1i64; + let Str.440 : U64 = CallByName Num.51 Str.263 Str.442; + let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439}; + let Str.271 : Int1 = CallByName Str.71 Str.433; + if Str.270 then + ret Str.271; else - let Str.426 : Int1 = CallByName Bool.1; - ret Str.426; + let Str.431 : Int1 = CallByName Bool.1; + ret Str.431; procedure Test.0 (): let Test.8 : Str = "a"; diff --git a/crates/compiler/test_mono/generated/inspect_derived_list.txt b/crates/compiler/test_mono/generated/inspect_derived_list.txt index 8e8fb6bf58..a690b11ad7 100644 --- a/crates/compiler/test_mono/generated/inspect_derived_list.txt +++ b/crates/compiler/test_mono/generated/inspect_derived_list.txt @@ -163,8 +163,8 @@ procedure Num.96 (#Attr.2): ret Num.283; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Test.0 (): let Test.2 : List I64 = Array [1i64, 2i64, 3i64]; diff --git a/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt b/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt index 6950187ead..a13f977bdf 100644 --- a/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt +++ b/crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt @@ -322,184 +322,184 @@ procedure Num.77 (#Attr.2, #Attr.3): ret Num.295; procedure Str.20 (#Attr.2): - let Str.449 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.449; + let Str.454 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.454; procedure Str.3 (#Attr.2, #Attr.3): - let Str.381 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.381; + let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.386; procedure Str.35 (#Attr.2, #Attr.3): - let Str.439 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.439; + let Str.444 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.444; procedure Str.36 (#Attr.2): - let Str.401 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.401; + let Str.406 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.406; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.399 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.399; + let Str.404 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.404; -procedure Str.38 (Str.211, Str.212): - let Str.395 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.408 : U8 = 1i64; - let Str.409 : U8 = GetTagId Str.395; - let Str.410 : Int1 = lowlevel Eq Str.408 Str.409; - if Str.410 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.395; - let Str.404 : U64 = CallByName Str.36 Str.211; - let Str.405 : U64 = CallByName Str.36 Str.212; - let Str.403 : U64 = CallByName Num.20 Str.404 Str.405; - let Str.214 : U64 = CallByName Num.20 Str.403 Str.213; - let Str.402 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.402 Str.213; - let Str.400 : U64 = CallByName Str.36 Str.212; - let Str.398 : U64 = CallByName Num.51 Str.213 Str.400; - let Str.216 : Str = CallByName Str.37 Str.211 Str.398 Str.214; - let Str.397 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.396 : [C {}, C {Str, Str}] = TagId(1) Str.397; - ret Str.396; +procedure Str.38 (Str.213, Str.214): + let Str.400 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.413 : U8 = 1i64; + let Str.414 : U8 = GetTagId Str.400; + let Str.415 : Int1 = lowlevel Eq Str.413 Str.414; + if Str.415 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.400; + let Str.409 : U64 = CallByName Str.36 Str.213; + let Str.410 : U64 = CallByName Str.36 Str.214; + let Str.408 : U64 = CallByName Num.20 Str.409 Str.410; + let Str.216 : U64 = CallByName Num.20 Str.408 Str.215; + let Str.407 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.407 Str.215; + let Str.405 : U64 = CallByName Str.36 Str.214; + let Str.403 : U64 = CallByName Num.51 Str.215 Str.405; + let Str.218 : Str = CallByName Str.37 Str.213 Str.403 Str.216; + let Str.402 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.401 : [C {}, C {Str, Str}] = TagId(1) Str.402; + ret Str.401; else - dec Str.211; - let Str.407 : {} = Struct {}; - let Str.406 : [C {}, C {Str, Str}] = TagId(0) Str.407; - ret Str.406; + dec Str.213; + let Str.412 : {} = Struct {}; + let Str.411 : [C {}, C {Str, Str}] = TagId(0) Str.412; + ret Str.411; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.477 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.485 : U8 = 1i64; - let Str.486 : U8 = GetTagId Str.477; - let Str.487 : Int1 = lowlevel Eq Str.485 Str.486; - if Str.487 then - let Str.484 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.477; - let Str.194 : Str = StructAtIndex 0 Str.484; - let Str.193 : Str = StructAtIndex 1 Str.484; - let Str.482 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.481 : Str = CallByName Str.20 Str.482; - let Str.480 : Str = CallByName Str.3 Str.481 Str.193; - dec Str.193; - let Str.479 : Str = CallByName Str.3 Str.480 Str.192; - let Str.478 : Str = CallByName Str.62 Str.479 Str.194 Str.191 Str.192; - ret Str.478; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.482 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.490 : U8 = 1i64; + let Str.491 : U8 = GetTagId Str.482; + let Str.492 : Int1 = lowlevel Eq Str.490 Str.491; + if Str.492 then + let Str.489 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.482; + let Str.196 : Str = StructAtIndex 0 Str.489; + let Str.195 : Str = StructAtIndex 1 Str.489; + let Str.487 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.486 : Str = CallByName Str.20 Str.487; + let Str.485 : Str = CallByName Str.3 Str.486 Str.195; + dec Str.195; + let Str.484 : Str = CallByName Str.3 Str.485 Str.194; + let Str.483 : Str = CallByName Str.64 Str.484 Str.196 Str.193 Str.194; + ret Str.483; else - dec Str.477; - ret Str.190; + dec Str.482; + ret Str.192; -procedure Str.62 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27): - joinpoint Str.385 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.386 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.392 : U8 = 1i64; - let Str.393 : U8 = GetTagId Str.386; - let Str.394 : Int1 = lowlevel Eq Str.392 Str.393; - if Str.394 then - dec Str.196; - let Str.391 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.386; - let Str.200 : Str = StructAtIndex 0 Str.391; - let Str.199 : Str = StructAtIndex 1 Str.391; - let Str.389 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.388 : Str = CallByName Str.3 Str.389 Str.198; - jump Str.385 Str.388 Str.200 Str.197 Str.198; - else +procedure Str.64 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27): + joinpoint Str.390 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.391 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.397 : U8 = 1i64; + let Str.398 : U8 = GetTagId Str.391; + let Str.399 : Int1 = lowlevel Eq Str.397 Str.398; + if Str.399 then dec Str.198; - dec Str.386; - dec Str.197; - let Str.390 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.390; + let Str.396 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.391; + let Str.202 : Str = StructAtIndex 0 Str.396; + let Str.201 : Str = StructAtIndex 1 Str.396; + let Str.394 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.393 : Str = CallByName Str.3 Str.394 Str.200; + jump Str.390 Str.393 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.391; + dec Str.200; + let Str.395 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.395; in inc #Derived_gen.27; inc #Derived_gen.26; - jump Str.385 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27; + jump Str.390 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.412 : U64 = 0i64; - let Str.411 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.412 Str.224; - ret Str.411; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.417 : U64 = 0i64; + let Str.416 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.417 Str.226; + ret Str.416; -procedure Str.64 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31): - joinpoint Str.413 Str.225 Str.226 Str.227 Str.228: - let Str.415 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.415 then - let Str.419 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.419 then - dec Str.226; - dec Str.225; - let Str.420 : [C , C U64] = TagId(1) Str.227; - ret Str.420; +procedure Str.66 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31): + joinpoint Str.418 Str.227 Str.228 Str.229 Str.230: + let Str.420 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.420 then + let Str.424 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.424 then + dec Str.227; + dec Str.228; + let Str.425 : [C , C U64] = TagId(1) Str.229; + ret Str.425; else - let Str.418 : U64 = 1i64; - let Str.417 : U64 = CallByName Num.51 Str.227 Str.418; - jump Str.413 Str.225 Str.226 Str.417 Str.228; + let Str.423 : U64 = 1i64; + let Str.422 : U64 = CallByName Num.51 Str.229 Str.423; + jump Str.418 Str.227 Str.228 Str.422 Str.230; else - dec Str.226; - dec Str.225; - let Str.414 : [C , C U64] = TagId(0) ; - ret Str.414; + dec Str.227; + dec Str.228; + let Str.419 : [C , C U64] = TagId(0) ; + ret Str.419; in inc #Derived_gen.29; inc #Derived_gen.28; - jump Str.413 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31; + jump Str.418 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31; -procedure Str.67 (Str.251, Str.252): - let Str.444 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.444 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.449 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.449 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.442 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.442 Str.256; - let Str.441 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.447 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.447 Str.258; + let Str.446 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.441, Str.257}; - let Str.421 : Int1 = CallByName Str.69 Str.422; - ret Str.421; + inc Str.257; + let Str.427 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.446, Str.259}; + let Str.426 : Int1 = CallByName Str.71 Str.427; + ret Str.426; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.437 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.438 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.437 Str.438; - let Str.427 : U64 = StructAtIndex 0 Str.259; - let Str.428 : Str = StructAtIndex 1 Str.259; - let Str.430 : Str = StructAtIndex 3 Str.259; - let Str.432 : U64 = StructAtIndex 5 Str.259; - let Str.436 : U64 = 1i64; - let Str.434 : U64 = CallByName Num.51 Str.263 Str.436; - let Str.435 : U64 = 1i64; - let Str.433 : U64 = CallByName Num.51 Str.261 Str.435; - let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.427, Str.428, Str.433, Str.430, Str.434, Str.432}; - let Str.269 : Int1 = CallByName Str.69 Str.426; - if Str.268 then - ret Str.269; + let Str.442 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.443 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.442 Str.443; + let Str.432 : U64 = StructAtIndex 0 Str.261; + let Str.433 : Str = StructAtIndex 1 Str.261; + let Str.435 : Str = StructAtIndex 3 Str.261; + let Str.437 : U64 = StructAtIndex 5 Str.261; + let Str.441 : U64 = 1i64; + let Str.439 : U64 = CallByName Num.51 Str.265 Str.441; + let Str.440 : U64 = 1i64; + let Str.438 : U64 = CallByName Num.51 Str.263 Str.440; + let Str.431 : {U64, Str, U64, Str, U64, U64} = Struct {Str.432, Str.433, Str.438, Str.435, Str.439, Str.437}; + let Str.271 : Int1 = CallByName Str.71 Str.431; + if Str.270 then + ret Str.271; else - let Str.424 : Int1 = CallByName Bool.1; - ret Str.424; + let Str.429 : Int1 = CallByName Bool.1; + ret Str.429; procedure Test.0 (): let Test.4 : Str = "bar"; diff --git a/crates/compiler/test_mono/generated/inspect_derived_record.txt b/crates/compiler/test_mono/generated/inspect_derived_record.txt index c4fbde56a4..9f88f72722 100644 --- a/crates/compiler/test_mono/generated/inspect_derived_record.txt +++ b/crates/compiler/test_mono/generated/inspect_derived_record.txt @@ -198,8 +198,8 @@ procedure Num.96 (#Attr.2): ret Num.284; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Test.0 (): let Test.3 : Decimal = 3dec; diff --git a/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt b/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt index 62a10bc7a9..6dde8dc773 100644 --- a/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt +++ b/crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt @@ -216,184 +216,184 @@ procedure Num.77 (#Attr.2, #Attr.3): ret Num.293; procedure Str.20 (#Attr.2): - let Str.448 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.448; + let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.453; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Str.35 (#Attr.2, #Attr.3): - let Str.438 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.438; + let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.443; procedure Str.36 (#Attr.2): - let Str.400 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.400; + let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.405; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.398; + let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.403; -procedure Str.38 (Str.211, Str.212): - let Str.394 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.407 : U8 = 1i64; - let Str.408 : U8 = GetTagId Str.394; - let Str.409 : Int1 = lowlevel Eq Str.407 Str.408; - if Str.409 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.394; - let Str.403 : U64 = CallByName Str.36 Str.211; - let Str.404 : U64 = CallByName Str.36 Str.212; - let Str.402 : U64 = CallByName Num.20 Str.403 Str.404; - let Str.214 : U64 = CallByName Num.20 Str.402 Str.213; - let Str.401 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.401 Str.213; - let Str.399 : U64 = CallByName Str.36 Str.212; - let Str.397 : U64 = CallByName Num.51 Str.213 Str.399; - let Str.216 : Str = CallByName Str.37 Str.211 Str.397 Str.214; - let Str.396 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.395 : [C {}, C {Str, Str}] = TagId(1) Str.396; - ret Str.395; +procedure Str.38 (Str.213, Str.214): + let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.412 : U8 = 1i64; + let Str.413 : U8 = GetTagId Str.399; + let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; + if Str.414 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; + let Str.408 : U64 = CallByName Str.36 Str.213; + let Str.409 : U64 = CallByName Str.36 Str.214; + let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; + let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; + let Str.406 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; + let Str.404 : U64 = CallByName Str.36 Str.214; + let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; + let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; + let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; + ret Str.400; else - dec Str.211; - let Str.406 : {} = Struct {}; - let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406; - ret Str.405; + dec Str.213; + let Str.411 : {} = Struct {}; + let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; + ret Str.410; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.476 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.484 : U8 = 1i64; - let Str.485 : U8 = GetTagId Str.476; - let Str.486 : Int1 = lowlevel Eq Str.484 Str.485; - if Str.486 then - let Str.483 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.476; - let Str.194 : Str = StructAtIndex 0 Str.483; - let Str.193 : Str = StructAtIndex 1 Str.483; - let Str.481 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.480 : Str = CallByName Str.20 Str.481; - let Str.479 : Str = CallByName Str.3 Str.480 Str.193; - dec Str.193; - let Str.478 : Str = CallByName Str.3 Str.479 Str.192; - let Str.477 : Str = CallByName Str.62 Str.478 Str.194 Str.191 Str.192; - ret Str.477; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.489 : U8 = 1i64; + let Str.490 : U8 = GetTagId Str.481; + let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; + if Str.491 then + let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; + let Str.196 : Str = StructAtIndex 0 Str.488; + let Str.195 : Str = StructAtIndex 1 Str.488; + let Str.486 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.485 : Str = CallByName Str.20 Str.486; + let Str.484 : Str = CallByName Str.3 Str.485 Str.195; + dec Str.195; + let Str.483 : Str = CallByName Str.3 Str.484 Str.194; + let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; + ret Str.482; else - dec Str.476; - ret Str.190; + dec Str.481; + ret Str.192; -procedure Str.62 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15): - joinpoint Str.384 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.391 : U8 = 1i64; - let Str.392 : U8 = GetTagId Str.385; - let Str.393 : Int1 = lowlevel Eq Str.391 Str.392; - if Str.393 then - dec Str.196; - let Str.390 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385; - let Str.200 : Str = StructAtIndex 0 Str.390; - let Str.199 : Str = StructAtIndex 1 Str.390; - let Str.388 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.387 : Str = CallByName Str.3 Str.388 Str.198; - jump Str.384 Str.387 Str.200 Str.197 Str.198; - else - dec Str.385; +procedure Str.64 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15): + joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.396 : U8 = 1i64; + let Str.397 : U8 = GetTagId Str.390; + let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; + if Str.398 then dec Str.198; - dec Str.197; - let Str.389 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.389; + let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390; + let Str.202 : Str = StructAtIndex 0 Str.395; + let Str.201 : Str = StructAtIndex 1 Str.395; + let Str.393 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.392 : Str = CallByName Str.3 Str.393 Str.200; + jump Str.389 Str.392 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.390; + dec Str.200; + let Str.394 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.394; in inc #Derived_gen.14; inc #Derived_gen.15; - jump Str.384 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15; + jump Str.389 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.411 : U64 = 0i64; - let Str.410 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.411 Str.224; - ret Str.410; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.416 : U64 = 0i64; + let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; + ret Str.415; -procedure Str.64 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19): - joinpoint Str.412 Str.225 Str.226 Str.227 Str.228: - let Str.414 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.414 then - let Str.418 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.418 then - dec Str.226; - dec Str.225; - let Str.419 : [C , C U64] = TagId(1) Str.227; - ret Str.419; +procedure Str.66 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19): + joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: + let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.419 then + let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.423 then + dec Str.227; + dec Str.228; + let Str.424 : [C , C U64] = TagId(1) Str.229; + ret Str.424; else - let Str.417 : U64 = 1i64; - let Str.416 : U64 = CallByName Num.51 Str.227 Str.417; - jump Str.412 Str.225 Str.226 Str.416 Str.228; + let Str.422 : U64 = 1i64; + let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; + jump Str.417 Str.227 Str.228 Str.421 Str.230; else - dec Str.226; - dec Str.225; - let Str.413 : [C , C U64] = TagId(0) ; - ret Str.413; + dec Str.227; + dec Str.228; + let Str.418 : [C , C U64] = TagId(0) ; + ret Str.418; in inc #Derived_gen.17; inc #Derived_gen.16; - jump Str.412 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19; + jump Str.417 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19; -procedure Str.67 (Str.251, Str.252): - let Str.443 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.443 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.448 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.441 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.441 Str.256; - let Str.440 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; + let Str.445 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.421 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.440, Str.257}; - let Str.420 : Int1 = CallByName Str.69 Str.421; - ret Str.420; + inc Str.257; + let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259}; + let Str.425 : Int1 = CallByName Str.71 Str.426; + ret Str.425; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.436 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.437 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.436 Str.437; - let Str.426 : U64 = StructAtIndex 0 Str.259; - let Str.427 : Str = StructAtIndex 1 Str.259; - let Str.429 : Str = StructAtIndex 3 Str.259; - let Str.431 : U64 = StructAtIndex 5 Str.259; - let Str.435 : U64 = 1i64; - let Str.433 : U64 = CallByName Num.51 Str.263 Str.435; - let Str.434 : U64 = 1i64; - let Str.432 : U64 = CallByName Num.51 Str.261 Str.434; - let Str.425 : {U64, Str, U64, Str, U64, U64} = Struct {Str.426, Str.427, Str.432, Str.429, Str.433, Str.431}; - let Str.269 : Int1 = CallByName Str.69 Str.425; - if Str.268 then - ret Str.269; + let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; + let Str.431 : U64 = StructAtIndex 0 Str.261; + let Str.432 : Str = StructAtIndex 1 Str.261; + let Str.434 : Str = StructAtIndex 3 Str.261; + let Str.436 : U64 = StructAtIndex 5 Str.261; + let Str.440 : U64 = 1i64; + let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; + let Str.439 : U64 = 1i64; + let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; + let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; + let Str.271 : Int1 = CallByName Str.71 Str.430; + if Str.270 then + ret Str.271; else - let Str.423 : Int1 = CallByName Bool.1; - ret Str.423; + let Str.428 : Int1 = CallByName Bool.1; + ret Str.428; procedure Test.0 (): let Test.3 : Str = "foo"; diff --git a/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt b/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt index 1644ebdbc5..50656f72b9 100644 --- a/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt +++ b/crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt @@ -223,184 +223,184 @@ procedure Num.77 (#Attr.2, #Attr.3): ret Num.293; procedure Str.20 (#Attr.2): - let Str.448 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.448; + let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.453; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Str.35 (#Attr.2, #Attr.3): - let Str.438 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.438; + let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.443; procedure Str.36 (#Attr.2): - let Str.400 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.400; + let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.405; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.398; + let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.403; -procedure Str.38 (Str.211, Str.212): - let Str.394 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.407 : U8 = 1i64; - let Str.408 : U8 = GetTagId Str.394; - let Str.409 : Int1 = lowlevel Eq Str.407 Str.408; - if Str.409 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.394; - let Str.403 : U64 = CallByName Str.36 Str.211; - let Str.404 : U64 = CallByName Str.36 Str.212; - let Str.402 : U64 = CallByName Num.20 Str.403 Str.404; - let Str.214 : U64 = CallByName Num.20 Str.402 Str.213; - let Str.401 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.401 Str.213; - let Str.399 : U64 = CallByName Str.36 Str.212; - let Str.397 : U64 = CallByName Num.51 Str.213 Str.399; - let Str.216 : Str = CallByName Str.37 Str.211 Str.397 Str.214; - let Str.396 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.395 : [C {}, C {Str, Str}] = TagId(1) Str.396; - ret Str.395; +procedure Str.38 (Str.213, Str.214): + let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.412 : U8 = 1i64; + let Str.413 : U8 = GetTagId Str.399; + let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; + if Str.414 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; + let Str.408 : U64 = CallByName Str.36 Str.213; + let Str.409 : U64 = CallByName Str.36 Str.214; + let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; + let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; + let Str.406 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; + let Str.404 : U64 = CallByName Str.36 Str.214; + let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; + let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; + let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; + ret Str.400; else - dec Str.211; - let Str.406 : {} = Struct {}; - let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406; - ret Str.405; + dec Str.213; + let Str.411 : {} = Struct {}; + let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; + ret Str.410; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.520 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.528 : U8 = 1i64; - let Str.529 : U8 = GetTagId Str.520; - let Str.530 : Int1 = lowlevel Eq Str.528 Str.529; - if Str.530 then - let Str.527 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.520; - let Str.194 : Str = StructAtIndex 0 Str.527; - let Str.193 : Str = StructAtIndex 1 Str.527; - let Str.525 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.524 : Str = CallByName Str.20 Str.525; - let Str.523 : Str = CallByName Str.3 Str.524 Str.193; - dec Str.193; - let Str.522 : Str = CallByName Str.3 Str.523 Str.192; - let Str.521 : Str = CallByName Str.62 Str.522 Str.194 Str.191 Str.192; - ret Str.521; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.525 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.533 : U8 = 1i64; + let Str.534 : U8 = GetTagId Str.525; + let Str.535 : Int1 = lowlevel Eq Str.533 Str.534; + if Str.535 then + let Str.532 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.525; + let Str.196 : Str = StructAtIndex 0 Str.532; + let Str.195 : Str = StructAtIndex 1 Str.532; + let Str.530 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.529 : Str = CallByName Str.20 Str.530; + let Str.528 : Str = CallByName Str.3 Str.529 Str.195; + dec Str.195; + let Str.527 : Str = CallByName Str.3 Str.528 Str.194; + let Str.526 : Str = CallByName Str.64 Str.527 Str.196 Str.193 Str.194; + ret Str.526; else - dec Str.520; - ret Str.190; + dec Str.525; + ret Str.192; -procedure Str.62 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19): - joinpoint Str.384 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.391 : U8 = 1i64; - let Str.392 : U8 = GetTagId Str.385; - let Str.393 : Int1 = lowlevel Eq Str.391 Str.392; - if Str.393 then - dec Str.196; - let Str.390 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385; - let Str.200 : Str = StructAtIndex 0 Str.390; - let Str.199 : Str = StructAtIndex 1 Str.390; - let Str.388 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.387 : Str = CallByName Str.3 Str.388 Str.198; - jump Str.384 Str.387 Str.200 Str.197 Str.198; - else - dec Str.385; +procedure Str.64 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19): + joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.396 : U8 = 1i64; + let Str.397 : U8 = GetTagId Str.390; + let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; + if Str.398 then dec Str.198; - dec Str.197; - let Str.389 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.389; + let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390; + let Str.202 : Str = StructAtIndex 0 Str.395; + let Str.201 : Str = StructAtIndex 1 Str.395; + let Str.393 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.392 : Str = CallByName Str.3 Str.393 Str.200; + jump Str.389 Str.392 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.390; + dec Str.200; + let Str.394 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.394; in inc #Derived_gen.18; inc #Derived_gen.19; - jump Str.384 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19; + jump Str.389 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.411 : U64 = 0i64; - let Str.410 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.411 Str.224; - ret Str.410; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.416 : U64 = 0i64; + let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; + ret Str.415; -procedure Str.64 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23): - joinpoint Str.412 Str.225 Str.226 Str.227 Str.228: - let Str.414 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.414 then - let Str.418 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.418 then - dec Str.226; - dec Str.225; - let Str.419 : [C , C U64] = TagId(1) Str.227; - ret Str.419; +procedure Str.66 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23): + joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: + let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.419 then + let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.423 then + dec Str.227; + dec Str.228; + let Str.424 : [C , C U64] = TagId(1) Str.229; + ret Str.424; else - let Str.417 : U64 = 1i64; - let Str.416 : U64 = CallByName Num.51 Str.227 Str.417; - jump Str.412 Str.225 Str.226 Str.416 Str.228; + let Str.422 : U64 = 1i64; + let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; + jump Str.417 Str.227 Str.228 Str.421 Str.230; else - dec Str.226; - dec Str.225; - let Str.413 : [C , C U64] = TagId(0) ; - ret Str.413; + dec Str.227; + dec Str.228; + let Str.418 : [C , C U64] = TagId(0) ; + ret Str.418; in inc #Derived_gen.20; inc #Derived_gen.21; - jump Str.412 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23; + jump Str.417 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23; -procedure Str.67 (Str.251, Str.252): - let Str.443 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.443 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.448 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.441 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.441 Str.256; - let Str.440 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; + let Str.445 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.421 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.440, Str.257}; - let Str.420 : Int1 = CallByName Str.69 Str.421; - ret Str.420; + inc Str.257; + let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259}; + let Str.425 : Int1 = CallByName Str.71 Str.426; + ret Str.425; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.436 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.437 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.436 Str.437; - let Str.426 : U64 = StructAtIndex 0 Str.259; - let Str.427 : Str = StructAtIndex 1 Str.259; - let Str.429 : Str = StructAtIndex 3 Str.259; - let Str.431 : U64 = StructAtIndex 5 Str.259; - let Str.435 : U64 = 1i64; - let Str.433 : U64 = CallByName Num.51 Str.263 Str.435; - let Str.434 : U64 = 1i64; - let Str.432 : U64 = CallByName Num.51 Str.261 Str.434; - let Str.425 : {U64, Str, U64, Str, U64, U64} = Struct {Str.426, Str.427, Str.432, Str.429, Str.433, Str.431}; - let Str.269 : Int1 = CallByName Str.69 Str.425; - if Str.268 then - ret Str.269; + let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; + let Str.431 : U64 = StructAtIndex 0 Str.261; + let Str.432 : Str = StructAtIndex 1 Str.261; + let Str.434 : Str = StructAtIndex 3 Str.261; + let Str.436 : U64 = StructAtIndex 5 Str.261; + let Str.440 : U64 = 1i64; + let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; + let Str.439 : U64 = 1i64; + let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; + let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; + let Str.271 : Int1 = CallByName Str.71 Str.430; + if Str.270 then + ret Str.271; else - let Str.423 : Int1 = CallByName Bool.1; - ret Str.423; + let Str.428 : Int1 = CallByName Bool.1; + ret Str.428; procedure Test.0 (): let Test.3 : Str = "foo"; diff --git a/crates/compiler/test_mono/generated/inspect_derived_string.txt b/crates/compiler/test_mono/generated/inspect_derived_string.txt index 80b2e53b96..e21327e0a8 100644 --- a/crates/compiler/test_mono/generated/inspect_derived_string.txt +++ b/crates/compiler/test_mono/generated/inspect_derived_string.txt @@ -100,184 +100,184 @@ procedure Num.77 (#Attr.2, #Attr.3): ret Num.293; procedure Str.20 (#Attr.2): - let Str.448 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.448; + let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.453; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Str.35 (#Attr.2, #Attr.3): - let Str.438 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.438; + let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.443; procedure Str.36 (#Attr.2): - let Str.400 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.400; + let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.405; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.398; + let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.403; -procedure Str.38 (Str.211, Str.212): - let Str.394 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.407 : U8 = 1i64; - let Str.408 : U8 = GetTagId Str.394; - let Str.409 : Int1 = lowlevel Eq Str.407 Str.408; - if Str.409 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.394; - let Str.403 : U64 = CallByName Str.36 Str.211; - let Str.404 : U64 = CallByName Str.36 Str.212; - let Str.402 : U64 = CallByName Num.20 Str.403 Str.404; - let Str.214 : U64 = CallByName Num.20 Str.402 Str.213; - let Str.401 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.401 Str.213; - let Str.399 : U64 = CallByName Str.36 Str.212; - let Str.397 : U64 = CallByName Num.51 Str.213 Str.399; - let Str.216 : Str = CallByName Str.37 Str.211 Str.397 Str.214; - let Str.396 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.395 : [C {}, C {Str, Str}] = TagId(1) Str.396; - ret Str.395; +procedure Str.38 (Str.213, Str.214): + let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.412 : U8 = 1i64; + let Str.413 : U8 = GetTagId Str.399; + let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; + if Str.414 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; + let Str.408 : U64 = CallByName Str.36 Str.213; + let Str.409 : U64 = CallByName Str.36 Str.214; + let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; + let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; + let Str.406 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; + let Str.404 : U64 = CallByName Str.36 Str.214; + let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; + let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; + let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; + ret Str.400; else - dec Str.211; - let Str.406 : {} = Struct {}; - let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406; - ret Str.405; + dec Str.213; + let Str.411 : {} = Struct {}; + let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; + ret Str.410; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.476 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.484 : U8 = 1i64; - let Str.485 : U8 = GetTagId Str.476; - let Str.486 : Int1 = lowlevel Eq Str.484 Str.485; - if Str.486 then - let Str.483 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.476; - let Str.194 : Str = StructAtIndex 0 Str.483; - let Str.193 : Str = StructAtIndex 1 Str.483; - let Str.481 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.480 : Str = CallByName Str.20 Str.481; - let Str.479 : Str = CallByName Str.3 Str.480 Str.193; - dec Str.193; - let Str.478 : Str = CallByName Str.3 Str.479 Str.192; - let Str.477 : Str = CallByName Str.62 Str.478 Str.194 Str.191 Str.192; - ret Str.477; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.489 : U8 = 1i64; + let Str.490 : U8 = GetTagId Str.481; + let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; + if Str.491 then + let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; + let Str.196 : Str = StructAtIndex 0 Str.488; + let Str.195 : Str = StructAtIndex 1 Str.488; + let Str.486 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.485 : Str = CallByName Str.20 Str.486; + let Str.484 : Str = CallByName Str.3 Str.485 Str.195; + dec Str.195; + let Str.483 : Str = CallByName Str.3 Str.484 Str.194; + let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; + ret Str.482; else - dec Str.476; - ret Str.190; + dec Str.481; + ret Str.192; -procedure Str.62 (Bool.24, Bool.25, Bool.26, Bool.27): - joinpoint Str.384 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.391 : U8 = 1i64; - let Str.392 : U8 = GetTagId Str.385; - let Str.393 : Int1 = lowlevel Eq Str.391 Str.392; - if Str.393 then - dec Str.196; - let Str.390 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385; - let Str.200 : Str = StructAtIndex 0 Str.390; - let Str.199 : Str = StructAtIndex 1 Str.390; - let Str.388 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.387 : Str = CallByName Str.3 Str.388 Str.198; - jump Str.384 Str.387 Str.200 Str.197 Str.198; - else - dec Str.385; +procedure Str.64 (Bool.24, Bool.25, Bool.26, Bool.27): + joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.396 : U8 = 1i64; + let Str.397 : U8 = GetTagId Str.390; + let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; + if Str.398 then dec Str.198; - dec Str.197; - let Str.389 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.389; + let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390; + let Str.202 : Str = StructAtIndex 0 Str.395; + let Str.201 : Str = StructAtIndex 1 Str.395; + let Str.393 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.392 : Str = CallByName Str.3 Str.393 Str.200; + jump Str.389 Str.392 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.390; + dec Str.200; + let Str.394 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.394; in inc Bool.26; inc Bool.27; - jump Str.384 Bool.24 Bool.25 Bool.26 Bool.27; + jump Str.389 Bool.24 Bool.25 Bool.26 Bool.27; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.411 : U64 = 0i64; - let Str.410 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.411 Str.224; - ret Str.410; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.416 : U64 = 0i64; + let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; + ret Str.415; -procedure Str.64 (Bool.28, Bool.29, Bool.30, Bool.31): - joinpoint Str.412 Str.225 Str.226 Str.227 Str.228: - let Str.414 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.414 then - let Str.418 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.418 then - dec Str.226; - dec Str.225; - let Str.419 : [C , C U64] = TagId(1) Str.227; - ret Str.419; +procedure Str.66 (Bool.28, Bool.29, Bool.30, Bool.31): + joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: + let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.419 then + let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.423 then + dec Str.227; + dec Str.228; + let Str.424 : [C , C U64] = TagId(1) Str.229; + ret Str.424; else - let Str.417 : U64 = 1i64; - let Str.416 : U64 = CallByName Num.51 Str.227 Str.417; - jump Str.412 Str.225 Str.226 Str.416 Str.228; + let Str.422 : U64 = 1i64; + let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; + jump Str.417 Str.227 Str.228 Str.421 Str.230; else - dec Str.226; - dec Str.225; - let Str.413 : [C , C U64] = TagId(0) ; - ret Str.413; + dec Str.227; + dec Str.228; + let Str.418 : [C , C U64] = TagId(0) ; + ret Str.418; in inc Bool.29; inc Bool.28; - jump Str.412 Bool.28 Bool.29 Bool.30 Bool.31; + jump Str.417 Bool.28 Bool.29 Bool.30 Bool.31; -procedure Str.67 (Str.251, Str.252): - let Str.443 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.443 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.448 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.441 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.441 Str.256; - let Str.440 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; + let Str.445 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.421 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.440, Str.257}; - let Str.420 : Int1 = CallByName Str.69 Str.421; - ret Str.420; + inc Str.257; + let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259}; + let Str.425 : Int1 = CallByName Str.71 Str.426; + ret Str.425; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.436 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.437 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.436 Str.437; - let Str.426 : U64 = StructAtIndex 0 Str.259; - let Str.427 : Str = StructAtIndex 1 Str.259; - let Str.429 : Str = StructAtIndex 3 Str.259; - let Str.431 : U64 = StructAtIndex 5 Str.259; - let Str.435 : U64 = 1i64; - let Str.433 : U64 = CallByName Num.51 Str.263 Str.435; - let Str.434 : U64 = 1i64; - let Str.432 : U64 = CallByName Num.51 Str.261 Str.434; - let Str.425 : {U64, Str, U64, Str, U64, U64} = Struct {Str.426, Str.427, Str.432, Str.429, Str.433, Str.431}; - let Str.269 : Int1 = CallByName Str.69 Str.425; - if Str.268 then - ret Str.269; + let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; + let Str.431 : U64 = StructAtIndex 0 Str.261; + let Str.432 : Str = StructAtIndex 1 Str.261; + let Str.434 : Str = StructAtIndex 3 Str.261; + let Str.436 : U64 = StructAtIndex 5 Str.261; + let Str.440 : U64 = 1i64; + let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; + let Str.439 : U64 = 1i64; + let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; + let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; + let Str.271 : Int1 = CallByName Str.71 Str.430; + if Str.270 then + ret Str.271; else - let Str.423 : Int1 = CallByName Bool.1; - ret Str.423; + let Str.428 : Int1 = CallByName Bool.1; + ret Str.428; procedure Test.0 (): let Test.2 : Str = "abc"; diff --git a/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt b/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt index fe96fb04cd..3fd1ca66bf 100644 --- a/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt +++ b/crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt @@ -223,184 +223,184 @@ procedure Num.77 (#Attr.2, #Attr.3): ret Num.293; procedure Str.20 (#Attr.2): - let Str.448 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.448; + let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.453; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Str.35 (#Attr.2, #Attr.3): - let Str.438 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.438; + let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.443; procedure Str.36 (#Attr.2): - let Str.400 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.400; + let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.405; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.398; + let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.403; -procedure Str.38 (Str.211, Str.212): - let Str.394 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.407 : U8 = 1i64; - let Str.408 : U8 = GetTagId Str.394; - let Str.409 : Int1 = lowlevel Eq Str.407 Str.408; - if Str.409 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.394; - let Str.403 : U64 = CallByName Str.36 Str.211; - let Str.404 : U64 = CallByName Str.36 Str.212; - let Str.402 : U64 = CallByName Num.20 Str.403 Str.404; - let Str.214 : U64 = CallByName Num.20 Str.402 Str.213; - let Str.401 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.401 Str.213; - let Str.399 : U64 = CallByName Str.36 Str.212; - let Str.397 : U64 = CallByName Num.51 Str.213 Str.399; - let Str.216 : Str = CallByName Str.37 Str.211 Str.397 Str.214; - let Str.396 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.395 : [C {}, C {Str, Str}] = TagId(1) Str.396; - ret Str.395; +procedure Str.38 (Str.213, Str.214): + let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.412 : U8 = 1i64; + let Str.413 : U8 = GetTagId Str.399; + let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; + if Str.414 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; + let Str.408 : U64 = CallByName Str.36 Str.213; + let Str.409 : U64 = CallByName Str.36 Str.214; + let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; + let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; + let Str.406 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; + let Str.404 : U64 = CallByName Str.36 Str.214; + let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; + let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; + let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; + ret Str.400; else - dec Str.211; - let Str.406 : {} = Struct {}; - let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406; - ret Str.405; + dec Str.213; + let Str.411 : {} = Struct {}; + let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; + ret Str.410; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.476 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.484 : U8 = 1i64; - let Str.485 : U8 = GetTagId Str.476; - let Str.486 : Int1 = lowlevel Eq Str.484 Str.485; - if Str.486 then - let Str.483 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.476; - let Str.194 : Str = StructAtIndex 0 Str.483; - let Str.193 : Str = StructAtIndex 1 Str.483; - let Str.481 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.480 : Str = CallByName Str.20 Str.481; - let Str.479 : Str = CallByName Str.3 Str.480 Str.193; - dec Str.193; - let Str.478 : Str = CallByName Str.3 Str.479 Str.192; - let Str.477 : Str = CallByName Str.62 Str.478 Str.194 Str.191 Str.192; - ret Str.477; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.489 : U8 = 1i64; + let Str.490 : U8 = GetTagId Str.481; + let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; + if Str.491 then + let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; + let Str.196 : Str = StructAtIndex 0 Str.488; + let Str.195 : Str = StructAtIndex 1 Str.488; + let Str.486 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.485 : Str = CallByName Str.20 Str.486; + let Str.484 : Str = CallByName Str.3 Str.485 Str.195; + dec Str.195; + let Str.483 : Str = CallByName Str.3 Str.484 Str.194; + let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; + ret Str.482; else - dec Str.476; - ret Str.190; + dec Str.481; + ret Str.192; -procedure Str.62 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15): - joinpoint Str.384 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.391 : U8 = 1i64; - let Str.392 : U8 = GetTagId Str.385; - let Str.393 : Int1 = lowlevel Eq Str.391 Str.392; - if Str.393 then - dec Str.196; - let Str.390 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385; - let Str.200 : Str = StructAtIndex 0 Str.390; - let Str.199 : Str = StructAtIndex 1 Str.390; - let Str.388 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.387 : Str = CallByName Str.3 Str.388 Str.198; - jump Str.384 Str.387 Str.200 Str.197 Str.198; - else - dec Str.385; +procedure Str.64 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15): + joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.396 : U8 = 1i64; + let Str.397 : U8 = GetTagId Str.390; + let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; + if Str.398 then dec Str.198; - dec Str.197; - let Str.389 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.389; + let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390; + let Str.202 : Str = StructAtIndex 0 Str.395; + let Str.201 : Str = StructAtIndex 1 Str.395; + let Str.393 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.392 : Str = CallByName Str.3 Str.393 Str.200; + jump Str.389 Str.392 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.390; + dec Str.200; + let Str.394 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.394; in inc #Derived_gen.14; inc #Derived_gen.15; - jump Str.384 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15; + jump Str.389 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.411 : U64 = 0i64; - let Str.410 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.411 Str.224; - ret Str.410; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.416 : U64 = 0i64; + let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; + ret Str.415; -procedure Str.64 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19): - joinpoint Str.412 Str.225 Str.226 Str.227 Str.228: - let Str.414 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.414 then - let Str.418 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.418 then - dec Str.226; - dec Str.225; - let Str.419 : [C , C U64] = TagId(1) Str.227; - ret Str.419; +procedure Str.66 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19): + joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: + let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.419 then + let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.423 then + dec Str.227; + dec Str.228; + let Str.424 : [C , C U64] = TagId(1) Str.229; + ret Str.424; else - let Str.417 : U64 = 1i64; - let Str.416 : U64 = CallByName Num.51 Str.227 Str.417; - jump Str.412 Str.225 Str.226 Str.416 Str.228; + let Str.422 : U64 = 1i64; + let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; + jump Str.417 Str.227 Str.228 Str.421 Str.230; else - dec Str.226; - dec Str.225; - let Str.413 : [C , C U64] = TagId(0) ; - ret Str.413; + dec Str.227; + dec Str.228; + let Str.418 : [C , C U64] = TagId(0) ; + ret Str.418; in inc #Derived_gen.17; inc #Derived_gen.16; - jump Str.412 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19; + jump Str.417 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19; -procedure Str.67 (Str.251, Str.252): - let Str.443 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.443 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.448 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.441 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.441 Str.256; - let Str.440 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; + let Str.445 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.421 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.440, Str.257}; - let Str.420 : Int1 = CallByName Str.69 Str.421; - ret Str.420; + inc Str.257; + let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259}; + let Str.425 : Int1 = CallByName Str.71 Str.426; + ret Str.425; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.436 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.437 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.436 Str.437; - let Str.426 : U64 = StructAtIndex 0 Str.259; - let Str.427 : Str = StructAtIndex 1 Str.259; - let Str.429 : Str = StructAtIndex 3 Str.259; - let Str.431 : U64 = StructAtIndex 5 Str.259; - let Str.435 : U64 = 1i64; - let Str.433 : U64 = CallByName Num.51 Str.263 Str.435; - let Str.434 : U64 = 1i64; - let Str.432 : U64 = CallByName Num.51 Str.261 Str.434; - let Str.425 : {U64, Str, U64, Str, U64, U64} = Struct {Str.426, Str.427, Str.432, Str.429, Str.433, Str.431}; - let Str.269 : Int1 = CallByName Str.69 Str.425; - if Str.268 then - ret Str.269; + let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; + let Str.431 : U64 = StructAtIndex 0 Str.261; + let Str.432 : Str = StructAtIndex 1 Str.261; + let Str.434 : Str = StructAtIndex 3 Str.261; + let Str.436 : U64 = StructAtIndex 5 Str.261; + let Str.440 : U64 = 1i64; + let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; + let Str.439 : U64 = 1i64; + let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; + let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; + let Str.271 : Int1 = CallByName Str.71 Str.430; + if Str.270 then + ret Str.271; else - let Str.423 : Int1 = CallByName Bool.1; - ret Str.423; + let Str.428 : Int1 = CallByName Bool.1; + ret Str.428; procedure Test.0 (): let Test.4 : Str = "foo"; diff --git a/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt b/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt index fbd3848588..4b2bf17788 100644 --- a/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt +++ b/crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt @@ -226,184 +226,184 @@ procedure Num.77 (#Attr.2, #Attr.3): ret Num.293; procedure Str.20 (#Attr.2): - let Str.448 : Str = lowlevel StrWithCapacity #Attr.2; - ret Str.448; + let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; + ret Str.453; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Str.35 (#Attr.2, #Attr.3): - let Str.438 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; - ret Str.438; + let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; + ret Str.443; procedure Str.36 (#Attr.2): - let Str.400 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.400; + let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.405; procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): - let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; - ret Str.398; + let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; + ret Str.403; -procedure Str.38 (Str.211, Str.212): - let Str.394 : [C , C U64] = CallByName Str.63 Str.211 Str.212; - let Str.407 : U8 = 1i64; - let Str.408 : U8 = GetTagId Str.394; - let Str.409 : Int1 = lowlevel Eq Str.407 Str.408; - if Str.409 then - let Str.213 : U64 = UnionAtIndex (Id 1) (Index 0) Str.394; - let Str.403 : U64 = CallByName Str.36 Str.211; - let Str.404 : U64 = CallByName Str.36 Str.212; - let Str.402 : U64 = CallByName Num.20 Str.403 Str.404; - let Str.214 : U64 = CallByName Num.20 Str.402 Str.213; - let Str.401 : U64 = 0i64; - inc Str.211; - let Str.215 : Str = CallByName Str.37 Str.211 Str.401 Str.213; - let Str.399 : U64 = CallByName Str.36 Str.212; - let Str.397 : U64 = CallByName Num.51 Str.213 Str.399; - let Str.216 : Str = CallByName Str.37 Str.211 Str.397 Str.214; - let Str.396 : {Str, Str} = Struct {Str.216, Str.215}; - let Str.395 : [C {}, C {Str, Str}] = TagId(1) Str.396; - ret Str.395; +procedure Str.38 (Str.213, Str.214): + let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; + let Str.412 : U8 = 1i64; + let Str.413 : U8 = GetTagId Str.399; + let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; + if Str.414 then + let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; + let Str.408 : U64 = CallByName Str.36 Str.213; + let Str.409 : U64 = CallByName Str.36 Str.214; + let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; + let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; + let Str.406 : U64 = 0i64; + inc Str.213; + let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; + let Str.404 : U64 = CallByName Str.36 Str.214; + let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; + let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; + let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; + let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; + ret Str.400; else - dec Str.211; - let Str.406 : {} = Struct {}; - let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406; - ret Str.405; + dec Str.213; + let Str.411 : {} = Struct {}; + let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; + ret Str.410; -procedure Str.45 (Str.190, Str.191, Str.192): - inc Str.190; - let Str.520 : [C {}, C {Str, Str}] = CallByName Str.38 Str.190 Str.191; - let Str.528 : U8 = 1i64; - let Str.529 : U8 = GetTagId Str.520; - let Str.530 : Int1 = lowlevel Eq Str.528 Str.529; - if Str.530 then - let Str.527 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.520; - let Str.194 : Str = StructAtIndex 0 Str.527; - let Str.193 : Str = StructAtIndex 1 Str.527; - let Str.525 : U64 = CallByName Str.36 Str.190; - dec Str.190; - let Str.524 : Str = CallByName Str.20 Str.525; - let Str.523 : Str = CallByName Str.3 Str.524 Str.193; - dec Str.193; - let Str.522 : Str = CallByName Str.3 Str.523 Str.192; - let Str.521 : Str = CallByName Str.62 Str.522 Str.194 Str.191 Str.192; - ret Str.521; +procedure Str.45 (Str.192, Str.193, Str.194): + inc Str.192; + let Str.525 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; + let Str.533 : U8 = 1i64; + let Str.534 : U8 = GetTagId Str.525; + let Str.535 : Int1 = lowlevel Eq Str.533 Str.534; + if Str.535 then + let Str.532 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.525; + let Str.196 : Str = StructAtIndex 0 Str.532; + let Str.195 : Str = StructAtIndex 1 Str.532; + let Str.530 : U64 = CallByName Str.36 Str.192; + dec Str.192; + let Str.529 : Str = CallByName Str.20 Str.530; + let Str.528 : Str = CallByName Str.3 Str.529 Str.195; + dec Str.195; + let Str.527 : Str = CallByName Str.3 Str.528 Str.194; + let Str.526 : Str = CallByName Str.64 Str.527 Str.196 Str.193 Str.194; + ret Str.526; else - dec Str.520; - ret Str.190; + dec Str.525; + ret Str.192; -procedure Str.62 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16): - joinpoint Str.384 Str.195 Str.196 Str.197 Str.198: - inc Str.196; - let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.196 Str.197; - let Str.391 : U8 = 1i64; - let Str.392 : U8 = GetTagId Str.385; - let Str.393 : Int1 = lowlevel Eq Str.391 Str.392; - if Str.393 then - dec Str.196; - let Str.390 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385; - let Str.200 : Str = StructAtIndex 0 Str.390; - let Str.199 : Str = StructAtIndex 1 Str.390; - let Str.388 : Str = CallByName Str.3 Str.195 Str.199; - dec Str.199; - let Str.387 : Str = CallByName Str.3 Str.388 Str.198; - jump Str.384 Str.387 Str.200 Str.197 Str.198; - else - dec Str.385; +procedure Str.64 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16): + joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: + inc Str.198; + let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; + let Str.396 : U8 = 1i64; + let Str.397 : U8 = GetTagId Str.390; + let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; + if Str.398 then dec Str.198; - dec Str.197; - let Str.389 : Str = CallByName Str.3 Str.195 Str.196; - dec Str.196; - ret Str.389; + let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390; + let Str.202 : Str = StructAtIndex 0 Str.395; + let Str.201 : Str = StructAtIndex 1 Str.395; + let Str.393 : Str = CallByName Str.3 Str.197 Str.201; + dec Str.201; + let Str.392 : Str = CallByName Str.3 Str.393 Str.200; + jump Str.389 Str.392 Str.202 Str.199 Str.200; + else + dec Str.199; + dec Str.390; + dec Str.200; + let Str.394 : Str = CallByName Str.3 Str.197 Str.198; + dec Str.198; + ret Str.394; in inc #Derived_gen.15; inc #Derived_gen.16; - jump Str.384 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16; + jump Str.389 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16; -procedure Str.63 (Str.220, Str.221): - let Str.222 : U64 = CallByName Str.36 Str.220; - let Str.223 : U64 = CallByName Str.36 Str.221; - let Str.224 : U64 = CallByName Num.77 Str.222 Str.223; - let Str.411 : U64 = 0i64; - let Str.410 : [C , C U64] = CallByName Str.64 Str.220 Str.221 Str.411 Str.224; - ret Str.410; +procedure Str.65 (Str.222, Str.223): + let Str.224 : U64 = CallByName Str.36 Str.222; + let Str.225 : U64 = CallByName Str.36 Str.223; + let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; + let Str.416 : U64 = 0i64; + let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; + ret Str.415; -procedure Str.64 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20): - joinpoint Str.412 Str.225 Str.226 Str.227 Str.228: - let Str.414 : Int1 = CallByName Num.23 Str.227 Str.228; - if Str.414 then - let Str.418 : Int1 = CallByName Str.68 Str.225 Str.227 Str.226; - if Str.418 then - dec Str.226; - dec Str.225; - let Str.419 : [C , C U64] = TagId(1) Str.227; - ret Str.419; +procedure Str.66 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20): + joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: + let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; + if Str.419 then + let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; + if Str.423 then + dec Str.227; + dec Str.228; + let Str.424 : [C , C U64] = TagId(1) Str.229; + ret Str.424; else - let Str.417 : U64 = 1i64; - let Str.416 : U64 = CallByName Num.51 Str.227 Str.417; - jump Str.412 Str.225 Str.226 Str.416 Str.228; + let Str.422 : U64 = 1i64; + let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; + jump Str.417 Str.227 Str.228 Str.421 Str.230; else - dec Str.226; - dec Str.225; - let Str.413 : [C , C U64] = TagId(0) ; - ret Str.413; + dec Str.227; + dec Str.228; + let Str.418 : [C , C U64] = TagId(0) ; + ret Str.418; in inc #Derived_gen.17; inc #Derived_gen.18; - jump Str.412 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20; + jump Str.417 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20; -procedure Str.67 (Str.251, Str.252): - let Str.443 : Int1 = CallByName Num.22 Str.251 Str.252; - if Str.443 then - ret Str.251; +procedure Str.69 (Str.253, Str.254): + let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; + if Str.448 then + ret Str.253; else - ret Str.252; + ret Str.254; -procedure Str.68 (Str.253, Str.254, Str.255): - let Str.256 : U64 = CallByName Str.36 Str.253; - let Str.257 : U64 = CallByName Str.36 Str.255; - let Str.441 : U64 = CallByName Num.53 Str.254 Str.257; - let Str.258 : U64 = CallByName Str.67 Str.441 Str.256; - let Str.440 : U64 = 0i64; +procedure Str.70 (Str.255, Str.256, Str.257): + let Str.258 : U64 = CallByName Str.36 Str.255; + let Str.259 : U64 = CallByName Str.36 Str.257; + let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; + let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; + let Str.445 : U64 = 0i64; inc Str.255; - inc Str.253; - let Str.421 : {U64, Str, U64, Str, U64, U64} = Struct {Str.258, Str.253, Str.254, Str.255, Str.440, Str.257}; - let Str.420 : Int1 = CallByName Str.69 Str.421; - ret Str.420; + inc Str.257; + let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259}; + let Str.425 : Int1 = CallByName Str.71 Str.426; + ret Str.425; -procedure Str.69 (Str.259): - let Str.265 : U64 = StructAtIndex 0 Str.259; - let Str.260 : Str = StructAtIndex 1 Str.259; - let Str.261 : U64 = StructAtIndex 2 Str.259; - let Str.262 : Str = StructAtIndex 3 Str.259; - let Str.263 : U64 = StructAtIndex 4 Str.259; - let Str.264 : U64 = StructAtIndex 5 Str.259; - let Str.266 : Int1 = CallByName Num.25 Str.261 Str.265; - if Str.266 then +procedure Str.71 (Str.261): + let Str.267 : U64 = StructAtIndex 0 Str.261; + let Str.262 : Str = StructAtIndex 1 Str.261; + let Str.263 : U64 = StructAtIndex 2 Str.261; + let Str.264 : Str = StructAtIndex 3 Str.261; + let Str.265 : U64 = StructAtIndex 4 Str.261; + let Str.266 : U64 = StructAtIndex 5 Str.261; + let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; + if Str.268 then dec Str.262; - dec Str.260; - let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264; - ret Str.267; + dec Str.264; + let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; + ret Str.269; else - let Str.436 : U8 = CallByName Str.35 Str.260 Str.261; - let Str.437 : U8 = CallByName Str.35 Str.262 Str.263; - let Str.268 : Int1 = CallByName Bool.9 Str.436 Str.437; - let Str.426 : U64 = StructAtIndex 0 Str.259; - let Str.427 : Str = StructAtIndex 1 Str.259; - let Str.429 : Str = StructAtIndex 3 Str.259; - let Str.431 : U64 = StructAtIndex 5 Str.259; - let Str.435 : U64 = 1i64; - let Str.433 : U64 = CallByName Num.51 Str.263 Str.435; - let Str.434 : U64 = 1i64; - let Str.432 : U64 = CallByName Num.51 Str.261 Str.434; - let Str.425 : {U64, Str, U64, Str, U64, U64} = Struct {Str.426, Str.427, Str.432, Str.429, Str.433, Str.431}; - let Str.269 : Int1 = CallByName Str.69 Str.425; - if Str.268 then - ret Str.269; + let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; + let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; + let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; + let Str.431 : U64 = StructAtIndex 0 Str.261; + let Str.432 : Str = StructAtIndex 1 Str.261; + let Str.434 : Str = StructAtIndex 3 Str.261; + let Str.436 : U64 = StructAtIndex 5 Str.261; + let Str.440 : U64 = 1i64; + let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; + let Str.439 : U64 = 1i64; + let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; + let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; + let Str.271 : Int1 = CallByName Str.71 Str.430; + if Str.270 then + ret Str.271; else - let Str.423 : Int1 = CallByName Bool.1; - ret Str.423; + let Str.428 : Int1 = CallByName Bool.1; + ret Str.428; procedure Test.0 (): let Test.5 : Str = "foo"; diff --git a/crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt b/crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt index c57e66e09a..6eaa8edcd2 100644 --- a/crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt +++ b/crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt @@ -45,27 +45,27 @@ procedure Num.22 (#Attr.2, #Attr.3): let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; ret Num.283; -procedure Str.27 (Str.183): - let Str.380 : [C Int1, C I64] = CallByName Str.72 Str.183; - ret Str.380; +procedure Str.27 (Str.185): + let Str.385 : [C Int1, C I64] = CallByName Str.74 Str.185; + ret Str.385; procedure Str.42 (#Attr.2): - let Str.388 : {I64, U8} = lowlevel StrToNum #Attr.2; - ret Str.388; + let Str.393 : {I64, U8} = lowlevel StrToNum #Attr.2; + ret Str.393; -procedure Str.72 (Str.290): - let Str.291 : {I64, U8} = CallByName Str.42 Str.290; - let Str.386 : U8 = StructAtIndex 1 Str.291; - let Str.387 : U8 = 0i64; - let Str.383 : Int1 = CallByName Bool.9 Str.386 Str.387; - if Str.383 then - let Str.385 : I64 = StructAtIndex 0 Str.291; - let Str.384 : [C Int1, C I64] = TagId(1) Str.385; - ret Str.384; +procedure Str.74 (Str.292): + let Str.293 : {I64, U8} = CallByName Str.42 Str.292; + let Str.391 : U8 = StructAtIndex 1 Str.293; + let Str.392 : U8 = 0i64; + let Str.388 : Int1 = CallByName Bool.9 Str.391 Str.392; + if Str.388 then + let Str.390 : I64 = StructAtIndex 0 Str.293; + let Str.389 : [C Int1, C I64] = TagId(1) Str.390; + ret Str.389; else - let Str.382 : Int1 = false; - let Str.381 : [C Int1, C I64] = TagId(0) Str.382; - ret Str.381; + let Str.387 : Int1 = false; + let Str.386 : [C Int1, C I64] = TagId(0) Str.387; + ret Str.386; procedure Test.0 (): let Test.3 : Int1 = CallByName Bool.2; diff --git a/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt b/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt index 2b6e1ad525..951954cab0 100644 --- a/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt +++ b/crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt @@ -19,30 +19,30 @@ procedure Decode.26 (Decode.109, Decode.110): ret Decode.126; procedure Str.12 (#Attr.2): - let Str.389 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.389; + let Str.394 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.394; -procedure Str.27 (Str.183): - let Str.380 : [C {}, C I64] = CallByName Str.72 Str.183; - ret Str.380; +procedure Str.27 (Str.185): + let Str.385 : [C {}, C I64] = CallByName Str.74 Str.185; + ret Str.385; procedure Str.42 (#Attr.2): - let Str.388 : {I64, U8} = lowlevel StrToNum #Attr.2; - ret Str.388; + let Str.393 : {I64, U8} = lowlevel StrToNum #Attr.2; + ret Str.393; -procedure Str.72 (Str.290): - let Str.291 : {I64, U8} = CallByName Str.42 Str.290; - let Str.386 : U8 = StructAtIndex 1 Str.291; - let Str.387 : U8 = 0i64; - let Str.383 : Int1 = CallByName Bool.9 Str.386 Str.387; - if Str.383 then - let Str.385 : I64 = StructAtIndex 0 Str.291; - let Str.384 : [C {}, C I64] = TagId(1) Str.385; - ret Str.384; +procedure Str.74 (Str.292): + let Str.293 : {I64, U8} = CallByName Str.42 Str.292; + let Str.391 : U8 = StructAtIndex 1 Str.293; + let Str.392 : U8 = 0i64; + let Str.388 : Int1 = CallByName Bool.9 Str.391 Str.392; + if Str.388 then + let Str.390 : I64 = StructAtIndex 0 Str.293; + let Str.389 : [C {}, C I64] = TagId(1) Str.390; + ret Str.389; else - let Str.382 : {} = Struct {}; - let Str.381 : [C {}, C I64] = TagId(0) Str.382; - ret Str.381; + let Str.387 : {} = Struct {}; + let Str.386 : [C {}, C I64] = TagId(0) Str.387; + ret Str.386; procedure Test.103 (): let Test.101 : [C Str, C {List U8, I64}] = CallByName Test.19; diff --git a/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt b/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt index dcfb879652..c46dc877bc 100644 --- a/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt +++ b/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt @@ -1,6 +1,6 @@ procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Test.1 (Test.5): let Test.16 : [C {}, C U64, C Str] = TagId(0) Test.5; diff --git a/crates/compiler/test_mono/generated/list_map_closure_borrows.txt b/crates/compiler/test_mono/generated/list_map_closure_borrows.txt index 2fb956ba13..3c606f4386 100644 --- a/crates/compiler/test_mono/generated/list_map_closure_borrows.txt +++ b/crates/compiler/test_mono/generated/list_map_closure_borrows.txt @@ -71,12 +71,12 @@ procedure Num.51 (#Attr.2, #Attr.3): ret Num.285; procedure Str.16 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrRepeat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrRepeat #Attr.2 #Attr.3; + ret Str.385; procedure Str.3 (#Attr.2, #Attr.3): - let Str.381 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.381; + let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.386; procedure Test.1 (): let Test.21 : Str = "lllllllllllllllllllllooooooooooong"; diff --git a/crates/compiler/test_mono/generated/list_map_closure_owns.txt b/crates/compiler/test_mono/generated/list_map_closure_owns.txt index 9f099628b0..e11e9596e5 100644 --- a/crates/compiler/test_mono/generated/list_map_closure_owns.txt +++ b/crates/compiler/test_mono/generated/list_map_closure_owns.txt @@ -70,8 +70,8 @@ procedure Num.51 (#Attr.2, #Attr.3): ret Num.285; procedure Str.3 (#Attr.2, #Attr.3): - let Str.381 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.381; + let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.386; procedure Test.1 (): let Test.21 : Str = "lllllllllllllllllllllooooooooooong"; diff --git a/crates/compiler/test_mono/generated/pizza_dbg.txt b/crates/compiler/test_mono/generated/pizza_dbg.txt index 04b319e2c7..e23cced881 100644 --- a/crates/compiler/test_mono/generated/pizza_dbg.txt +++ b/crates/compiler/test_mono/generated/pizza_dbg.txt @@ -43,8 +43,8 @@ procedure Num.96 (#Attr.2): ret Num.284; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Test.0 (): let Test.2 : I64 = 1i64; diff --git a/crates/compiler/test_mono/generated/polymorphic_expression_unification.txt b/crates/compiler/test_mono/generated/polymorphic_expression_unification.txt index 5667d52c3d..6b6af5beaa 100644 --- a/crates/compiler/test_mono/generated/polymorphic_expression_unification.txt +++ b/crates/compiler/test_mono/generated/polymorphic_expression_unification.txt @@ -3,8 +3,8 @@ procedure Bool.9 (#Attr.2, #Attr.3): ret Bool.21; procedure Str.3 (#Attr.2, #Attr.3): - let Str.381 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.381; + let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.386; procedure Test.2 (Test.7): let Test.24 : Str = ".trace(\""; diff --git a/crates/compiler/test_mono/generated/recursively_build_effect.txt b/crates/compiler/test_mono/generated/recursively_build_effect.txt index bfa91f0648..b0ed1a307f 100644 --- a/crates/compiler/test_mono/generated/recursively_build_effect.txt +++ b/crates/compiler/test_mono/generated/recursively_build_effect.txt @@ -3,8 +3,8 @@ procedure Num.20 (#Attr.2, #Attr.3): ret Num.283; procedure Str.3 (#Attr.2, #Attr.3): - let Str.382 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.382; + let Str.387 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.387; procedure Test.11 (Test.29, #Attr.12): let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12; diff --git a/crates/compiler/test_mono/generated/return_annotated.txt b/crates/compiler/test_mono/generated/return_annotated.txt index 6054a6fc0e..d7ba3fd5bb 100644 --- a/crates/compiler/test_mono/generated/return_annotated.txt +++ b/crates/compiler/test_mono/generated/return_annotated.txt @@ -2,27 +2,27 @@ procedure Bool.9 (#Attr.2, #Attr.3): let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3; ret Bool.21; -procedure Str.26 (Str.182): - let Str.380 : [C {}, C U64] = CallByName Str.72 Str.182; - ret Str.380; +procedure Str.26 (Str.184): + let Str.385 : [C {}, C U64] = CallByName Str.74 Str.184; + ret Str.385; procedure Str.42 (#Attr.2): - let Str.388 : {U64, U8} = lowlevel StrToNum #Attr.2; - ret Str.388; + let Str.393 : {U64, U8} = lowlevel StrToNum #Attr.2; + ret Str.393; -procedure Str.72 (Str.290): - let Str.291 : {U64, U8} = CallByName Str.42 Str.290; - let Str.386 : U8 = StructAtIndex 1 Str.291; - let Str.387 : U8 = 0i64; - let Str.383 : Int1 = CallByName Bool.9 Str.386 Str.387; - if Str.383 then - let Str.385 : U64 = StructAtIndex 0 Str.291; - let Str.384 : [C {}, C U64] = TagId(1) Str.385; - ret Str.384; +procedure Str.74 (Str.292): + let Str.293 : {U64, U8} = CallByName Str.42 Str.292; + let Str.391 : U8 = StructAtIndex 1 Str.293; + let Str.392 : U8 = 0i64; + let Str.388 : Int1 = CallByName Bool.9 Str.391 Str.392; + if Str.388 then + let Str.390 : U64 = StructAtIndex 0 Str.293; + let Str.389 : [C {}, C U64] = TagId(1) Str.390; + ret Str.389; else - let Str.382 : {} = Struct {}; - let Str.381 : [C {}, C U64] = TagId(0) Str.382; - ret Str.381; + let Str.387 : {} = Struct {}; + let Str.386 : [C {}, C U64] = TagId(0) Str.387; + ret Str.386; procedure Test.1 (Test.2): joinpoint Test.11 Test.3: diff --git a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt index 7b8472617b..7cbd43bd2a 100644 --- a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt +++ b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt @@ -99,12 +99,12 @@ procedure Num.96 (#Attr.2): ret Num.283; procedure Str.12 (#Attr.2): - let Str.381 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.381; + let Str.386 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.386; procedure Str.36 (#Attr.2): - let Str.382 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.382; + let Str.387 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.387; procedure Test.20 (Test.58): let Test.295 : Str = CallByName Encode.23 Test.58; diff --git a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt index b6e1bb0b17..ce2b6871ba 100644 --- a/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt +++ b/crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt @@ -192,12 +192,12 @@ procedure Num.96 (#Attr.2): ret Num.287; procedure Str.12 (#Attr.2): - let Str.384 : List U8 = lowlevel StrToUtf8 #Attr.2; - ret Str.384; + let Str.389 : List U8 = lowlevel StrToUtf8 #Attr.2; + ret Str.389; procedure Str.36 (#Attr.2): - let Str.385 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; - ret Str.385; + let Str.390 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; + ret Str.390; procedure Test.20 (Test.58): inc Test.58; diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt index 3b96915938..c92017fdfa 100644 --- a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt @@ -46,8 +46,8 @@ procedure Inspect.64 (Inspect.297): ret Inspect.297; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Test.0 (): let Test.4 : {} = Struct {}; diff --git a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt index 03ced7e5fd..27b7be1052 100644 --- a/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt +++ b/crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt @@ -49,8 +49,8 @@ procedure Inspect.64 (Inspect.297): ret Inspect.297; procedure Str.3 (#Attr.2, #Attr.3): - let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3; - ret Str.380; + let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.385; procedure Test.2 (Test.3): let Test.4 : Str = CallByName Inspect.33 Test.3;