language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-04 12:18:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Update tests

Browse source
This commit is contained in:
Sam Mohr 2025-01-17 19:10:20 -08:00
parent 1a9668e83a
commit b8de09d048
No known key found for this signature in database
GPG key ID: EA41D161A3C1BC99
61 changed files with 757 additions and 720 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,6 +1,6 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure List.116 (List.563, List.564, List.565):
let List.693 : U64 = 0i64;
@ -95,7 +95,7 @@ procedure Test.1 (Test.2):
let Test.14 : {} = Struct {};
let Test.3 : U64 = CallByName List.26 Test.2 Test.13 Test.14;
let Test.12 : U64 = 0i64;
let Test.10 : Int1 = CallByName Bool.11 Test.3 Test.12;
let Test.10 : Int1 = CallByName Bool.9 Test.3 Test.12;
if Test.10 then
ret Test.2;
else

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

@ -1,6 +1,6 @@
procedure Bool.1 ():
let Bool.23 : Int1 = false;
ret Bool.23;
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Test.2 (Test.6):
let Test.22 : U8 = 1i64;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure List.101 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
joinpoint List.678 List.175 List.176 List.177 List.178 List.179:

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

@ -1,17 +1,17 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.1 ():
let Bool.22 : Int1 = false;
ret Bool.22;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel And #Attr.2 #Attr.3;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Inspect.245 (Inspect.246, Inspect.244):
@ -104,16 +104,16 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -151,24 +151,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
let Str.342 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.350 : U8 = 1i64;
let Str.351 : U8 = GetTagId Str.342;
let Str.352 : Int1 = lowlevel Eq Str.350 Str.351;
if Str.352 then
let Str.349 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.342;
let Str.95 : Str = StructAtIndex 0 Str.349;
let Str.94 : Str = StructAtIndex 1 Str.349;
let Str.347 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
let Str.346 : Str = CallByName Str.20 Str.347;
let Str.345 : Str = CallByName Str.3 Str.346 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
let Str.344 : Str = CallByName Str.3 Str.345 Str.93;
let Str.343 : Str = CallByName Str.56 Str.344 Str.95 Str.92 Str.93;
ret Str.343;
else
dec Str.341;
dec Str.342;
ret Str.91;
procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
@ -232,8 +232,8 @@ procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4
jump Str.278 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.309 then
ret Str.152;
else
ret Str.153;
@ -241,12 +241,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
let Str.306 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
@ -261,24 +261,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.302 Str.303;
let Str.292 : U64 = StructAtIndex 0 Str.160;
let Str.293 : Str = StructAtIndex 1 Str.160;
let Str.295 : Str = StructAtIndex 3 Str.160;
let Str.297 : U64 = StructAtIndex 5 Str.160;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
let Str.170 : Int1 = CallByName Str.63 Str.291;
if Str.169 then
ret Str.170;
else
let Str.289 : Int1 = CallByName Bool.1;
ret Str.289;
procedure Test.1 ():
let Test.4 : Str = "";

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

@ -1,13 +1,13 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.1 ():
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.22;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.245 (Inspect.246, Inspect.244):
@ -100,16 +100,16 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.315 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.315;
let Str.316 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.316;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.248;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.305 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.305;
let Str.306 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.306;
procedure Str.36 (#Attr.2):
let Str.268 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -147,24 +147,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.343 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.351 : U8 = 1i64;
let Str.352 : U8 = GetTagId Str.343;
let Str.353 : Int1 = lowlevel Eq Str.351 Str.352;
if Str.353 then
let Str.350 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.343;
let Str.95 : Str = StructAtIndex 0 Str.350;
let Str.94 : Str = StructAtIndex 1 Str.350;
let Str.348 : U64 = CallByName Str.36 Str.91;
let Str.344 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.352 : U8 = 1i64;
let Str.353 : U8 = GetTagId Str.344;
let Str.354 : Int1 = lowlevel Eq Str.352 Str.353;
if Str.354 then
let Str.351 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.344;
let Str.95 : Str = StructAtIndex 0 Str.351;
let Str.94 : Str = StructAtIndex 1 Str.351;
let Str.349 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.347 : Str = CallByName Str.20 Str.348;
let Str.346 : Str = CallByName Str.3 Str.347 Str.94;
let Str.348 : Str = CallByName Str.20 Str.349;
let Str.347 : Str = CallByName Str.3 Str.348 Str.94;
dec Str.94;
let Str.345 : Str = CallByName Str.3 Str.346 Str.93;
let Str.344 : Str = CallByName Str.56 Str.345 Str.95 Str.92 Str.93;
ret Str.344;
let Str.346 : Str = CallByName Str.3 Str.347 Str.93;
let Str.345 : Str = CallByName Str.56 Str.346 Str.95 Str.92 Str.93;
ret Str.345;
else
dec Str.343;
dec Str.344;
ret Str.91;
procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
@ -228,8 +228,8 @@ procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4
jump Str.280 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Str.61 (Str.152, Str.153):
let Str.310 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.310 then
let Str.311 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.311 then
ret Str.152;
else
ret Str.153;
@ -237,12 +237,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.308 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.308 Str.157;
let Str.307 : U64 = 0i64;
let Str.309 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.309 Str.157;
let Str.308 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.289 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.307, Str.158};
let Str.289 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.308, Str.158};
let Str.288 : Int1 = CallByName Str.63 Str.289;
ret Str.288;
@ -257,24 +257,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.303 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.304 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.303 Str.304;
let Str.293 : U64 = StructAtIndex 0 Str.160;
let Str.294 : Str = StructAtIndex 1 Str.160;
let Str.296 : Str = StructAtIndex 3 Str.160;
let Str.298 : U64 = StructAtIndex 5 Str.160;
let Str.304 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.305 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.304 Str.305;
let Str.294 : U64 = StructAtIndex 0 Str.160;
let Str.295 : Str = StructAtIndex 1 Str.160;
let Str.297 : Str = StructAtIndex 3 Str.160;
let Str.299 : U64 = StructAtIndex 5 Str.160;
let Str.303 : U64 = 1i64;
let Str.301 : U64 = CallByName Num.51 Str.164 Str.303;
let Str.302 : U64 = 1i64;
let Str.300 : U64 = CallByName Num.51 Str.164 Str.302;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.162 Str.301;
let Str.292 : {U64, Str, U64, Str, U64, U64} = Struct {Str.293, Str.294, Str.299, Str.296, Str.300, Str.298};
let Str.170 : Int1 = CallByName Str.63 Str.292;
let Str.291 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.291;
let Str.300 : U64 = CallByName Num.51 Str.162 Str.302;
let Str.293 : {U64, Str, U64, Str, U64, U64} = Struct {Str.294, Str.295, Str.300, Str.297, Str.301, Str.299};
let Str.170 : Int1 = CallByName Str.63 Str.293;
if Str.169 then
ret Str.170;
else
let Str.291 : Int1 = CallByName Bool.1;
ret Str.291;
procedure Test.0 ():
let Test.5 : Str = "Hello ";

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

@ -1,13 +1,13 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.1 ():
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.22;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.245 (Inspect.246, Inspect.244):
@ -100,16 +100,16 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -147,24 +147,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
let Str.342 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.350 : U8 = 1i64;
let Str.351 : U8 = GetTagId Str.342;
let Str.352 : Int1 = lowlevel Eq Str.350 Str.351;
if Str.352 then
let Str.349 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.342;
let Str.95 : Str = StructAtIndex 0 Str.349;
let Str.94 : Str = StructAtIndex 1 Str.349;
let Str.347 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
let Str.346 : Str = CallByName Str.20 Str.347;
let Str.345 : Str = CallByName Str.3 Str.346 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
let Str.344 : Str = CallByName Str.3 Str.345 Str.93;
let Str.343 : Str = CallByName Str.56 Str.344 Str.95 Str.92 Str.93;
ret Str.343;
else
dec Str.341;
dec Str.342;
ret Str.91;
procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
@ -228,8 +228,8 @@ procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4
jump Str.278 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.309 then
ret Str.152;
else
ret Str.153;
@ -237,12 +237,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
let Str.306 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
@ -257,24 +257,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.302 Str.303;
let Str.292 : U64 = StructAtIndex 0 Str.160;
let Str.293 : Str = StructAtIndex 1 Str.160;
let Str.295 : Str = StructAtIndex 3 Str.160;
let Str.297 : U64 = StructAtIndex 5 Str.160;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
let Str.170 : Int1 = CallByName Str.63 Str.291;
if Str.169 then
ret Str.170;
else
let Str.289 : Int1 = CallByName Bool.1;
ret Str.289;
procedure Test.0 ():
let Test.3 : Str = "";

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

@ -1,6 +1,6 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.22;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.285 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
@ -25,7 +25,7 @@ procedure Test.1 (Test.2):
ret Test.8;
in
let Test.22 : I64 = 1i64;
let Test.20 : Int1 = CallByName Bool.11 Test.2 Test.22;
let Test.20 : Int1 = CallByName Bool.9 Test.2 Test.22;
if Test.20 then
dec Test.3;
let Test.21 : Str = "early 1";
@ -38,7 +38,7 @@ procedure Test.1 (Test.2):
jump Test.12 Test.11;
in
let Test.17 : I64 = 2i64;
let Test.15 : Int1 = CallByName Bool.11 Test.2 Test.17;
let Test.15 : Int1 = CallByName Bool.9 Test.2 Test.17;
if Test.15 then
dec Test.3;
dec Test.5;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Test.2 (Test.5):
let Test.6 : Int1 = CallByName Bool.2;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Test.2 (Test.5):
let Test.6 : Int1 = CallByName Bool.2;

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

@ -1,6 +1,6 @@
procedure Bool.1 ():
let Bool.23 : Int1 = false;
ret Bool.23;
let Bool.21 : Int1 = false;
ret Bool.21;
procedure List.2 (List.120, List.121):
let List.681 : U64 = CallByName List.6 List.120;

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

@ -1,6 +1,6 @@
procedure Bool.1 ():
let Bool.23 : Int1 = false;
ret Bool.23;
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Test.1 (Test.2):
let Test.5 : I64 = 2i64;

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

@ -1,6 +1,6 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Test.1 (Test.3):
let Test.6 : I64 = 10i64;
@ -13,7 +13,7 @@ procedure Test.1 (Test.3):
ret Test.8;
in
let Test.12 : I64 = 5i64;
let Test.11 : Int1 = CallByName Bool.11 Test.6 Test.12;
let Test.11 : Int1 = CallByName Bool.9 Test.6 Test.12;
jump Test.10 Test.11;
procedure Test.0 ():

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

@ -1,10 +1,10 @@
procedure Bool.1 ():
let Bool.23 : Int1 = false;
ret Bool.23;
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Bool.2 ():
let Bool.24 : Int1 = true;
ret Bool.24;
let Bool.22 : Int1 = true;
ret Bool.22;
procedure Test.0 ():
let Test.4 : Int1 = CallByName Bool.2;

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

@ -1,6 +1,6 @@
procedure Bool.1 ():
let Bool.23 : Int1 = false;
ret Bool.23;
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;

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

@ -1,47 +1,43 @@
procedure Bool.1 ():
let Bool.32 : Int1 = false;
ret Bool.32;
let Bool.31 : Int1 = false;
ret Bool.31;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.28 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.28;
procedure Bool.10 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
ret Bool.22;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.29 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.29;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.34 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.34;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.35 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.35;
procedure Bool.12 (#Attr.2, #Attr.3):
procedure Bool.10 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.12 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.2 ():
let Bool.31 : Int1 = true;
ret Bool.31;
let Bool.29 : Int1 = true;
ret Bool.29;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.33 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.33;
procedure Bool.5 (Bool.17, Bool.18):
let Bool.23 : Int1 = CallByName Bool.10 Bool.17 Bool.18;
ret Bool.23;
procedure Bool.7 (Bool.19, Bool.20):
let Bool.25 : Int1 = CallByName Bool.12 Bool.19 Bool.20;
procedure Bool.5 (Bool.17, Bool.18):
let Bool.25 : Int1 = CallByName Bool.10 Bool.17 Bool.18;
ret Bool.25;
procedure Bool.7 (Bool.19, Bool.20):
let Bool.27 : Int1 = CallByName Bool.12 Bool.19 Bool.20;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.27 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.27;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.32 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.32;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.33 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.33;
procedure Dict.1 (Dict.732):
let Dict.894 : List {U32, U32} = Array [];
let Dict.895 : List {Str, I64} = Array [];
@ -157,13 +153,13 @@ procedure Dict.45 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_g
joinpoint Dict.745 Dict.228 Dict.229 Dict.230 Dict.231 Dict.232 Dict.233 Dict.234 Dict.235 Dict.236:
let Dict.237 : {U32, U32} = CallByName Dict.22 Dict.228 Dict.230;
let Dict.792 : U32 = StructAtIndex 1 Dict.237;
let Dict.780 : Int1 = CallByName Bool.11 Dict.231 Dict.792;
let Dict.780 : Int1 = CallByName Bool.9 Dict.231 Dict.792;
if Dict.780 then
let Dict.791 : U32 = StructAtIndex 0 Dict.237;
let Dict.789 : U64 = CallByName Num.133 Dict.791;
let Dict.788 : {Str, I64} = CallByName Dict.22 Dict.229 Dict.789;
let Dict.238 : Str = StructAtIndex 0 Dict.788;
let Dict.783 : Int1 = CallByName Bool.11 Dict.238 Dict.232;
let Dict.783 : Int1 = CallByName Bool.9 Dict.238 Dict.232;
if Dict.783 then
let Dict.787 : U32 = StructAtIndex 0 Dict.237;
let Dict.785 : U64 = CallByName Num.133 Dict.787;
@ -250,7 +246,7 @@ procedure Dict.66 (Dict.728):
let #Derived_gen.71 : List {U32, U32} = StructAtIndex 0 Dict.728;
dec #Derived_gen.71;
let Dict.886 : U64 = CallByName Dict.54;
let Dict.845 : Int1 = CallByName Bool.7 Dict.386 Dict.886;
let Dict.845 : Int1 = CallByName Bool.5 Dict.386 Dict.886;
if Dict.845 then
let Dict.885 : U8 = 1i64;
let Dict.389 : U8 = CallByName Num.75 Dict.388 Dict.885;
@ -275,7 +271,7 @@ procedure Dict.66 (Dict.728):
procedure Dict.67 (Dict.393, Dict.394):
let Dict.395 : U64 = CallByName Dict.70 Dict.393;
let Dict.878 : U64 = CallByName Dict.54;
let Dict.873 : Int1 = CallByName Bool.11 Dict.395 Dict.878;
let Dict.873 : Int1 = CallByName Bool.9 Dict.395 Dict.878;
if Dict.873 then
let Dict.876 : {U32, U32} = CallByName Dict.48;
let Dict.877 : U64 = CallByName Dict.54;
@ -335,7 +331,7 @@ procedure Dict.74 (#Derived_gen.48, #Derived_gen.49, #Derived_gen.50):
let Dict.426 : {U32, U32} = CallByName Dict.22 Dict.423 Dict.425;
let Dict.772 : U32 = StructAtIndex 1 Dict.426;
let Dict.773 : U32 = 0i64;
let Dict.764 : Int1 = CallByName Bool.7 Dict.772 Dict.773;
let Dict.764 : Int1 = CallByName Bool.5 Dict.772 Dict.773;
if Dict.764 then
let Dict.427 : List {U32, U32} = CallByName List.3 Dict.423 Dict.425 Dict.424;
let Dict.769 : U32 = StructAtIndex 0 Dict.426;
@ -354,7 +350,7 @@ procedure Dict.74 (#Derived_gen.48, #Derived_gen.49, #Derived_gen.50):
procedure Dict.75 (Dict.428, Dict.429):
let Dict.758 : U64 = 1i64;
let Dict.757 : U64 = CallByName Num.51 Dict.428 Dict.758;
let Dict.754 : Int1 = CallByName Bool.7 Dict.757 Dict.429;
let Dict.754 : Int1 = CallByName Bool.5 Dict.757 Dict.429;
if Dict.754 then
let Dict.756 : U64 = 1i64;
let Dict.755 : U64 = CallByName Num.51 Dict.428 Dict.756;
@ -1212,16 +1208,16 @@ procedure Str.12 (#Attr.2):
ret Str.248;
procedure Str.20 (#Attr.2):
let Str.316 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.316;
let Str.317 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.317;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.306 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.306;
let Str.307 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.307;
procedure Str.36 (#Attr.2):
let Str.269 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -1259,24 +1255,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.344 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.352 : U8 = 1i64;
let Str.353 : U8 = GetTagId Str.344;
let Str.354 : Int1 = lowlevel Eq Str.352 Str.353;
if Str.354 then
let Str.351 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.344;
let Str.95 : Str = StructAtIndex 0 Str.351;
let Str.94 : Str = StructAtIndex 1 Str.351;
let Str.349 : U64 = CallByName Str.36 Str.91;
let Str.345 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.353 : U8 = 1i64;
let Str.354 : U8 = GetTagId Str.345;
let Str.355 : Int1 = lowlevel Eq Str.353 Str.354;
if Str.355 then
let Str.352 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.345;
let Str.95 : Str = StructAtIndex 0 Str.352;
let Str.94 : Str = StructAtIndex 1 Str.352;
let Str.350 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.348 : Str = CallByName Str.20 Str.349;
let Str.347 : Str = CallByName Str.3 Str.348 Str.94;
let Str.349 : Str = CallByName Str.20 Str.350;
let Str.348 : Str = CallByName Str.3 Str.349 Str.94;
dec Str.94;
let Str.346 : Str = CallByName Str.3 Str.347 Str.93;
let Str.345 : Str = CallByName Str.56 Str.346 Str.95 Str.92 Str.93;
ret Str.345;
let Str.347 : Str = CallByName Str.3 Str.348 Str.93;
let Str.346 : Str = CallByName Str.56 Str.347 Str.95 Str.92 Str.93;
ret Str.346;
else
dec Str.344;
dec Str.345;
ret Str.91;
procedure Str.56 (#Derived_gen.56, #Derived_gen.57, #Derived_gen.58, #Derived_gen.59):
@ -1340,8 +1336,8 @@ procedure Str.58 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_ge
jump Str.281 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
procedure Str.61 (Str.152, Str.153):
let Str.311 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.311 then
let Str.312 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.312 then
ret Str.152;
else
ret Str.153;
@ -1349,12 +1345,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.309 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.309 Str.157;
let Str.308 : U64 = 0i64;
let Str.310 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.310 Str.157;
let Str.309 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.308, Str.158};
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.309, Str.158};
let Str.289 : Int1 = CallByName Str.63 Str.290;
ret Str.289;
@ -1369,24 +1365,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.304 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.305 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.304 Str.305;
let Str.294 : U64 = StructAtIndex 0 Str.160;
let Str.295 : Str = StructAtIndex 1 Str.160;
let Str.297 : Str = StructAtIndex 3 Str.160;
let Str.299 : U64 = StructAtIndex 5 Str.160;
let Str.305 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.306 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.305 Str.306;
let Str.295 : U64 = StructAtIndex 0 Str.160;
let Str.296 : Str = StructAtIndex 1 Str.160;
let Str.298 : Str = StructAtIndex 3 Str.160;
let Str.300 : U64 = StructAtIndex 5 Str.160;
let Str.304 : U64 = 1i64;
let Str.302 : U64 = CallByName Num.51 Str.164 Str.304;
let Str.303 : U64 = 1i64;
let Str.301 : U64 = CallByName Num.51 Str.164 Str.303;
let Str.302 : U64 = 1i64;
let Str.300 : U64 = CallByName Num.51 Str.162 Str.302;
let Str.293 : {U64, Str, U64, Str, U64, U64} = Struct {Str.294, Str.295, Str.300, Str.297, Str.301, Str.299};
let Str.170 : Int1 = CallByName Str.63 Str.293;
let Str.292 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.292;
let Str.301 : U64 = CallByName Num.51 Str.162 Str.303;
let Str.294 : {U64, Str, U64, Str, U64, U64} = Struct {Str.295, Str.296, Str.301, Str.298, Str.302, Str.300};
let Str.170 : Int1 = CallByName Str.63 Str.294;
if Str.169 then
ret Str.170;
else
let Str.292 : Int1 = CallByName Bool.1;
ret Str.292;
procedure Test.0 ():
let Test.8 : Str = "a";

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

@ -14,12 +14,12 @@ procedure #Derived.4 (#Derived.5, #Derived.1):
ret #Derived_gen.3;
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
let Bool.22 : Int1 = false;
ret Bool.22;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Inspect.156 (Inspect.157, #Attr.12):
let Inspect.155 : {} = StructAtIndex 2 #Attr.12;

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

@ -27,23 +27,19 @@ procedure #Derived.6 (#Derived.7, #Derived.5):
ret #Derived_gen.13;
procedure Bool.1 ():
let Bool.26 : Int1 = false;
ret Bool.26;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.28 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.28;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.29 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.29;
procedure Bool.2 ():
let Bool.25 : Int1 = true;
let Bool.25 : Int1 = false;
ret Bool.25;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.27 : Int1 = lowlevel And #Attr.2 #Attr.3;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.27 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.27;
procedure Inspect.225 (Inspect.226, Inspect.224):
@ -326,16 +322,16 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.295;
procedure Str.20 (#Attr.2):
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
let Str.315 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.315;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
let Str.305 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.305;
procedure Str.36 (#Attr.2):
let Str.267 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -373,24 +369,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.342 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.350 : U8 = 1i64;
let Str.351 : U8 = GetTagId Str.342;
let Str.352 : Int1 = lowlevel Eq Str.350 Str.351;
if Str.352 then
let Str.349 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.342;
let Str.95 : Str = StructAtIndex 0 Str.349;
let Str.94 : Str = StructAtIndex 1 Str.349;
let Str.347 : U64 = CallByName Str.36 Str.91;
let Str.343 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.351 : U8 = 1i64;
let Str.352 : U8 = GetTagId Str.343;
let Str.353 : Int1 = lowlevel Eq Str.351 Str.352;
if Str.353 then
let Str.350 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.343;
let Str.95 : Str = StructAtIndex 0 Str.350;
let Str.94 : Str = StructAtIndex 1 Str.350;
let Str.348 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.346 : Str = CallByName Str.20 Str.347;
let Str.345 : Str = CallByName Str.3 Str.346 Str.94;
let Str.347 : Str = CallByName Str.20 Str.348;
let Str.346 : Str = CallByName Str.3 Str.347 Str.94;
dec Str.94;
let Str.344 : Str = CallByName Str.3 Str.345 Str.93;
let Str.343 : Str = CallByName Str.56 Str.344 Str.95 Str.92 Str.93;
ret Str.343;
let Str.345 : Str = CallByName Str.3 Str.346 Str.93;
let Str.344 : Str = CallByName Str.56 Str.345 Str.95 Str.92 Str.93;
ret Str.344;
else
dec Str.342;
dec Str.343;
ret Str.91;
procedure Str.56 (#Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
@ -454,8 +450,8 @@ procedure Str.58 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_ge
jump Str.279 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
procedure Str.61 (Str.152, Str.153):
let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.309 then
let Str.310 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.310 then
ret Str.152;
else
ret Str.153;
@ -463,12 +459,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
let Str.306 : U64 = 0i64;
let Str.308 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.308 Str.157;
let Str.307 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.288 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
let Str.288 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.307, Str.158};
let Str.287 : Int1 = CallByName Str.63 Str.288;
ret Str.287;
@ -483,24 +479,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.302 Str.303;
let Str.292 : U64 = StructAtIndex 0 Str.160;
let Str.293 : Str = StructAtIndex 1 Str.160;
let Str.295 : Str = StructAtIndex 3 Str.160;
let Str.297 : U64 = StructAtIndex 5 Str.160;
let Str.303 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.304 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.303 Str.304;
let Str.293 : U64 = StructAtIndex 0 Str.160;
let Str.294 : Str = StructAtIndex 1 Str.160;
let Str.296 : Str = StructAtIndex 3 Str.160;
let Str.298 : U64 = StructAtIndex 5 Str.160;
let Str.302 : U64 = 1i64;
let Str.300 : U64 = CallByName Num.51 Str.164 Str.302;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
let Str.170 : Int1 = CallByName Str.63 Str.291;
let Str.290 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.290;
let Str.299 : U64 = CallByName Num.51 Str.162 Str.301;
let Str.292 : {U64, Str, U64, Str, U64, U64} = Struct {Str.293, Str.294, Str.299, Str.296, Str.300, Str.298};
let Str.170 : Int1 = CallByName Str.63 Str.292;
if Str.169 then
ret Str.170;
else
let Str.290 : Int1 = CallByName Bool.1;
ret Str.290;
procedure Test.0 ():
let Test.4 : Str = "bar";

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

@ -18,12 +18,12 @@ procedure #Derived.2 (#Derived.3, #Derived.1):
ret #Derived_gen.3;
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
let Bool.22 : Int1 = false;
ret Bool.22;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Inspect.225 (Inspect.226, Inspect.224):
let Inspect.339 : Str = "{";

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

@ -13,23 +13,19 @@ procedure #Derived.2 (#Derived.3, #Derived.1):
ret #Derived_gen.3;
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.27 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.27;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
let Bool.23 : Int1 = false;
ret Bool.23;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel And #Attr.2 #Attr.3;
procedure Bool.2 ():
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Inspect.225 (Inspect.226, Inspect.224):
@ -220,16 +216,16 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -267,24 +263,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
let Str.342 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.350 : U8 = 1i64;
let Str.351 : U8 = GetTagId Str.342;
let Str.352 : Int1 = lowlevel Eq Str.350 Str.351;
if Str.352 then
let Str.349 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.342;
let Str.95 : Str = StructAtIndex 0 Str.349;
let Str.94 : Str = StructAtIndex 1 Str.349;
let Str.347 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
let Str.346 : Str = CallByName Str.20 Str.347;
let Str.345 : Str = CallByName Str.3 Str.346 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
let Str.344 : Str = CallByName Str.3 Str.345 Str.93;
let Str.343 : Str = CallByName Str.56 Str.344 Str.95 Str.92 Str.93;
ret Str.343;
else
dec Str.341;
dec Str.342;
ret Str.91;
procedure Str.56 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
@ -348,8 +344,8 @@ procedure Str.58 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_ge
jump Str.278 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.309 then
ret Str.152;
else
ret Str.153;
@ -357,12 +353,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
let Str.306 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
@ -377,24 +373,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.302 Str.303;
let Str.292 : U64 = StructAtIndex 0 Str.160;
let Str.293 : Str = StructAtIndex 1 Str.160;
let Str.295 : Str = StructAtIndex 3 Str.160;
let Str.297 : U64 = StructAtIndex 5 Str.160;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
let Str.170 : Int1 = CallByName Str.63 Str.291;
if Str.169 then
ret Str.170;
else
let Str.289 : Int1 = CallByName Bool.1;
ret Str.289;
procedure Test.0 ():
let Test.3 : Str = "foo";

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

@ -20,23 +20,19 @@ procedure #Derived.2 (#Derived.3, #Derived.1):
ret #Derived_gen.3;
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.27 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.27;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
let Bool.23 : Int1 = false;
ret Bool.23;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel And #Attr.2 #Attr.3;
procedure Bool.2 ():
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Inspect.225 (Inspect.226, Inspect.224):
@ -227,16 +223,16 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -274,24 +270,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.393 : U8 = 1i64;
let Str.394 : U8 = GetTagId Str.385;
let Str.395 : Int1 = lowlevel Eq Str.393 Str.394;
if Str.395 then
let Str.392 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385;
let Str.95 : Str = StructAtIndex 0 Str.392;
let Str.94 : Str = StructAtIndex 1 Str.392;
let Str.390 : U64 = CallByName Str.36 Str.91;
let Str.386 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.394 : U8 = 1i64;
let Str.395 : U8 = GetTagId Str.386;
let Str.396 : Int1 = lowlevel Eq Str.394 Str.395;
if Str.396 then
let Str.393 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.386;
let Str.95 : Str = StructAtIndex 0 Str.393;
let Str.94 : Str = StructAtIndex 1 Str.393;
let Str.391 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.389 : Str = CallByName Str.20 Str.390;
let Str.388 : Str = CallByName Str.3 Str.389 Str.94;
let Str.390 : Str = CallByName Str.20 Str.391;
let Str.389 : Str = CallByName Str.3 Str.390 Str.94;
dec Str.94;
let Str.387 : Str = CallByName Str.3 Str.388 Str.93;
let Str.386 : Str = CallByName Str.56 Str.387 Str.95 Str.92 Str.93;
ret Str.386;
let Str.388 : Str = CallByName Str.3 Str.389 Str.93;
let Str.387 : Str = CallByName Str.56 Str.388 Str.95 Str.92 Str.93;
ret Str.387;
else
dec Str.385;
dec Str.386;
ret Str.91;
procedure Str.56 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31):
@ -355,8 +351,8 @@ procedure Str.58 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_ge
jump Str.278 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.309 then
ret Str.152;
else
ret Str.153;
@ -364,12 +360,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
let Str.306 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
@ -384,24 +380,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.302 Str.303;
let Str.292 : U64 = StructAtIndex 0 Str.160;
let Str.293 : Str = StructAtIndex 1 Str.160;
let Str.295 : Str = StructAtIndex 3 Str.160;
let Str.297 : U64 = StructAtIndex 5 Str.160;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
let Str.170 : Int1 = CallByName Str.63 Str.291;
if Str.169 then
ret Str.170;
else
let Str.289 : Int1 = CallByName Bool.1;
ret Str.289;
procedure Test.0 ():
let Test.3 : Str = "foo";

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

@ -1,13 +1,13 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.1 ():
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.22;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.245 (Inspect.246, Inspect.244):
@ -100,16 +100,16 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -147,24 +147,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
let Str.342 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.350 : U8 = 1i64;
let Str.351 : U8 = GetTagId Str.342;
let Str.352 : Int1 = lowlevel Eq Str.350 Str.351;
if Str.352 then
let Str.349 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.342;
let Str.95 : Str = StructAtIndex 0 Str.349;
let Str.94 : Str = StructAtIndex 1 Str.349;
let Str.347 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
let Str.346 : Str = CallByName Str.20 Str.347;
let Str.345 : Str = CallByName Str.3 Str.346 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
let Str.344 : Str = CallByName Str.3 Str.345 Str.93;
let Str.343 : Str = CallByName Str.56 Str.344 Str.95 Str.92 Str.93;
ret Str.343;
else
dec Str.341;
dec Str.342;
ret Str.91;
procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
@ -228,8 +228,8 @@ procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4
jump Str.278 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.309 then
ret Str.152;
else
ret Str.153;
@ -237,12 +237,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
let Str.306 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
@ -257,24 +257,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.302 Str.303;
let Str.292 : U64 = StructAtIndex 0 Str.160;
let Str.293 : Str = StructAtIndex 1 Str.160;
let Str.295 : Str = StructAtIndex 3 Str.160;
let Str.297 : U64 = StructAtIndex 5 Str.160;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
let Str.170 : Int1 = CallByName Str.63 Str.291;
if Str.169 then
ret Str.170;
else
let Str.289 : Int1 = CallByName Bool.1;
ret Str.289;
procedure Test.0 ():
let Test.2 : Str = "abc";

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

@ -15,18 +15,18 @@ procedure #Derived.3 (#Derived.4, #Derived.1):
dec #Derived_gen.7;
jump #Derived_gen.5 #Derived_gen.6;
procedure Bool.11 (#Attr.2, #Attr.3):
procedure Bool.1 ():
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.22;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.201 (Inspect.202, #Attr.12):
let Inspect.335 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.334 : Str = CallByName Inspect.63 Inspect.202 Inspect.335;
@ -159,7 +159,7 @@ procedure Inspect.64 (Inspect.297):
procedure List.1 (List.119):
let List.688 : U64 = CallByName List.6 List.119;
let List.689 : U64 = 0i64;
let List.687 : Int1 = CallByName Bool.11 List.688 List.689;
let List.687 : Int1 = CallByName Bool.9 List.688 List.689;
ret List.687;
procedure List.101 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
@ -223,16 +223,16 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -270,24 +270,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
let Str.342 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.350 : U8 = 1i64;
let Str.351 : U8 = GetTagId Str.342;
let Str.352 : Int1 = lowlevel Eq Str.350 Str.351;
if Str.352 then
let Str.349 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.342;
let Str.95 : Str = StructAtIndex 0 Str.349;
let Str.94 : Str = StructAtIndex 1 Str.349;
let Str.347 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
let Str.346 : Str = CallByName Str.20 Str.347;
let Str.345 : Str = CallByName Str.3 Str.346 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
let Str.344 : Str = CallByName Str.3 Str.345 Str.93;
let Str.343 : Str = CallByName Str.56 Str.344 Str.95 Str.92 Str.93;
ret Str.343;
else
dec Str.341;
dec Str.342;
ret Str.91;
procedure Str.56 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
@ -351,8 +351,8 @@ procedure Str.58 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_ge
jump Str.278 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.309 then
ret Str.152;
else
ret Str.153;
@ -360,12 +360,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
let Str.306 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
@ -380,24 +380,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.302 Str.303;
let Str.292 : U64 = StructAtIndex 0 Str.160;
let Str.293 : Str = StructAtIndex 1 Str.160;
let Str.295 : Str = StructAtIndex 3 Str.160;
let Str.297 : U64 = StructAtIndex 5 Str.160;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
let Str.170 : Int1 = CallByName Str.63 Str.291;
if Str.169 then
ret Str.170;
else
let Str.289 : Int1 = CallByName Bool.1;
ret Str.289;
procedure Test.0 ():
let Test.4 : Str = "foo";

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

@ -18,18 +18,18 @@ procedure #Derived.4 (#Derived.5, #Derived.1):
dec #Derived_gen.7;
jump #Derived_gen.5 #Derived_gen.6;
procedure Bool.11 (#Attr.2, #Attr.3):
procedure Bool.1 ():
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.22;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.201 (Inspect.202, #Attr.12):
let Inspect.335 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.334 : Str = CallByName Inspect.63 Inspect.202 Inspect.335;
@ -162,7 +162,7 @@ procedure Inspect.64 (Inspect.297):
procedure List.1 (List.119):
let List.688 : U64 = CallByName List.6 List.119;
let List.689 : U64 = 0i64;
let List.687 : Int1 = CallByName Bool.11 List.688 List.689;
let List.687 : Int1 = CallByName Bool.9 List.688 List.689;
ret List.687;
procedure List.101 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
@ -226,16 +226,16 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
@ -273,24 +273,24 @@ procedure Str.38 (Str.112, Str.113):
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.393 : U8 = 1i64;
let Str.394 : U8 = GetTagId Str.385;
let Str.395 : Int1 = lowlevel Eq Str.393 Str.394;
if Str.395 then
let Str.392 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385;
let Str.95 : Str = StructAtIndex 0 Str.392;
let Str.94 : Str = StructAtIndex 1 Str.392;
let Str.390 : U64 = CallByName Str.36 Str.91;
let Str.386 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.394 : U8 = 1i64;
let Str.395 : U8 = GetTagId Str.386;
let Str.396 : Int1 = lowlevel Eq Str.394 Str.395;
if Str.396 then
let Str.393 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.386;
let Str.95 : Str = StructAtIndex 0 Str.393;
let Str.94 : Str = StructAtIndex 1 Str.393;
let Str.391 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.389 : Str = CallByName Str.20 Str.390;
let Str.388 : Str = CallByName Str.3 Str.389 Str.94;
let Str.390 : Str = CallByName Str.20 Str.391;
let Str.389 : Str = CallByName Str.3 Str.390 Str.94;
dec Str.94;
let Str.387 : Str = CallByName Str.3 Str.388 Str.93;
let Str.386 : Str = CallByName Str.56 Str.387 Str.95 Str.92 Str.93;
ret Str.386;
let Str.388 : Str = CallByName Str.3 Str.389 Str.93;
let Str.387 : Str = CallByName Str.56 Str.388 Str.95 Str.92 Str.93;
ret Str.387;
else
dec Str.385;
dec Str.386;
ret Str.91;
procedure Str.56 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
@ -354,8 +354,8 @@ procedure Str.58 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_ge
jump Str.278 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.309 then
ret Str.152;
else
ret Str.153;
@ -363,12 +363,12 @@ procedure Str.61 (Str.152, Str.153):
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
let Str.306 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
@ -383,24 +383,27 @@ procedure Str.63 (Str.160):
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
let Str.168 : Int1 = CallByName Bool.9 Str.164 Str.165;
ret Str.168;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.9 Str.302 Str.303;
let Str.292 : U64 = StructAtIndex 0 Str.160;
let Str.293 : Str = StructAtIndex 1 Str.160;
let Str.295 : Str = StructAtIndex 3 Str.160;
let Str.297 : U64 = StructAtIndex 5 Str.160;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
let Str.170 : Int1 = CallByName Str.63 Str.291;
if Str.169 then
ret Str.170;
else
let Str.289 : Int1 = CallByName Bool.1;
ret Str.289;
procedure Test.0 ():
let Test.5 : Str = "foo";

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

@ -1,10 +1,10 @@
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
let Bool.22 : Int1 = false;
ret Bool.22;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Test.2 (Test.4):
let Test.11 : U8 = 1i64;

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

@ -1,10 +1,10 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.22;
procedure List.2 (List.120, List.121):
let List.689 : U64 = CallByName List.6 List.120;
@ -57,7 +57,7 @@ procedure Str.66 (Str.191):
let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
let Str.249 : Int1 = CallByName Bool.9 Str.252 Str.253;
if Str.249 then
let Str.251 : I64 = StructAtIndex 0 Str.192;
let Str.250 : [C Int1, C I64] = TagId(1) Str.251;

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

@ -1,6 +1,6 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Test.2 (#Derived_gen.0):
joinpoint Test.13 Test.7:
@ -28,6 +28,6 @@ procedure Test.0 ():
let Test.12 : [<rnu><null>, C *self] = TagId(1) ;
let Test.10 : {} = CallByName Test.2 Test.12;
let Test.11 : {} = Struct {};
let Test.8 : Int1 = CallByName Bool.11 Test.10 Test.11;
let Test.8 : Int1 = CallByName Bool.9 Test.10 Test.11;
let Test.9 : Str = "";
ret Test.9;

65
crates/compiler/test_mono/generated/issue_4557.txt generated
View file

@ -1,45 +1,48 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.2 ():
let Bool.22 : Int1 = true;
ret Bool.22;
procedure Bool.4 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Or #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Test.1 (Test.2, Test.3):
let Test.17 : {Int1, Int1} = Struct {Test.2, Test.3};
let Test.32 : Int1 = StructAtIndex 0 Test.17;
let Test.31 : Int1 = StructAtIndex 1 Test.17;
let Test.19 : Int1 = CallByName Test.1 Test.31 Test.32;
let Test.26 : {} = Struct {};
joinpoint Test.27 Test.21:
let Test.23 : {} = Struct {};
joinpoint Test.24 Test.22:
let Test.20 : Int1 = CallByName Bool.11 Test.21 Test.22;
dec Test.21;
dec Test.22;
let Test.18 : Int1 = CallByName Bool.4 Test.19 Test.20;
ret Test.18;
let Test.27 : Int1 = CallByName Test.1 Test.31 Test.32;
if Test.27 then
let Test.28 : Int1 = CallByName Bool.2;
ret Test.28;
else
let Test.24 : {} = Struct {};
joinpoint Test.25 Test.19:
let Test.21 : {} = Struct {};
joinpoint Test.22 Test.20:
let Test.18 : Int1 = CallByName Bool.9 Test.19 Test.20;
dec Test.20;
dec Test.19;
ret Test.18;
in
switch Test.31:
case 0:
let Test.23 : Str = CallByName Test.9 Test.21;
jump Test.22 Test.23;
default:
let Test.23 : Str = CallByName Test.11 Test.21;
jump Test.22 Test.23;
in
switch Test.31:
switch Test.32:
case 0:
let Test.25 : Str = CallByName Test.9 Test.23;
jump Test.24 Test.25;
let Test.26 : Str = CallByName Test.9 Test.24;
jump Test.25 Test.26;
default:
let Test.25 : Str = CallByName Test.11 Test.23;
jump Test.24 Test.25;
let Test.26 : Str = CallByName Test.11 Test.24;
jump Test.25 Test.26;
in
switch Test.32:
case 0:
let Test.28 : Str = CallByName Test.9 Test.26;
jump Test.27 Test.28;
default:
let Test.28 : Str = CallByName Test.11 Test.26;
jump Test.27 Test.28;
procedure Test.11 (Test.34):
let Test.35 : Str = "a";

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Test.0 (Test.4):
let Test.7 : Int1 = CallByName Bool.2;

14
crates/compiler/test_mono/generated/issue_4749.txt generated
View file

@ -1,17 +1,17 @@
procedure Bool.12 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.10 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
ret Bool.22;
procedure Bool.7 (Bool.19, Bool.20):
let Bool.23 : Int1 = CallByName Bool.12 Bool.19 Bool.20;
ret Bool.23;
procedure Bool.5 (Bool.17, Bool.18):
let Bool.21 : Int1 = CallByName Bool.10 Bool.17 Bool.18;
ret Bool.21;
procedure Test.6 ():
let Test.10 : Int1 = false;
let Test.0 : [C Int1, C Int1, C Int1] = TagId(2) Test.10;
let Test.9 : Int1 = false;
let Test.1 : [C Int1, C Int1, C Int1] = TagId(0) Test.9;
let Test.8 : Int1 = CallByName Bool.7 Test.0 Test.1;
let Test.8 : Int1 = CallByName Bool.5 Test.0 Test.1;
expect Test.8;
let Test.7 : {} = Struct {};
ret Test.7;

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

@ -1,10 +1,10 @@
procedure Bool.1 ():
let Bool.25 : Int1 = false;
ret Bool.25;
let Bool.23 : Int1 = false;
ret Bool.23;
procedure Bool.2 ():
let Bool.24 : Int1 = true;
ret Bool.24;
let Bool.22 : Int1 = true;
ret Bool.22;
procedure List.106 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6):
joinpoint List.713 List.291 List.292 List.293 List.294 List.295 List.296:

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

@ -1,10 +1,10 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.22 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.22;
procedure Decode.24 (Decode.105):
ret Decode.105;
@ -34,7 +34,7 @@ procedure Str.66 (Str.191):
let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
let Str.249 : Int1 = CallByName Bool.9 Str.252 Str.253;
if Str.249 then
let Str.251 : I64 = StructAtIndex 0 Str.192;
let Str.250 : [C {}, C I64] = TagId(1) Str.251;
@ -50,7 +50,7 @@ procedure Test.103 ():
let Test.116 : I64 = -1234i64;
let Test.114 : {List U8, I64} = Struct {Test.115, Test.116};
let Test.113 : [C Str, C {List U8, I64}] = TagId(1) Test.114;
let Test.112 : Int1 = CallByName Bool.11 Test.101 Test.113;
let Test.112 : Int1 = CallByName Bool.9 Test.101 Test.113;
dec Test.114;
expect Test.112;
dec Test.101;

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

@ -1,6 +1,6 @@
procedure Bool.1 ():
let Bool.23 : Int1 = false;
ret Bool.23;
let Bool.21 : Int1 = false;
ret Bool.21;
procedure Test.2 (Test.11, Test.1):
if Test.1 then

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

@ -1,6 +1,6 @@
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
let Bool.22 : Int1 = false;
ret Bool.22;
procedure Test.1 (Test.4):
let Test.9 : I64 = 0i64;

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

@ -1,6 +1,6 @@
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
let Bool.22 : Int1 = false;
ret Bool.22;
procedure Test.1 (Test.4):
let Test.9 : I64 = 0i64;

14
crates/compiler/test_mono/generated/lambda_set_with_imported_toplevels_issue_4733.txt generated
View file

@ -1,10 +1,10 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.2 ():
let Bool.24 : Int1 = true;
ret Bool.24;
let Bool.22 : Int1 = true;
ret Bool.22;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
@ -40,7 +40,7 @@ procedure Test.7 ():
let Test.14 : Int1 = CallByName Test.0 Test.15;
let Test.11 : U64 = CallByName Test.5 Test.13 Test.14;
let Test.12 : U64 = 9i64;
let Test.10 : Int1 = CallByName Bool.11 Test.11 Test.12;
let Test.10 : Int1 = CallByName Bool.9 Test.11 Test.12;
expect Test.10;
let Test.9 : {} = Struct {};
ret Test.9;

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

@ -1,6 +1,6 @@
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
let Bool.22 : Int1 = false;
ret Bool.22;
procedure Test.4 (Test.6):
let Test.8 : U64 = 1i64;

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

@ -1,6 +1,6 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Test.2 (Test.5):
let Test.14 : U8 = GetTagId Test.5;
@ -23,7 +23,7 @@ procedure Test.0 ():
let Test.10 : [<rnw><null>, C Str, C *self] = TagId(0) ;
let Test.8 : Str = CallByName Test.2 Test.10;
let Test.9 : Str = "c";
let Test.7 : Int1 = CallByName Bool.11 Test.8 Test.9;
let Test.7 : Int1 = CallByName Bool.9 Test.8 Test.9;
dec Test.8;
dec Test.9;
ret Test.7;

12
crates/compiler/test_mono/generated/pattern_as_nested.txt generated
View file

@ -1,10 +1,10 @@
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
let Bool.22 : Int1 = false;
ret Bool.22;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Test.1 ():
let Test.9 : I64 = 42i64;
@ -23,7 +23,7 @@ procedure Test.0 ():
if Test.17 then
let Test.13 : {I64, Str} = StructAtIndex 0 Test.5;
let Test.7 : {I64, Str} = CallByName Test.1;
let Test.6 : Int1 = CallByName Bool.11 Test.7 Test.13;
let Test.6 : Int1 = CallByName Bool.9 Test.7 Test.13;
dec Test.13;
dec Test.7;
ret Test.6;

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

@ -1,9 +1,9 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Test.0 ():
let Test.3 : Str = "foo";
let Test.4 : Int1 = CallByName Bool.11 Test.3 Test.3;
let Test.4 : Int1 = CallByName Bool.9 Test.3 Test.3;
dec Test.3;
ret Test.4;

12
crates/compiler/test_mono/generated/pattern_as_toplevel.txt generated
View file

@ -1,10 +1,10 @@
procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
let Bool.22 : Int1 = false;
ret Bool.22;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Test.1 ():
let Test.8 : I64 = 42i64;
@ -19,7 +19,7 @@ procedure Test.0 ():
let Test.13 : Int1 = lowlevel Eq Test.12 Test.11;
if Test.13 then
let Test.6 : {I64, Str} = CallByName Test.1;
let Test.5 : Int1 = CallByName Bool.11 Test.6 Test.4;
let Test.5 : Int1 = CallByName Bool.9 Test.6 Test.4;
dec Test.6;
let #Derived_gen.0 : Str = StructAtIndex 1 Test.4;
dec #Derived_gen.0;

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

@ -1,6 +1,6 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
@ -29,7 +29,7 @@ procedure Test.0 ():
let Test.14 : [<r>C List *self, C Str] = CallByName Test.3;
let Test.16 : Str = "";
let Test.15 : [<r>C List *self, C Str] = TagId(1) Test.16;
let Test.13 : Int1 = CallByName Bool.11 Test.14 Test.15;
let Test.13 : Int1 = CallByName Bool.9 Test.14 Test.15;
joinpoint #Derived_gen.0:
dec Test.14;
ret Test.13;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.283 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Test.10 (Test.26):
let Test.30 : Int1 = CallByName Bool.2;

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

@ -1,6 +1,6 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.284 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
@ -13,7 +13,7 @@ procedure Num.21 (#Attr.2, #Attr.3):
procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
joinpoint Test.11 Test.2 Test.3:
let Test.26 : U8 = 0i64;
let Test.22 : Int1 = CallByName Bool.11 Test.2 Test.26;
let Test.22 : Int1 = CallByName Bool.9 Test.2 Test.26;
if Test.22 then
let Test.24 : U8 = 1i64;
let Test.25 : U8 = GetTagId Test.3;

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

@ -1,6 +1,6 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Str.26 (Str.83):
let Str.246 : [C {}, C U64] = CallByName Str.66 Str.83;
@ -14,7 +14,7 @@ procedure Str.66 (Str.191):
let Str.192 : {U64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
let Str.249 : Int1 = CallByName Bool.9 Str.252 Str.253;
if Str.249 then
let Str.251 : U64 = StructAtIndex 0 Str.192;
let Str.250 : [C {}, C U64] = TagId(1) Str.251;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Test.0 ():
let Test.2 : Int1 = CallByName Bool.2;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.24 : Int1 = true;
ret Bool.24;
let Bool.22 : Int1 = true;
ret Bool.22;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Test.0 ():
let Test.6 : Int1 = CallByName Bool.2;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Encode.23 (Encode.100):
ret Encode.100;

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Test.12 (Test.52):
let Test.72 : Int1 = false;

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

@ -31,8 +31,8 @@ procedure #Derived.7 (#Derived.8, #Derived.9, #Attr.12):
jump #Derived_gen.5 #Derived_gen.6;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
let Bool.21 : Int1 = true;
ret Bool.21;
procedure Encode.23 (Encode.100):
ret Encode.100;

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

@ -1,6 +1,6 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure List.116 (List.563, List.564, List.565):
let List.693 : U64 = 0i64;
@ -99,7 +99,7 @@ procedure Test.0 (Test.1):
let Test.11 : {} = Struct {};
let Test.2 : U64 = CallByName List.26 Test.1 Test.10 Test.11;
let Test.9 : U64 = 0i64;
let Test.7 : Int1 = CallByName Bool.11 Test.2 Test.9;
let Test.7 : Int1 = CallByName Bool.9 Test.2 Test.9;
if Test.7 then
ret Test.1;
else

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

@ -1,6 +1,6 @@
procedure Bool.2 ():
let Bool.25 : Int1 = true;
ret Bool.25;
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.283 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;