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

add with_ascii_uppercased and caseless_ascii_equals to Str

Browse source
This commit is contained in:
Norbert Hajagos 2025-01-23 12:59:52 +01:00
parent 690e690bb7
commit fc0a9ec4cf
No known key found for this signature in database
49 changed files with 1974 additions and 1673 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/compiler/builtins/bitcode/src/main.zig
View file

@ -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.");

129
crates/compiler/builtins/bitcode/src/str.zig
View file

@ -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 {

70
crates/compiler/builtins/roc/Str.roc
View file

@ -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É")

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

@ -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";

2
crates/compiler/can/src/builtins.rs
View file

@ -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,

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

@ -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?

22
crates/compiler/gen_llvm/src/llvm/lowlevel.rs
View file

@ -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);

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

@ -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 => {

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

@ -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;

10
crates/compiler/module/src/symbol.rs
View file

@ -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

2
crates/compiler/mono/src/drop_specialization.rs
View file

@ -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

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

@ -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],

24
crates/compiler/solve/tests/solve_expr.rs
View file

@ -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(

24
crates/compiler/test_gen/src/gen_str.rs
View file

@ -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
);
}

4
crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt generated
View file

@ -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;

4
crates/compiler/test_mono/generated/dbg_expr.txt generated
View file

@ -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;

298
crates/compiler/test_mono/generated/dbg_in_expect.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.398;
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;
else
dec Str.211;
let Str.406 : {} = Struct {};
let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406;
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
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;
else
dec Str.476;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
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;
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.385;
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.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.481;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.423 : Int1 = CallByName Bool.1;
ret Str.423;
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.428 : Int1 = CallByName Bool.1;
ret Str.428;
procedure Test.1 ():
let Test.4 : Str = "";

298
crates/compiler/test_mono/generated/dbg_inside_string.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.400 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.400;
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;
else
dec Str.211;
let Str.408 : {} = Struct {};
let Str.407 : [C {}, C {Str, Str}] = TagId(0) Str.408;
let Str.407 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.407;
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;
else
dec Str.478;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.405 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.405;
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;
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.213;
let Str.413 : {} = Struct {};
let Str.412 : [C {}, C {Str, Str}] = TagId(0) Str.413;
ret Str.412;
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.483;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.425 : Int1 = CallByName Bool.1;
ret Str.425;
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.430 : Int1 = CallByName Bool.1;
ret Str.430;
procedure Test.0 ():
let Test.4 : Str = "Hello ";

4
crates/compiler/test_mono/generated/dbg_nested_expr.txt generated
View file

@ -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;

298
crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.398;
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;
else
dec Str.211;
let Str.406 : {} = Struct {};
let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406;
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
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;
else
dec Str.476;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
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;
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.385;
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.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.481;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.423 : Int1 = CallByName Bool.1;
ret Str.423;
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.428 : Int1 = CallByName Bool.1;
ret Str.428;
procedure Test.0 ():
let Test.3 : Str = "";

4
crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt generated
View file

@ -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;

38
crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt generated
View file

@ -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;

38
crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt generated
View file

@ -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;

38
crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt generated
View file

@ -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;

38
crates/compiler/test_mono/generated/encode_derived_string.txt generated
View file

@ -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;

38
crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt generated
View file

@ -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;

38
crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt generated
View file

@ -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;

302
crates/compiler/test_mono/generated/inspect_derived_dict.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.401 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.401;
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;
else
dec Str.211;
let Str.409 : {} = Struct {};
let Str.408 : [C {}, C {Str, Str}] = TagId(0) Str.409;
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408;
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;
else
dec Str.479;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406;
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;
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.213;
let Str.414 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.413;
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.484;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.426 : Int1 = CallByName Bool.1;
ret Str.426;
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.431 : Int1 = CallByName Bool.1;
ret Str.431;
procedure Test.0 ():
let Test.8 : Str = "a";

4
crates/compiler/test_mono/generated/inspect_derived_list.txt generated
View file

@ -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];

298
crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.399 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.399;
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;
else
dec Str.211;
let Str.407 : {} = Struct {};
let Str.406 : [C {}, C {Str, Str}] = TagId(0) Str.407;
let Str.406 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.406;
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;
else
dec Str.477;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.404 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.404;
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;
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.213;
let Str.412 : {} = Struct {};
let Str.411 : [C {}, C {Str, Str}] = TagId(0) Str.412;
ret Str.411;
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.482;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.424 : Int1 = CallByName Bool.1;
ret Str.424;
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.429 : Int1 = CallByName Bool.1;
ret Str.429;
procedure Test.0 ():
let Test.4 : Str = "bar";

4
crates/compiler/test_mono/generated/inspect_derived_record.txt generated
View file

@ -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;

298
crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.398;
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;
else
dec Str.211;
let Str.406 : {} = Struct {};
let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406;
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
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;
else
dec Str.476;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
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;
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.385;
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.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.481;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.423 : Int1 = CallByName Bool.1;
ret Str.423;
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.428 : Int1 = CallByName Bool.1;
ret Str.428;
procedure Test.0 ():
let Test.3 : Str = "foo";

298
crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.398;
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;
else
dec Str.211;
let Str.406 : {} = Struct {};
let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406;
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
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;
else
dec Str.520;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
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;
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.385;
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.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.525;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.423 : Int1 = CallByName Bool.1;
ret Str.423;
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.428 : Int1 = CallByName Bool.1;
ret Str.428;
procedure Test.0 ():
let Test.3 : Str = "foo";

298
crates/compiler/test_mono/generated/inspect_derived_string.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.398;
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;
else
dec Str.211;
let Str.406 : {} = Struct {};
let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406;
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
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;
else
dec Str.476;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
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;
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.385;
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.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.481;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.423 : Int1 = CallByName Bool.1;
ret Str.423;
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.428 : Int1 = CallByName Bool.1;
ret Str.428;
procedure Test.0 ():
let Test.2 : Str = "abc";

298
crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.398;
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;
else
dec Str.211;
let Str.406 : {} = Struct {};
let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406;
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
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;
else
dec Str.476;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
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;
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.385;
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.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.481;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.423 : Int1 = CallByName Bool.1;
ret Str.423;
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.428 : Int1 = CallByName Bool.1;
ret Str.428;
procedure Test.0 ():
let Test.4 : Str = "foo";

298
crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt generated
View file

@ -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;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.398;
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;
else
dec Str.211;
let Str.406 : {} = Struct {};
let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406;
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
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;
else
dec Str.520;
ret Str.190;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
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;
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.385;
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.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.525;
ret Str.192;
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
dec Str.262;
dec Str.260;
let Str.267 : Int1 = CallByName Bool.9 Str.263 Str.264;
ret Str.267;
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;
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.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
else
let Str.423 : Int1 = CallByName Bool.1;
ret Str.423;
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.428 : Int1 = CallByName Bool.1;
ret Str.428;
procedure Test.0 ():
let Test.5 : Str = "foo";

34
crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt generated
View file

@ -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;

38
crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt generated
View file

@ -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;

4
crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt generated
View file

@ -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;

8
crates/compiler/test_mono/generated/list_map_closure_borrows.txt generated
View file

@ -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";

4
crates/compiler/test_mono/generated/list_map_closure_owns.txt generated
View file

@ -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";

4
crates/compiler/test_mono/generated/pizza_dbg.txt generated
View file

@ -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;

4
crates/compiler/test_mono/generated/polymorphic_expression_unification.txt generated
View file

@ -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(\"";

4
crates/compiler/test_mono/generated/recursively_build_effect.txt generated
View file

@ -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;

34
crates/compiler/test_mono/generated/return_annotated.txt generated
View file

@ -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:

8
crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt generated
View file

@ -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;

8
crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt generated
View file

@ -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;

4
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt
View file

@ -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 {};

4
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt
View file

@ -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;