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

Update mono tests

Browse source
This commit is contained in:
Richard Feldman 2024-01-26 16:25:32 -05:00
parent 204cee7d60
commit 418731cb71
No known key found for this signature in database
GPG key ID: F1F21AA5B1D9E43B
91 changed files with 2545 additions and 2607 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -78,16 +78,16 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
jump List.591 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.300 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.300;
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.260;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.299 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.259;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.298 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.258;
procedure Test.1 (Test.2):
let Test.13 : U64 = 0i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.4 (Test.27):
let Test.39 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = TagId(0) ;

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

@ -28,12 +28,12 @@ procedure List.90 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.
jump List.574 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.298 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.257;
procedure Test.10 (Test.69, #Attr.12):
let Test.72 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;

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

@ -47,8 +47,8 @@ procedure List.9 (List.333):
ret List.573;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Result.5 (Result.12, Result.13):
let Result.39 : U8 = 1i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.298 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Test.0 ():
let Test.6 : I128 = 18446744073709551616i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.2 : U128 = 170141183460469231731687303715884105728u128;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.2 : U64 = 9999999999999999999i64;

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

@ -32,16 +32,16 @@ procedure List.90 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
jump List.574 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.298 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.252 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.252;
let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.251;
procedure Test.1 (Test.5):
ret Test.5;

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

@ -2,52 +2,52 @@ procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Inspect.251 (Inspect.252, Inspect.250):
let Inspect.327 : Str = "\"";
let Inspect.326 : Str = CallByName Inspect.61 Inspect.252 Inspect.327;
let Inspect.322 : Str = CallByName Inspect.61 Inspect.326 Inspect.250;
let Inspect.323 : Str = "\"";
let Inspect.321 : Str = CallByName Inspect.61 Inspect.322 Inspect.323;
ret Inspect.321;
procedure Inspect.246 (Inspect.247, Inspect.245):
let Inspect.319 : Str = "\"";
let Inspect.318 : Str = CallByName Inspect.59 Inspect.247 Inspect.319;
let Inspect.314 : Str = CallByName Inspect.59 Inspect.318 Inspect.245;
let Inspect.315 : Str = "\"";
let Inspect.313 : Str = CallByName Inspect.59 Inspect.314 Inspect.315;
ret Inspect.313;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
ret Inspect.315;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.44 (Inspect.250):
let Inspect.317 : Str = CallByName Inspect.30 Inspect.250;
procedure Inspect.43 (Inspect.245):
let Inspect.309 : Str = CallByName Inspect.30 Inspect.245;
ret Inspect.309;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : Str = CallByName Inspect.43 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName Inspect.246 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.317 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.317;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : Str = CallByName Inspect.44 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName Inspect.251 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.325 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
ret Inspect.325;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.1 ():
let Test.4 : Str = "";
let Test.0 : Str = CallByName Inspect.34 Test.4;
let Test.0 : Str = CallByName Inspect.33 Test.4;
dbg Test.0;
dec Test.0;
let Test.3 : Int1 = CallByName Bool.2;

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

@ -1,49 +1,49 @@
procedure Inspect.251 (Inspect.252, Inspect.250):
let Inspect.327 : Str = "\"";
let Inspect.326 : Str = CallByName Inspect.61 Inspect.252 Inspect.327;
let Inspect.322 : Str = CallByName Inspect.61 Inspect.326 Inspect.250;
let Inspect.323 : Str = "\"";
let Inspect.321 : Str = CallByName Inspect.61 Inspect.322 Inspect.323;
ret Inspect.321;
procedure Inspect.246 (Inspect.247, Inspect.245):
let Inspect.319 : Str = "\"";
let Inspect.318 : Str = CallByName Inspect.59 Inspect.247 Inspect.319;
let Inspect.314 : Str = CallByName Inspect.59 Inspect.318 Inspect.245;
let Inspect.315 : Str = "\"";
let Inspect.313 : Str = CallByName Inspect.59 Inspect.314 Inspect.315;
ret Inspect.313;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
ret Inspect.315;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.44 (Inspect.250):
let Inspect.317 : Str = CallByName Inspect.30 Inspect.250;
procedure Inspect.43 (Inspect.245):
let Inspect.309 : Str = CallByName Inspect.30 Inspect.245;
ret Inspect.309;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : Str = CallByName Inspect.43 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName Inspect.246 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.317 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.317;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : Str = CallByName Inspect.44 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName Inspect.251 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.325 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
ret Inspect.325;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.3 : Str = "";
let Test.1 : Str = CallByName Inspect.34 Test.3;
let Test.1 : Str = CallByName Inspect.33 Test.3;
dbg Test.1;
dec Test.1;
let Test.2 : I64 = 42i64;

42
crates/compiler/test_mono/generated/dict.txt
View file

@ -1,37 +1,37 @@
procedure Dict.1 (Dict.726):
let Dict.735 : List {U32, U32} = Array [];
let Dict.736 : List {[], []} = Array [];
let Dict.737 : U64 = 0i64;
procedure Dict.1 (Dict.723):
let Dict.732 : List {U32, U32} = Array [];
let Dict.733 : List {[], []} = Array [];
let Dict.734 : U64 = 0i64;
let Dict.44 : Float32 = CallByName Dict.44;
let Dict.45 : U8 = CallByName Dict.45;
let Dict.734 : {List {U32, U32}, List {[], []}, U64, Float32, U8} = Struct {Dict.735, Dict.736, Dict.737, Dict.44, Dict.45};
ret Dict.734;
let Dict.731 : {List {U32, U32}, List {[], []}, U64, Float32, U8} = Struct {Dict.732, Dict.733, Dict.734, Dict.44, Dict.45};
ret Dict.731;
procedure Dict.4 (Dict.732):
let Dict.157 : List {[], []} = StructAtIndex 1 Dict.732;
let #Derived_gen.0 : List {U32, U32} = StructAtIndex 0 Dict.732;
procedure Dict.4 (Dict.729):
let Dict.156 : List {[], []} = StructAtIndex 1 Dict.729;
let #Derived_gen.0 : List {U32, U32} = StructAtIndex 0 Dict.729;
dec #Derived_gen.0;
let Dict.733 : U64 = CallByName List.6 Dict.157;
dec Dict.157;
ret Dict.733;
let Dict.730 : U64 = CallByName List.6 Dict.156;
dec Dict.156;
ret Dict.730;
procedure Dict.44 ():
let Dict.741 : Float32 = 0.8f64;
ret Dict.741;
let Dict.738 : Float32 = 0.8f64;
ret Dict.738;
procedure Dict.45 ():
let Dict.739 : U8 = 64i64;
let Dict.740 : U8 = 3i64;
let Dict.738 : U8 = CallByName Num.20 Dict.739 Dict.740;
ret Dict.738;
let Dict.736 : U8 = 64i64;
let Dict.737 : U8 = 3i64;
let Dict.735 : U8 = CallByName Num.75 Dict.736 Dict.737;
ret Dict.735;
procedure List.6 (#Attr.2):
let List.571 : U64 = lowlevel ListLen #Attr.2;
ret List.571;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.297 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.297;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.257 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.3 : {} = Struct {};

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

@ -25,8 +25,8 @@ procedure List.66 (#Attr.2, #Attr.3):
ret List.576;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Test.2 (Test.5):
dec Test.5;

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

@ -176,7 +176,7 @@ procedure List.8 (#Attr.2, #Attr.3):
let List.658 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.658;
procedure List.80 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
procedure List.80 (#Derived_gen.50, #Derived_gen.51, #Derived_gen.52, #Derived_gen.53, #Derived_gen.54):
joinpoint List.685 List.489 List.490 List.491 List.492 List.493:
let List.687 : Int1 = CallByName Num.22 List.492 List.493;
if List.687 then
@ -200,25 +200,9 @@ procedure List.80 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_g
let List.686 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.686;
in
jump List.685 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
jump List.685 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54;
procedure List.90 (#Derived_gen.34, #Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38):
joinpoint List.629 List.161 List.162 List.163 List.164 List.165:
let List.631 : Int1 = CallByName Num.22 List.164 List.165;
if List.631 then
let List.635 : {Str, Str} = CallByName List.66 List.161 List.164;
inc List.635;
let List.166 : {List U8, U64} = CallByName TotallyNotJson.203 List.162 List.635;
let List.634 : U64 = 1i64;
let List.633 : U64 = CallByName Num.51 List.164 List.634;
jump List.629 List.161 List.166 List.163 List.633 List.165;
else
dec List.161;
ret List.162;
in
jump List.629 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38;
procedure List.90 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43):
procedure List.90 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
joinpoint List.641 List.161 List.162 List.163 List.164 List.165:
let List.643 : Int1 = CallByName Num.22 List.164 List.165;
if List.643 then
@ -231,9 +215,9 @@ procedure List.90 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_g
dec List.161;
ret List.162;
in
jump List.641 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43;
jump List.641 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
procedure List.90 (#Derived_gen.47, #Derived_gen.48, #Derived_gen.49, #Derived_gen.50, #Derived_gen.51):
procedure List.90 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44):
joinpoint List.595 List.161 List.162 List.163 List.164 List.165:
let List.597 : Int1 = CallByName Num.22 List.164 List.165;
if List.597 then
@ -247,74 +231,85 @@ procedure List.90 (#Derived_gen.47, #Derived_gen.48, #Derived_gen.49, #Derived_g
dec List.161;
ret List.162;
in
jump List.595 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51;
jump List.595 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
procedure List.90 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_gen.48, #Derived_gen.49):
joinpoint List.629 List.161 List.162 List.163 List.164 List.165:
let List.631 : Int1 = CallByName Num.22 List.164 List.165;
if List.631 then
let List.635 : {Str, Str} = CallByName List.66 List.161 List.164;
inc List.635;
let List.166 : {List U8, U64} = CallByName TotallyNotJson.203 List.162 List.635;
let List.634 : U64 = 1i64;
let List.633 : U64 = CallByName Num.51 List.164 List.634;
jump List.629 List.161 List.166 List.163 List.633 List.165;
else
dec List.161;
ret List.162;
in
jump List.629 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49;
procedure Num.127 (#Attr.2):
let Num.313 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.313;
let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.272;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.137 (#Attr.2, #Attr.3):
let Num.277 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.277;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.317 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.317;
let Num.276 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.276;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.314 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.314;
let Num.273 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.273;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.319 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.319;
let Num.278 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.278;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.325 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.325;
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.284;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.327 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.327;
let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.286;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.322 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.322;
let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.281;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.326 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.326;
procedure Num.94 (#Attr.2, #Attr.3):
let Num.318 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.318;
let Num.285 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.285;
procedure Str.12 (#Attr.2):
let Str.263 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.263;
let Str.261 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.261;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
let Str.258 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.258;
procedure Str.9 (Str.68):
let Str.257 : U64 = 0i64;
let Str.260 : U64 = CallByName List.6 Str.68;
let Str.258 : U64 = CallByName Num.133 Str.260;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.257 Str.258;
let Str.254 : Int1 = StructAtIndex 2 Str.69;
if Str.254 then
let Str.256 : Str = StructAtIndex 1 Str.69;
let Str.255 : [C {U64, U8}, C Str] = TagId(1) Str.256;
ret Str.255;
procedure Str.9 (Str.67):
let Str.256 : U64 = 0i64;
let Str.257 : U64 = CallByName List.6 Str.67;
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67 Str.256 Str.257;
let Str.253 : Int1 = StructAtIndex 2 Str.68;
if Str.253 then
let Str.255 : Str = StructAtIndex 1 Str.68;
let Str.254 : [C {U64, U8}, C Str] = TagId(1) Str.255;
ret Str.254;
else
let Str.252 : U8 = StructAtIndex 3 Str.69;
let Str.253 : U64 = StructAtIndex 0 Str.69;
let #Derived_gen.55 : Str = StructAtIndex 1 Str.69;
let Str.251 : U8 = StructAtIndex 3 Str.68;
let Str.252 : U64 = StructAtIndex 0 Str.68;
let #Derived_gen.55 : Str = StructAtIndex 1 Str.68;
dec #Derived_gen.55;
let Str.251 : {U64, U8} = Struct {Str.253, Str.252};
let Str.250 : [C {U64, U8}, C Str] = TagId(0) Str.251;
ret Str.250;
let Str.250 : {U64, U8} = Struct {Str.252, Str.251};
let Str.249 : [C {U64, U8}, C Str] = TagId(0) Str.250;
ret Str.249;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1043, TotallyNotJson.149):
let TotallyNotJson.1046 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;
@ -521,7 +516,7 @@ procedure TotallyNotJson.26 (TotallyNotJson.152):
let TotallyNotJson.1088 : U64 = 120i64;
let TotallyNotJson.1085 : U64 = CallByName Num.21 TotallyNotJson.1087 TotallyNotJson.1088;
let TotallyNotJson.1086 : U64 = 100i64;
let TotallyNotJson.1084 : U64 = CallByName Num.94 TotallyNotJson.1085 TotallyNotJson.1086;
let TotallyNotJson.1084 : U64 = CallByName Num.137 TotallyNotJson.1085 TotallyNotJson.1086;
let TotallyNotJson.1081 : List U8 = CallByName List.68 TotallyNotJson.1084;
let TotallyNotJson.1083 : U8 = 34i64;
let TotallyNotJson.1082 : List U8 = Array [TotallyNotJson.1083];

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

@ -135,7 +135,7 @@ procedure List.8 (#Attr.2, #Attr.3):
let List.624 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.624;
procedure List.80 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
procedure List.80 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
joinpoint List.651 List.489 List.490 List.491 List.492 List.493:
let List.653 : Int1 = CallByName Num.22 List.492 List.493;
if List.653 then
@ -159,7 +159,7 @@ procedure List.80 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_g
let List.652 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.652;
in
jump List.651 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
jump List.651 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
procedure List.90 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
joinpoint List.607 List.161 List.162 List.163 List.164 List.165:
@ -176,7 +176,7 @@ procedure List.90 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_g
in
jump List.607 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
procedure List.90 (#Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33):
procedure List.90 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
joinpoint List.595 List.161 List.162 List.163 List.164 List.165:
let List.597 : Int1 = CallByName Num.22 List.164 List.165;
if List.597 then
@ -190,74 +190,69 @@ procedure List.90 (#Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_g
dec List.161;
ret List.162;
in
jump List.595 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33;
jump List.595 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
procedure Num.127 (#Attr.2):
let Num.303 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.303;
let Num.262 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.262;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.137 (#Attr.2, #Attr.3):
let Num.267 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.267;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.307 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.307;
let Num.266 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.266;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.304 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.304;
let Num.263 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.263;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.309 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.309;
let Num.268 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.268;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.315 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.315;
let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.274;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.317 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.317;
let Num.276 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.276;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.312 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.312;
let Num.271 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.271;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.316 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.316;
procedure Num.94 (#Attr.2, #Attr.3):
let Num.308 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.308;
let Num.275 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.275;
procedure Str.12 (#Attr.2):
let Str.262 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.262;
let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.260;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
let Str.258 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.258;
procedure Str.9 (Str.68):
let Str.257 : U64 = 0i64;
let Str.260 : U64 = CallByName List.6 Str.68;
let Str.258 : U64 = CallByName Num.133 Str.260;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.257 Str.258;
let Str.254 : Int1 = StructAtIndex 2 Str.69;
if Str.254 then
let Str.256 : Str = StructAtIndex 1 Str.69;
let Str.255 : [C {U64, U8}, C Str] = TagId(1) Str.256;
ret Str.255;
procedure Str.9 (Str.67):
let Str.256 : U64 = 0i64;
let Str.257 : U64 = CallByName List.6 Str.67;
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67 Str.256 Str.257;
let Str.253 : Int1 = StructAtIndex 2 Str.68;
if Str.253 then
let Str.255 : Str = StructAtIndex 1 Str.68;
let Str.254 : [C {U64, U8}, C Str] = TagId(1) Str.255;
ret Str.254;
else
let Str.252 : U8 = StructAtIndex 3 Str.69;
let Str.253 : U64 = StructAtIndex 0 Str.69;
let #Derived_gen.34 : Str = StructAtIndex 1 Str.69;
let Str.251 : U8 = StructAtIndex 3 Str.68;
let Str.252 : U64 = StructAtIndex 0 Str.68;
let #Derived_gen.34 : Str = StructAtIndex 1 Str.68;
dec #Derived_gen.34;
let Str.251 : {U64, U8} = Struct {Str.253, Str.252};
let Str.250 : [C {U64, U8}, C Str] = TagId(0) Str.251;
ret Str.250;
let Str.250 : {U64, U8} = Struct {Str.252, Str.251};
let Str.249 : [C {U64, U8}, C Str] = TagId(0) Str.250;
ret Str.249;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1009, TotallyNotJson.149):
let TotallyNotJson.1012 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;
@ -416,7 +411,7 @@ procedure TotallyNotJson.26 (TotallyNotJson.152):
let TotallyNotJson.1054 : U64 = 120i64;
let TotallyNotJson.1051 : U64 = CallByName Num.21 TotallyNotJson.1053 TotallyNotJson.1054;
let TotallyNotJson.1052 : U64 = 100i64;
let TotallyNotJson.1050 : U64 = CallByName Num.94 TotallyNotJson.1051 TotallyNotJson.1052;
let TotallyNotJson.1050 : U64 = CallByName Num.137 TotallyNotJson.1051 TotallyNotJson.1052;
let TotallyNotJson.1047 : List U8 = CallByName List.68 TotallyNotJson.1050;
let TotallyNotJson.1049 : U8 = 34i64;
let TotallyNotJson.1048 : List U8 = Array [TotallyNotJson.1049];

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

@ -142,7 +142,7 @@ procedure List.8 (#Attr.2, #Attr.3):
let List.624 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.624;
procedure List.80 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29):
procedure List.80 (#Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
joinpoint List.651 List.489 List.490 List.491 List.492 List.493:
let List.653 : Int1 = CallByName Num.22 List.492 List.493;
if List.653 then
@ -166,7 +166,7 @@ procedure List.80 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_g
let List.652 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.652;
in
jump List.651 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29;
jump List.651 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
procedure List.90 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
joinpoint List.607 List.161 List.162 List.163 List.164 List.165:
@ -183,7 +183,7 @@ procedure List.90 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_g
in
jump List.607 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
procedure List.90 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36, #Derived_gen.37):
procedure List.90 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34):
joinpoint List.595 List.161 List.162 List.163 List.164 List.165:
let List.597 : Int1 = CallByName Num.22 List.164 List.165;
if List.597 then
@ -197,74 +197,69 @@ procedure List.90 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_g
dec List.161;
ret List.162;
in
jump List.595 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37;
jump List.595 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
procedure Num.127 (#Attr.2):
let Num.303 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.303;
let Num.262 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.262;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.137 (#Attr.2, #Attr.3):
let Num.267 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.267;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.307 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.307;
let Num.266 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.266;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.304 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.304;
let Num.263 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.263;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.309 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.309;
let Num.268 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.268;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.315 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.315;
let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.274;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.317 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.317;
let Num.276 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.276;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.312 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.312;
let Num.271 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.271;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.316 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.316;
procedure Num.94 (#Attr.2, #Attr.3):
let Num.308 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.308;
let Num.275 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.275;
procedure Str.12 (#Attr.2):
let Str.262 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.262;
let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.260;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
let Str.258 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.258;
procedure Str.9 (Str.68):
let Str.257 : U64 = 0i64;
let Str.260 : U64 = CallByName List.6 Str.68;
let Str.258 : U64 = CallByName Num.133 Str.260;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.257 Str.258;
let Str.254 : Int1 = StructAtIndex 2 Str.69;
if Str.254 then
let Str.256 : Str = StructAtIndex 1 Str.69;
let Str.255 : [C {U64, U8}, C Str] = TagId(1) Str.256;
ret Str.255;
procedure Str.9 (Str.67):
let Str.256 : U64 = 0i64;
let Str.257 : U64 = CallByName List.6 Str.67;
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67 Str.256 Str.257;
let Str.253 : Int1 = StructAtIndex 2 Str.68;
if Str.253 then
let Str.255 : Str = StructAtIndex 1 Str.68;
let Str.254 : [C {U64, U8}, C Str] = TagId(1) Str.255;
ret Str.254;
else
let Str.252 : U8 = StructAtIndex 3 Str.69;
let Str.253 : U64 = StructAtIndex 0 Str.69;
let #Derived_gen.38 : Str = StructAtIndex 1 Str.69;
let Str.251 : U8 = StructAtIndex 3 Str.68;
let Str.252 : U64 = StructAtIndex 0 Str.68;
let #Derived_gen.38 : Str = StructAtIndex 1 Str.68;
dec #Derived_gen.38;
let Str.251 : {U64, U8} = Struct {Str.253, Str.252};
let Str.250 : [C {U64, U8}, C Str] = TagId(0) Str.251;
ret Str.250;
let Str.250 : {U64, U8} = Struct {Str.252, Str.251};
let Str.249 : [C {U64, U8}, C Str] = TagId(0) Str.250;
ret Str.249;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1009, TotallyNotJson.149):
let TotallyNotJson.1012 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;
@ -423,7 +418,7 @@ procedure TotallyNotJson.26 (TotallyNotJson.152):
let TotallyNotJson.1054 : U64 = 120i64;
let TotallyNotJson.1051 : U64 = CallByName Num.21 TotallyNotJson.1053 TotallyNotJson.1054;
let TotallyNotJson.1052 : U64 = 100i64;
let TotallyNotJson.1050 : U64 = CallByName Num.94 TotallyNotJson.1051 TotallyNotJson.1052;
let TotallyNotJson.1050 : U64 = CallByName Num.137 TotallyNotJson.1051 TotallyNotJson.1052;
let TotallyNotJson.1047 : List U8 = CallByName List.68 TotallyNotJson.1050;
let TotallyNotJson.1049 : U8 = 34i64;
let TotallyNotJson.1048 : List U8 = Array [TotallyNotJson.1049];

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

@ -80,7 +80,7 @@ procedure List.8 (#Attr.2, #Attr.3):
let List.579 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.579;
procedure List.80 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
joinpoint List.616 List.489 List.490 List.491 List.492 List.493:
let List.618 : Int1 = CallByName Num.22 List.492 List.493;
if List.618 then
@ -104,9 +104,9 @@ procedure List.80 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen
let List.617 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.617;
in
jump List.616 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
jump List.616 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure List.90 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
procedure List.90 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
joinpoint List.587 List.161 List.162 List.163 List.164 List.165:
let List.589 : Int1 = CallByName Num.22 List.164 List.165;
if List.589 then
@ -119,66 +119,61 @@ procedure List.90 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
dec List.161;
ret List.162;
in
jump List.587 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
jump List.587 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.137 (#Attr.2, #Attr.3):
let Num.259 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.259;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.299 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.299;
let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.301 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.301;
let Num.260 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.260;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.305 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.305;
let Num.264 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.264;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.307 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.307;
let Num.266 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.266;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.303 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.303;
let Num.262 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.262;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.306 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.306;
procedure Num.94 (#Attr.2, #Attr.3):
let Num.300 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.300;
let Num.265 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.265;
procedure Str.12 (#Attr.2):
let Str.261 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.261;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
let Str.259 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.259;
procedure Str.9 (Str.68):
let Str.257 : U64 = 0i64;
let Str.260 : U64 = CallByName List.6 Str.68;
let Str.258 : U64 = CallByName Num.133 Str.260;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.257 Str.258;
let Str.254 : Int1 = StructAtIndex 2 Str.69;
if Str.254 then
let Str.256 : Str = StructAtIndex 1 Str.69;
let Str.255 : [C {U64, U8}, C Str] = TagId(1) Str.256;
ret Str.255;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.258 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.258;
procedure Str.9 (Str.67):
let Str.256 : U64 = 0i64;
let Str.257 : U64 = CallByName List.6 Str.67;
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67 Str.256 Str.257;
let Str.253 : Int1 = StructAtIndex 2 Str.68;
if Str.253 then
let Str.255 : Str = StructAtIndex 1 Str.68;
let Str.254 : [C {U64, U8}, C Str] = TagId(1) Str.255;
ret Str.254;
else
let Str.252 : U8 = StructAtIndex 3 Str.69;
let Str.253 : U64 = StructAtIndex 0 Str.69;
let #Derived_gen.13 : Str = StructAtIndex 1 Str.69;
let Str.251 : U8 = StructAtIndex 3 Str.68;
let Str.252 : U64 = StructAtIndex 0 Str.68;
let #Derived_gen.13 : Str = StructAtIndex 1 Str.68;
dec #Derived_gen.13;
let Str.251 : {U64, U8} = Struct {Str.253, Str.252};
let Str.250 : [C {U64, U8}, C Str] = TagId(0) Str.251;
ret Str.250;
let Str.250 : {U64, U8} = Struct {Str.252, Str.251};
let Str.249 : [C {U64, U8}, C Str] = TagId(0) Str.250;
ret Str.249;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.973, TotallyNotJson.149):
let TotallyNotJson.976 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;
@ -289,7 +284,7 @@ procedure TotallyNotJson.26 (TotallyNotJson.152):
let TotallyNotJson.1018 : U64 = 120i64;
let TotallyNotJson.1015 : U64 = CallByName Num.21 TotallyNotJson.1017 TotallyNotJson.1018;
let TotallyNotJson.1016 : U64 = 100i64;
let TotallyNotJson.1014 : U64 = CallByName Num.94 TotallyNotJson.1015 TotallyNotJson.1016;
let TotallyNotJson.1014 : U64 = CallByName Num.137 TotallyNotJson.1015 TotallyNotJson.1016;
let TotallyNotJson.1011 : List U8 = CallByName List.68 TotallyNotJson.1014;
let TotallyNotJson.1013 : U8 = 34i64;
let TotallyNotJson.1012 : List U8 = Array [TotallyNotJson.1013];

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

@ -137,7 +137,7 @@ procedure List.8 (#Attr.2, #Attr.3):
let List.633 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.633;
procedure List.80 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
procedure List.80 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
joinpoint List.657 List.489 List.490 List.491 List.492 List.493:
let List.659 : Int1 = CallByName Num.22 List.492 List.493;
if List.659 then
@ -161,9 +161,9 @@ procedure List.80 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_g
let List.658 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.658;
in
jump List.657 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
jump List.657 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
procedure List.90 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
procedure List.90 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
joinpoint List.613 List.161 List.162 List.163 List.164 List.165:
let List.615 : Int1 = CallByName Num.22 List.164 List.165;
if List.615 then
@ -176,9 +176,9 @@ procedure List.90 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_g
dec List.161;
ret List.162;
in
jump List.613 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
jump List.613 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
procedure List.90 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
procedure List.90 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
joinpoint List.601 List.161 List.162 List.163 List.164 List.165:
let List.603 : Int1 = CallByName Num.22 List.164 List.165;
if List.603 then
@ -192,74 +192,69 @@ procedure List.90 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_g
dec List.161;
ret List.162;
in
jump List.601 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
jump List.601 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
procedure Num.127 (#Attr.2):
let Num.305 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.305;
let Num.264 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.264;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.137 (#Attr.2, #Attr.3):
let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.269;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.309 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.309;
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.268;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.306 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.306;
let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.265;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.311 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.311;
let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.270;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.317 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.317;
let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.276;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.319 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.319;
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.278;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.314 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.314;
let Num.273 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.273;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.318 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.318;
procedure Num.94 (#Attr.2, #Attr.3):
let Num.310 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.310;
let Num.277 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.277;
procedure Str.12 (#Attr.2):
let Str.262 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.262;
let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.260;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
let Str.258 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.258;
procedure Str.9 (Str.68):
let Str.257 : U64 = 0i64;
let Str.260 : U64 = CallByName List.6 Str.68;
let Str.258 : U64 = CallByName Num.133 Str.260;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.257 Str.258;
let Str.254 : Int1 = StructAtIndex 2 Str.69;
if Str.254 then
let Str.256 : Str = StructAtIndex 1 Str.69;
let Str.255 : [C {U64, U8}, C Str] = TagId(1) Str.256;
ret Str.255;
procedure Str.9 (Str.67):
let Str.256 : U64 = 0i64;
let Str.257 : U64 = CallByName List.6 Str.67;
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67 Str.256 Str.257;
let Str.253 : Int1 = StructAtIndex 2 Str.68;
if Str.253 then
let Str.255 : Str = StructAtIndex 1 Str.68;
let Str.254 : [C {U64, U8}, C Str] = TagId(1) Str.255;
ret Str.254;
else
let Str.252 : U8 = StructAtIndex 3 Str.69;
let Str.253 : U64 = StructAtIndex 0 Str.69;
let #Derived_gen.34 : Str = StructAtIndex 1 Str.69;
let Str.251 : U8 = StructAtIndex 3 Str.68;
let Str.252 : U64 = StructAtIndex 0 Str.68;
let #Derived_gen.34 : Str = StructAtIndex 1 Str.68;
dec #Derived_gen.34;
let Str.251 : {U64, U8} = Struct {Str.253, Str.252};
let Str.250 : [C {U64, U8}, C Str] = TagId(0) Str.251;
ret Str.250;
let Str.250 : {U64, U8} = Struct {Str.252, Str.251};
let Str.249 : [C {U64, U8}, C Str] = TagId(0) Str.250;
ret Str.249;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1014, TotallyNotJson.149):
let TotallyNotJson.1017 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;
@ -424,7 +419,7 @@ procedure TotallyNotJson.26 (TotallyNotJson.152):
let TotallyNotJson.1059 : U64 = 120i64;
let TotallyNotJson.1056 : U64 = CallByName Num.21 TotallyNotJson.1058 TotallyNotJson.1059;
let TotallyNotJson.1057 : U64 = 100i64;
let TotallyNotJson.1055 : U64 = CallByName Num.94 TotallyNotJson.1056 TotallyNotJson.1057;
let TotallyNotJson.1055 : U64 = CallByName Num.137 TotallyNotJson.1056 TotallyNotJson.1057;
let TotallyNotJson.1052 : List U8 = CallByName List.68 TotallyNotJson.1055;
let TotallyNotJson.1054 : U8 = 34i64;
let TotallyNotJson.1053 : List U8 = Array [TotallyNotJson.1054];

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

@ -140,7 +140,7 @@ procedure List.8 (#Attr.2, #Attr.3):
let List.633 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.633;
procedure List.80 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
procedure List.80 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
joinpoint List.657 List.489 List.490 List.491 List.492 List.493:
let List.659 : Int1 = CallByName Num.22 List.492 List.493;
if List.659 then
@ -164,24 +164,9 @@ procedure List.80 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_g
let List.658 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.658;
in
jump List.657 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
jump List.657 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
procedure List.90 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
joinpoint List.613 List.161 List.162 List.163 List.164 List.165:
let List.615 : Int1 = CallByName Num.22 List.164 List.165;
if List.615 then
let List.619 : U8 = CallByName List.66 List.161 List.164;
let List.166 : List U8 = CallByName TotallyNotJson.183 List.162 List.619;
let List.618 : U64 = 1i64;
let List.617 : U64 = CallByName Num.51 List.164 List.618;
jump List.613 List.161 List.166 List.163 List.617 List.165;
else
dec List.161;
ret List.162;
in
jump List.613 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
procedure List.90 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34):
procedure List.90 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
joinpoint List.601 List.161 List.162 List.163 List.164 List.165:
let List.603 : Int1 = CallByName Num.22 List.164 List.165;
if List.603 then
@ -195,74 +180,84 @@ procedure List.90 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_g
dec List.161;
ret List.162;
in
jump List.601 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
jump List.601 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28):
joinpoint List.613 List.161 List.162 List.163 List.164 List.165:
let List.615 : Int1 = CallByName Num.22 List.164 List.165;
if List.615 then
let List.619 : U8 = CallByName List.66 List.161 List.164;
let List.166 : List U8 = CallByName TotallyNotJson.183 List.162 List.619;
let List.618 : U64 = 1i64;
let List.617 : U64 = CallByName Num.51 List.164 List.618;
jump List.613 List.161 List.166 List.163 List.617 List.165;
else
dec List.161;
ret List.162;
in
jump List.613 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
procedure Num.127 (#Attr.2):
let Num.305 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.305;
let Num.264 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.264;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.137 (#Attr.2, #Attr.3):
let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.269;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.309 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.309;
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.268;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.306 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.306;
let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.265;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.311 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.311;
let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.270;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.317 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.317;
let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.276;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.319 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.319;
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.278;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.314 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.314;
let Num.273 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.273;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.318 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.318;
procedure Num.94 (#Attr.2, #Attr.3):
let Num.310 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.310;
let Num.277 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.277;
procedure Str.12 (#Attr.2):
let Str.262 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.262;
let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.260;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
let Str.258 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.258;
procedure Str.9 (Str.68):
let Str.257 : U64 = 0i64;
let Str.260 : U64 = CallByName List.6 Str.68;
let Str.258 : U64 = CallByName Num.133 Str.260;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.257 Str.258;
let Str.254 : Int1 = StructAtIndex 2 Str.69;
if Str.254 then
let Str.256 : Str = StructAtIndex 1 Str.69;
let Str.255 : [C {U64, U8}, C Str] = TagId(1) Str.256;
ret Str.255;
procedure Str.9 (Str.67):
let Str.256 : U64 = 0i64;
let Str.257 : U64 = CallByName List.6 Str.67;
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67 Str.256 Str.257;
let Str.253 : Int1 = StructAtIndex 2 Str.68;
if Str.253 then
let Str.255 : Str = StructAtIndex 1 Str.68;
let Str.254 : [C {U64, U8}, C Str] = TagId(1) Str.255;
ret Str.254;
else
let Str.252 : U8 = StructAtIndex 3 Str.69;
let Str.253 : U64 = StructAtIndex 0 Str.69;
let #Derived_gen.35 : Str = StructAtIndex 1 Str.69;
let Str.251 : U8 = StructAtIndex 3 Str.68;
let Str.252 : U64 = StructAtIndex 0 Str.68;
let #Derived_gen.35 : Str = StructAtIndex 1 Str.68;
dec #Derived_gen.35;
let Str.251 : {U64, U8} = Struct {Str.253, Str.252};
let Str.250 : [C {U64, U8}, C Str] = TagId(0) Str.251;
ret Str.250;
let Str.250 : {U64, U8} = Struct {Str.252, Str.251};
let Str.249 : [C {U64, U8}, C Str] = TagId(0) Str.250;
ret Str.249;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1014, TotallyNotJson.149):
let TotallyNotJson.1017 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;
@ -427,7 +422,7 @@ procedure TotallyNotJson.26 (TotallyNotJson.152):
let TotallyNotJson.1059 : U64 = 120i64;
let TotallyNotJson.1056 : U64 = CallByName Num.21 TotallyNotJson.1058 TotallyNotJson.1059;
let TotallyNotJson.1057 : U64 = 100i64;
let TotallyNotJson.1055 : U64 = CallByName Num.94 TotallyNotJson.1056 TotallyNotJson.1057;
let TotallyNotJson.1055 : U64 = CallByName Num.137 TotallyNotJson.1056 TotallyNotJson.1057;
let TotallyNotJson.1052 : List U8 = CallByName List.68 TotallyNotJson.1055;
let TotallyNotJson.1054 : U8 = 34i64;
let TotallyNotJson.1053 : List U8 = Array [TotallyNotJson.1054];

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

@ -1,10 +1,10 @@
procedure Num.20 (#Attr.2, #Attr.3):
let Num.298 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.258;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
joinpoint Test.7 Test.2 Test.3:

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.8):
let Test.3 : I64 = 10i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.298 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Test.1 (Test.9):
let Test.4 : U8 = 10i64;

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

@ -3,8 +3,8 @@ procedure Bool.1 ():
ret Bool.23;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.3 (Test.4):
ret Test.4;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.299 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.259;
procedure Test.2 (Test.3):
switch Test.3:

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.298 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Test.2 (Test.3, Test.1):
let Test.18 : Int1 = false;

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

File diff suppressed because it is too large Load diff

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

@ -3,13 +3,13 @@ procedure #Derived.0 (#Derived.1):
ret #Derived_gen.0;
procedure #Derived.3 (#Derived.2):
let #Derived_gen.7 : I64 = CallByName Inspect.54 #Derived.2;
let #Derived_gen.7 : I64 = CallByName Inspect.53 #Derived.2;
ret #Derived_gen.7;
procedure #Derived.4 (#Derived.5, #Derived.1):
let #Derived_gen.5 : {} = Struct {};
let #Derived_gen.6 : {} = Struct {};
let #Derived_gen.4 : {List I64, {}, {}} = CallByName Inspect.37 #Derived.1 #Derived_gen.5 #Derived_gen.6;
let #Derived_gen.4 : {List I64, {}, {}} = CallByName Inspect.36 #Derived.1 #Derived_gen.5 #Derived_gen.6;
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.5;
ret #Derived_gen.3;
@ -21,109 +21,109 @@ procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Inspect.157 (Inspect.158, #Attr.12):
let Inspect.156 : {} = StructAtIndex 2 #Attr.12;
let Inspect.155 : {} = StructAtIndex 1 #Attr.12;
let Inspect.154 : List I64 = StructAtIndex 0 #Attr.12;
let Inspect.351 : Str = "[";
let Inspect.332 : Str = CallByName Inspect.61 Inspect.158 Inspect.351;
let Inspect.333 : {List I64, {}, {}} = Struct {Inspect.154, Inspect.155, Inspect.156};
let Inspect.328 : {Str, Int1} = CallByName Inspect.159 Inspect.332 Inspect.333;
let Inspect.329 : {} = Struct {};
let Inspect.324 : Str = CallByName Inspect.168 Inspect.328;
let Inspect.325 : Str = "]";
let Inspect.323 : Str = CallByName Inspect.61 Inspect.324 Inspect.325;
ret Inspect.323;
procedure Inspect.159 (Inspect.160, #Attr.12):
let Inspect.156 : {} = StructAtIndex 2 #Attr.12;
let Inspect.155 : {} = StructAtIndex 1 #Attr.12;
let Inspect.154 : List I64 = StructAtIndex 0 #Attr.12;
let Inspect.350 : Int1 = CallByName Bool.1;
let Inspect.336 : {Str, Int1} = Struct {Inspect.160, Inspect.350};
let Inspect.335 : {Str, Int1} = CallByName List.18 Inspect.154 Inspect.336 Inspect.156;
ret Inspect.335;
procedure Inspect.161 (Inspect.338, Inspect.164, Inspect.156):
let Inspect.162 : Str = StructAtIndex 0 Inspect.338;
let Inspect.163 : Int1 = StructAtIndex 1 Inspect.338;
joinpoint Inspect.348 Inspect.165:
let Inspect.345 : I64 = CallByName #Derived.3 Inspect.164;
let Inspect.341 : Str = CallByName Inspect.31 Inspect.345 Inspect.165;
let Inspect.342 : {} = Struct {};
let Inspect.340 : {Str, Int1} = CallByName Inspect.166 Inspect.341;
ret Inspect.340;
in
if Inspect.163 then
let Inspect.349 : Str = ", ";
let Inspect.347 : Str = CallByName Inspect.61 Inspect.162 Inspect.349;
jump Inspect.348 Inspect.347;
else
jump Inspect.348 Inspect.162;
procedure Inspect.166 (Inspect.167):
let Inspect.344 : Int1 = CallByName Bool.2;
let Inspect.343 : {Str, Int1} = Struct {Inspect.167, Inspect.344};
ret Inspect.343;
procedure Inspect.168 (Inspect.330):
let Inspect.331 : Str = StructAtIndex 0 Inspect.330;
ret Inspect.331;
procedure Inspect.279 (Inspect.280, Inspect.278):
let Inspect.357 : Str = CallByName Num.96 Inspect.278;
let Inspect.356 : Str = CallByName Inspect.61 Inspect.280 Inspect.357;
ret Inspect.356;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.318 : Str = CallByName Inspect.157 Inspect.150 Inspect.307;
ret Inspect.318;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.346 : Str = CallByName Inspect.279 Inspect.150 Inspect.307;
ret Inspect.346;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
procedure Inspect.152 (Inspect.153, #Attr.12):
let Inspect.151 : {} = StructAtIndex 2 #Attr.12;
let Inspect.150 : {} = StructAtIndex 1 #Attr.12;
let Inspect.149 : List I64 = StructAtIndex 0 #Attr.12;
let Inspect.343 : Str = "[";
let Inspect.324 : Str = CallByName Inspect.59 Inspect.153 Inspect.343;
let Inspect.325 : {List I64, {}, {}} = Struct {Inspect.149, Inspect.150, Inspect.151};
let Inspect.320 : {Str, Int1} = CallByName Inspect.154 Inspect.324 Inspect.325;
let Inspect.321 : {} = Struct {};
let Inspect.316 : Str = CallByName Inspect.163 Inspect.320;
let Inspect.317 : Str = "]";
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
ret Inspect.315;
procedure Inspect.37 (Inspect.154, Inspect.155, Inspect.156):
let Inspect.320 : {List I64, {}, {}} = Struct {Inspect.154, Inspect.155, Inspect.156};
let Inspect.319 : {List I64, {}, {}} = CallByName Inspect.30 Inspect.320;
ret Inspect.319;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : List I64 = CallByName #Derived.0 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName #Derived.4 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.54 (Inspect.278):
let Inspect.352 : I64 = CallByName Inspect.30 Inspect.278;
ret Inspect.352;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.327 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
procedure Inspect.154 (Inspect.155, #Attr.12):
let Inspect.151 : {} = StructAtIndex 2 #Attr.12;
let Inspect.150 : {} = StructAtIndex 1 #Attr.12;
let Inspect.149 : List I64 = StructAtIndex 0 #Attr.12;
let Inspect.342 : Int1 = CallByName Bool.1;
let Inspect.328 : {Str, Int1} = Struct {Inspect.155, Inspect.342};
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.149 Inspect.328 Inspect.151;
ret Inspect.327;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.156 (Inspect.330, Inspect.159, Inspect.151):
let Inspect.157 : Str = StructAtIndex 0 Inspect.330;
let Inspect.158 : Int1 = StructAtIndex 1 Inspect.330;
joinpoint Inspect.340 Inspect.160:
let Inspect.337 : I64 = CallByName #Derived.3 Inspect.159;
let Inspect.333 : Str = CallByName Inspect.31 Inspect.337 Inspect.160;
let Inspect.334 : {} = Struct {};
let Inspect.332 : {Str, Int1} = CallByName Inspect.161 Inspect.333;
ret Inspect.332;
in
if Inspect.158 then
let Inspect.341 : Str = ", ";
let Inspect.339 : Str = CallByName Inspect.59 Inspect.157 Inspect.341;
jump Inspect.340 Inspect.339;
else
jump Inspect.340 Inspect.157;
procedure Inspect.161 (Inspect.162):
let Inspect.336 : Int1 = CallByName Bool.2;
let Inspect.335 : {Str, Int1} = Struct {Inspect.162, Inspect.336};
ret Inspect.335;
procedure Inspect.163 (Inspect.322):
let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
ret Inspect.323;
procedure Inspect.274 (Inspect.275, Inspect.273):
let Inspect.349 : Str = CallByName Num.96 Inspect.273;
let Inspect.348 : Str = CallByName Inspect.59 Inspect.275 Inspect.349;
ret Inspect.348;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.310 : Str = CallByName Inspect.152 Inspect.145 Inspect.299;
ret Inspect.310;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.338 : Str = CallByName Inspect.274 Inspect.145 Inspect.299;
ret Inspect.338;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.36 (Inspect.149, Inspect.150, Inspect.151):
let Inspect.312 : {List I64, {}, {}} = Struct {Inspect.149, Inspect.150, Inspect.151};
let Inspect.311 : {List I64, {}, {}} = CallByName Inspect.30 Inspect.312;
ret Inspect.311;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : List I64 = CallByName #Derived.0 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName #Derived.4 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.53 (Inspect.273):
let Inspect.344 : I64 = CallByName Inspect.30 Inspect.273;
ret Inspect.344;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.319;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure List.18 (List.158, List.159, List.160):
let List.572 : U64 = 0i64;
@ -139,12 +139,12 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.581 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.581;
procedure List.90 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
procedure List.90 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
joinpoint List.574 List.161 List.162 List.163 List.164 List.165:
let List.576 : Int1 = CallByName Num.22 List.164 List.165;
if List.576 then
let List.580 : I64 = CallByName List.66 List.161 List.164;
let List.166 : {Str, Int1} = CallByName Inspect.161 List.162 List.580 List.163;
let List.166 : {Str, Int1} = CallByName Inspect.156 List.162 List.580 List.163;
let List.579 : U64 = 1i64;
let List.578 : U64 = CallByName Num.51 List.164 List.579;
jump List.574 List.161 List.166 List.163 List.578 List.165;
@ -152,25 +152,25 @@ procedure List.90 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_g
dec List.161;
ret List.162;
in
jump List.574 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
jump List.574 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.299 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.259;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.298 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.258;
procedure Num.96 (#Attr.2):
let Num.297 : Str = lowlevel NumToStr #Attr.2;
ret Num.297;
let Num.257 : Str = lowlevel NumToStr #Attr.2;
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.2 : List I64 = Array [1i64, 2i64, 3i64];
let Test.1 : Str = CallByName Inspect.34 Test.2;
let Test.1 : Str = CallByName Inspect.33 Test.2;
ret Test.1;

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

@ -7,7 +7,7 @@ procedure #Derived.2 (#Derived.3, #Derived.1):
let #Derived_gen.8 : Str = CallByName #Derived.4 #Derived.1;
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.42 #Derived_gen.5;
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.5;
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
ret #Derived_gen.3;
@ -17,10 +17,10 @@ procedure #Derived.4 (#Derived.5):
procedure #Derived.6 (#Derived.7, #Derived.5):
let #Derived_gen.17 : Str = "b";
let #Derived_gen.18 : Str = CallByName Inspect.44 #Derived.5;
let #Derived_gen.18 : Str = CallByName Inspect.43 #Derived.5;
let #Derived_gen.16 : {Str, Str} = Struct {#Derived_gen.17, #Derived_gen.18};
let #Derived_gen.15 : List {Str, Str} = Array [#Derived_gen.16];
let #Derived_gen.14 : List {Str, Str} = CallByName Inspect.42 #Derived_gen.15;
let #Derived_gen.14 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.15;
let #Derived_gen.13 : Str = CallByName Inspect.31 #Derived_gen.14 #Derived.7;
ret #Derived_gen.13;
@ -32,173 +32,173 @@ procedure Bool.2 ():
let Bool.25 : Int1 = true;
ret Bool.25;
procedure Inspect.230 (Inspect.231, Inspect.229):
let Inspect.356 : Str = "{";
let Inspect.332 : Str = CallByName Inspect.61 Inspect.231 Inspect.356;
let Inspect.328 : {Str, Int1} = CallByName Inspect.232 Inspect.332 Inspect.229;
let Inspect.329 : {} = Struct {};
let Inspect.324 : Str = CallByName Inspect.244 Inspect.328;
let Inspect.325 : Str = "}";
let Inspect.323 : Str = CallByName Inspect.61 Inspect.324 Inspect.325;
ret Inspect.323;
procedure Inspect.230 (Inspect.231, Inspect.229):
let Inspect.396 : Str = "{";
let Inspect.372 : Str = CallByName Inspect.61 Inspect.231 Inspect.396;
let Inspect.368 : {Str, Int1} = CallByName Inspect.232 Inspect.372 Inspect.229;
let Inspect.369 : {} = Struct {};
let Inspect.364 : Str = CallByName Inspect.244 Inspect.368;
let Inspect.365 : Str = "}";
let Inspect.363 : Str = CallByName Inspect.61 Inspect.364 Inspect.365;
ret Inspect.363;
procedure Inspect.232 (Inspect.233, Inspect.229):
let Inspect.355 : Int1 = CallByName Bool.1;
let Inspect.336 : {Str, Int1} = Struct {Inspect.233, Inspect.355};
let Inspect.337 : {} = Struct {};
let Inspect.335 : {Str, Int1} = CallByName List.18 Inspect.229 Inspect.336 Inspect.337;
ret Inspect.335;
procedure Inspect.232 (Inspect.233, Inspect.229):
let Inspect.395 : Int1 = CallByName Bool.1;
let Inspect.376 : {Str, Int1} = Struct {Inspect.233, Inspect.395};
let Inspect.377 : {} = Struct {};
let Inspect.375 : {Str, Int1} = CallByName List.18 Inspect.229 Inspect.376 Inspect.377;
ret Inspect.375;
procedure Inspect.234 (Inspect.338, Inspect.339):
let Inspect.237 : Str = StructAtIndex 0 Inspect.339;
let Inspect.238 : Str = StructAtIndex 1 Inspect.339;
let Inspect.235 : Str = StructAtIndex 0 Inspect.338;
let Inspect.236 : Int1 = StructAtIndex 1 Inspect.338;
joinpoint Inspect.353 Inspect.239:
let Inspect.350 : Str = CallByName Inspect.61 Inspect.239 Inspect.237;
let Inspect.351 : Str = ": ";
let Inspect.345 : Str = CallByName Inspect.61 Inspect.350 Inspect.351;
let Inspect.341 : Str = CallByName Inspect.240 Inspect.345 Inspect.238;
let Inspect.342 : {} = Struct {};
let Inspect.340 : {Str, Int1} = CallByName Inspect.242 Inspect.341;
ret Inspect.340;
in
if Inspect.236 then
let Inspect.354 : Str = ", ";
let Inspect.352 : Str = CallByName Inspect.61 Inspect.235 Inspect.354;
jump Inspect.353 Inspect.352;
else
jump Inspect.353 Inspect.235;
procedure Inspect.234 (Inspect.338, Inspect.339):
let Inspect.237 : Str = StructAtIndex 0 Inspect.339;
let Inspect.238 : Str = StructAtIndex 1 Inspect.339;
let Inspect.235 : Str = StructAtIndex 0 Inspect.338;
let Inspect.236 : Int1 = StructAtIndex 1 Inspect.338;
joinpoint Inspect.393 Inspect.239:
let Inspect.390 : Str = CallByName Inspect.61 Inspect.239 Inspect.237;
let Inspect.391 : Str = ": ";
let Inspect.385 : Str = CallByName Inspect.61 Inspect.390 Inspect.391;
let Inspect.381 : Str = CallByName Inspect.240 Inspect.385 Inspect.238;
let Inspect.382 : {} = Struct {};
let Inspect.380 : {Str, Int1} = CallByName Inspect.242 Inspect.381;
ret Inspect.380;
in
if Inspect.236 then
let Inspect.394 : Str = ", ";
let Inspect.392 : Str = CallByName Inspect.61 Inspect.235 Inspect.394;
jump Inspect.393 Inspect.392;
else
jump Inspect.393 Inspect.235;
procedure Inspect.240 (Inspect.241, Inspect.238):
let Inspect.348 : Str = CallByName Inspect.31 Inspect.238 Inspect.241;
ret Inspect.348;
procedure Inspect.240 (Inspect.241, Inspect.238):
let Inspect.388 : Str = CallByName Inspect.31 Inspect.238 Inspect.241;
ret Inspect.388;
procedure Inspect.242 (Inspect.243):
let Inspect.384 : Int1 = CallByName Bool.2;
let Inspect.383 : {Str, Int1} = Struct {Inspect.243, Inspect.384};
ret Inspect.383;
procedure Inspect.244 (Inspect.330):
let Inspect.371 : Str = StructAtIndex 0 Inspect.330;
ret Inspect.371;
procedure Inspect.251 (Inspect.252, Inspect.250):
let Inspect.405 : Str = "\"";
let Inspect.404 : Str = CallByName Inspect.61 Inspect.252 Inspect.405;
let Inspect.402 : Str = CallByName Inspect.61 Inspect.404 Inspect.250;
let Inspect.403 : Str = "\"";
let Inspect.401 : Str = CallByName Inspect.61 Inspect.402 Inspect.403;
ret Inspect.401;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.318 : Str = CallByName Inspect.230 Inspect.150 Inspect.307;
ret Inspect.318;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.349 : Str = CallByName #Derived.6 Inspect.150 Inspect.307;
ret Inspect.349;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.358 : Str = CallByName Inspect.230 Inspect.150 Inspect.307;
ret Inspect.358;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.389 : Str = CallByName Inspect.251 Inspect.150 Inspect.307;
ret Inspect.389;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
procedure Inspect.225 (Inspect.226, Inspect.224):
let Inspect.348 : Str = "{";
let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.348;
let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
let Inspect.321 : {} = Struct {};
let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
let Inspect.317 : Str = "}";
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
ret Inspect.315;
procedure Inspect.42 (Inspect.229):
let Inspect.319 : List {Str, Str} = CallByName Inspect.30 Inspect.229;
ret Inspect.319;
procedure Inspect.225 (Inspect.226, Inspect.224):
let Inspect.388 : Str = "{";
let Inspect.364 : Str = CallByName Inspect.59 Inspect.226 Inspect.388;
let Inspect.360 : {Str, Int1} = CallByName Inspect.227 Inspect.364 Inspect.224;
let Inspect.361 : {} = Struct {};
let Inspect.356 : Str = CallByName Inspect.239 Inspect.360;
let Inspect.357 : Str = "}";
let Inspect.355 : Str = CallByName Inspect.59 Inspect.356 Inspect.357;
ret Inspect.355;
procedure Inspect.42 (Inspect.229):
let Inspect.359 : List {Str, Str} = CallByName Inspect.30 Inspect.229;
ret Inspect.359;
procedure Inspect.227 (Inspect.228, Inspect.224):
let Inspect.347 : Int1 = CallByName Bool.1;
let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.347};
let Inspect.329 : {} = Struct {};
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
ret Inspect.327;
procedure Inspect.44 (Inspect.250):
let Inspect.397 : Str = CallByName Inspect.30 Inspect.250;
ret Inspect.397;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : Str = CallByName #Derived.0 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName #Derived.2 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.367 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
procedure Inspect.227 (Inspect.228, Inspect.224):
let Inspect.387 : Int1 = CallByName Bool.1;
let Inspect.368 : {Str, Int1} = Struct {Inspect.228, Inspect.387};
let Inspect.369 : {} = Struct {};
let Inspect.367 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.368 Inspect.369;
ret Inspect.367;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.229 (Inspect.330, Inspect.331):
let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
joinpoint Inspect.345 Inspect.234:
let Inspect.342 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
let Inspect.343 : Str = ": ";
let Inspect.337 : Str = CallByName Inspect.59 Inspect.342 Inspect.343;
let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
let Inspect.334 : {} = Struct {};
let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
ret Inspect.332;
in
if Inspect.231 then
let Inspect.346 : Str = ", ";
let Inspect.344 : Str = CallByName Inspect.59 Inspect.230 Inspect.346;
jump Inspect.345 Inspect.344;
else
jump Inspect.345 Inspect.230;
procedure Inspect.229 (Inspect.330, Inspect.331):
let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
joinpoint Inspect.385 Inspect.234:
let Inspect.382 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
let Inspect.383 : Str = ": ";
let Inspect.377 : Str = CallByName Inspect.59 Inspect.382 Inspect.383;
let Inspect.373 : Str = CallByName Inspect.235 Inspect.377 Inspect.233;
let Inspect.374 : {} = Struct {};
let Inspect.372 : {Str, Int1} = CallByName Inspect.237 Inspect.373;
ret Inspect.372;
in
if Inspect.231 then
let Inspect.386 : Str = ", ";
let Inspect.384 : Str = CallByName Inspect.59 Inspect.230 Inspect.386;
jump Inspect.385 Inspect.384;
else
jump Inspect.385 Inspect.230;
procedure Inspect.235 (Inspect.236, Inspect.233):
let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
ret Inspect.340;
procedure Inspect.235 (Inspect.236, Inspect.233):
let Inspect.380 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
ret Inspect.380;
procedure Inspect.237 (Inspect.238):
let Inspect.376 : Int1 = CallByName Bool.2;
let Inspect.375 : {Str, Int1} = Struct {Inspect.238, Inspect.376};
ret Inspect.375;
procedure Inspect.239 (Inspect.322):
let Inspect.363 : Str = StructAtIndex 0 Inspect.322;
ret Inspect.363;
procedure Inspect.246 (Inspect.247, Inspect.245):
let Inspect.397 : Str = "\"";
let Inspect.396 : Str = CallByName Inspect.59 Inspect.247 Inspect.397;
let Inspect.394 : Str = CallByName Inspect.59 Inspect.396 Inspect.245;
let Inspect.395 : Str = "\"";
let Inspect.393 : Str = CallByName Inspect.59 Inspect.394 Inspect.395;
ret Inspect.393;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
ret Inspect.310;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.341 : Str = CallByName #Derived.6 Inspect.145 Inspect.299;
ret Inspect.341;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.350 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
ret Inspect.350;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.381 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
ret Inspect.381;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.41 (Inspect.224):
let Inspect.311 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
ret Inspect.311;
procedure Inspect.41 (Inspect.224):
let Inspect.351 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
ret Inspect.351;
procedure Inspect.43 (Inspect.245):
let Inspect.389 : Str = CallByName Inspect.30 Inspect.245;
ret Inspect.389;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : Str = CallByName #Derived.0 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.359 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.359;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure List.18 (List.158, List.159, List.160):
let List.572 : U64 = 0i64;
@ -234,7 +234,7 @@ procedure List.90 (#Derived_gen.32, #Derived_gen.33, #Derived_gen.34, #Derived_g
if List.588 then
let List.592 : {Str, Str} = CallByName List.66 List.161 List.164;
inc List.592;
let List.166 : {Str, Int1} = CallByName Inspect.234 List.162 List.592;
let List.166 : {Str, Int1} = CallByName Inspect.229 List.162 List.592;
let List.591 : U64 = 1i64;
let List.590 : U64 = CallByName Num.51 List.164 List.591;
jump List.586 List.161 List.166 List.163 List.590 List.165;
@ -250,7 +250,7 @@ procedure List.90 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_g
if List.576 then
let List.580 : {Str, Str} = CallByName List.66 List.161 List.164;
inc List.580;
let List.166 : {Str, Int1} = CallByName Inspect.234 List.162 List.580;
let List.166 : {Str, Int1} = CallByName Inspect.229 List.162 List.580;
let List.579 : U64 = 1i64;
let List.578 : U64 = CallByName Num.51 List.164 List.579;
jump List.574 List.161 List.166 List.163 List.578 List.165;
@ -261,18 +261,18 @@ procedure List.90 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_g
jump List.574 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.300 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.300;
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.260;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.299 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.259;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.251;
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
procedure Test.0 ():
let Test.4 : Str = "bar";
let Test.1 : Str = CallByName Inspect.34 Test.4;
let Test.1 : Str = CallByName Inspect.33 Test.4;
ret Test.1;

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

@ -4,15 +4,15 @@ procedure #Derived.0 (#Derived.1):
procedure #Derived.2 (#Derived.3, #Derived.1):
let #Derived_gen.13 : I64 = StructAtIndex 1 #Derived.1;
let #Derived_gen.11 : [C I64, C Decimal] = CallByName Inspect.54 #Derived_gen.13;
let #Derived_gen.11 : [C I64, C Decimal] = CallByName Inspect.53 #Derived_gen.13;
let #Derived_gen.12 : Str = "a";
let #Derived_gen.6 : {[C I64, C Decimal], Str} = Struct {#Derived_gen.11, #Derived_gen.12};
let #Derived_gen.10 : Decimal = StructAtIndex 0 #Derived.1;
let #Derived_gen.8 : [C I64, C Decimal] = CallByName Inspect.60 #Derived_gen.10;
let #Derived_gen.8 : [C I64, C Decimal] = CallByName Inspect.58 #Derived_gen.10;
let #Derived_gen.9 : Str = "b";
let #Derived_gen.7 : {[C I64, C Decimal], Str} = Struct {#Derived_gen.8, #Derived_gen.9};
let #Derived_gen.5 : List {[C I64, C Decimal], Str} = Array [#Derived_gen.6, #Derived_gen.7];
let #Derived_gen.4 : List {[C I64, C Decimal], Str} = CallByName Inspect.42 #Derived_gen.5;
let #Derived_gen.4 : List {[C I64, C Decimal], Str} = CallByName Inspect.41 #Derived_gen.5;
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
ret #Derived_gen.3;
@ -24,131 +24,131 @@ procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Inspect.230 (Inspect.231, Inspect.229):
let Inspect.357 : Str = "{";
let Inspect.332 : Str = CallByName Inspect.61 Inspect.231 Inspect.357;
let Inspect.328 : {Str, Int1} = CallByName Inspect.232 Inspect.332 Inspect.229;
let Inspect.329 : {} = Struct {};
let Inspect.324 : Str = CallByName Inspect.244 Inspect.328;
let Inspect.325 : Str = "}";
let Inspect.323 : Str = CallByName Inspect.61 Inspect.324 Inspect.325;
ret Inspect.323;
procedure Inspect.232 (Inspect.233, Inspect.229):
let Inspect.356 : Int1 = CallByName Bool.1;
let Inspect.336 : {Str, Int1} = Struct {Inspect.233, Inspect.356};
let Inspect.337 : {} = Struct {};
let Inspect.335 : {Str, Int1} = CallByName List.18 Inspect.229 Inspect.336 Inspect.337;
ret Inspect.335;
procedure Inspect.234 (Inspect.338, Inspect.339):
let Inspect.238 : [C I64, C Decimal] = StructAtIndex 0 Inspect.339;
let Inspect.237 : Str = StructAtIndex 1 Inspect.339;
let Inspect.235 : Str = StructAtIndex 0 Inspect.338;
let Inspect.236 : Int1 = StructAtIndex 1 Inspect.338;
joinpoint Inspect.354 Inspect.239:
let Inspect.351 : Str = CallByName Inspect.61 Inspect.239 Inspect.237;
let Inspect.352 : Str = ": ";
let Inspect.345 : Str = CallByName Inspect.61 Inspect.351 Inspect.352;
let Inspect.341 : Str = CallByName Inspect.240 Inspect.345 Inspect.238;
let Inspect.342 : {} = Struct {};
let Inspect.340 : {Str, Int1} = CallByName Inspect.242 Inspect.341;
ret Inspect.340;
in
if Inspect.236 then
let Inspect.355 : Str = ", ";
let Inspect.353 : Str = CallByName Inspect.61 Inspect.235 Inspect.355;
jump Inspect.354 Inspect.353;
else
jump Inspect.354 Inspect.235;
procedure Inspect.240 (Inspect.241, Inspect.238):
let Inspect.348 : Str = CallByName Inspect.31 Inspect.238 Inspect.241;
ret Inspect.348;
procedure Inspect.242 (Inspect.243):
let Inspect.344 : Int1 = CallByName Bool.2;
let Inspect.343 : {Str, Int1} = Struct {Inspect.243, Inspect.344};
ret Inspect.343;
procedure Inspect.244 (Inspect.330):
let Inspect.331 : Str = StructAtIndex 0 Inspect.330;
ret Inspect.331;
procedure Inspect.279 (Inspect.280, #Attr.12):
let Inspect.370 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.369 : Str = CallByName Num.96 Inspect.370;
let Inspect.368 : Str = CallByName Inspect.61 Inspect.280 Inspect.369;
ret Inspect.368;
procedure Inspect.297 (Inspect.298, #Attr.12):
let Inspect.364 : Decimal = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.363 : Str = CallByName Num.96 Inspect.364;
let Inspect.362 : Str = CallByName Inspect.61 Inspect.298 Inspect.363;
ret Inspect.362;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.318 : Str = CallByName Inspect.230 Inspect.150 Inspect.307;
ret Inspect.318;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.350 : U8 = GetTagId Inspect.307;
switch Inspect.350:
case 0:
let Inspect.349 : Str = CallByName Inspect.279 Inspect.150 Inspect.307;
ret Inspect.349;
default:
let Inspect.349 : Str = CallByName Inspect.297 Inspect.150 Inspect.307;
ret Inspect.349;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
procedure Inspect.225 (Inspect.226, Inspect.224):
let Inspect.349 : Str = "{";
let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.349;
let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
let Inspect.321 : {} = Struct {};
let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
let Inspect.317 : Str = "}";
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
ret Inspect.315;
procedure Inspect.42 (Inspect.229):
let Inspect.319 : List {[C I64, C Decimal], Str} = CallByName Inspect.30 Inspect.229;
ret Inspect.319;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : {Decimal, I64} = CallByName #Derived.0 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName #Derived.2 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.54 (Inspect.278):
let Inspect.366 : [C I64, C Decimal] = TagId(0) Inspect.278;
let Inspect.365 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.366;
ret Inspect.365;
procedure Inspect.60 (Inspect.296):
let Inspect.359 : [C I64, C Decimal] = TagId(1) Inspect.296;
let Inspect.358 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.359;
ret Inspect.358;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.327 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
procedure Inspect.227 (Inspect.228, Inspect.224):
let Inspect.348 : Int1 = CallByName Bool.1;
let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.348};
let Inspect.329 : {} = Struct {};
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
ret Inspect.327;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.229 (Inspect.330, Inspect.331):
let Inspect.233 : [C I64, C Decimal] = StructAtIndex 0 Inspect.331;
let Inspect.232 : Str = StructAtIndex 1 Inspect.331;
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
joinpoint Inspect.346 Inspect.234:
let Inspect.343 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
let Inspect.344 : Str = ": ";
let Inspect.337 : Str = CallByName Inspect.59 Inspect.343 Inspect.344;
let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
let Inspect.334 : {} = Struct {};
let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
ret Inspect.332;
in
if Inspect.231 then
let Inspect.347 : Str = ", ";
let Inspect.345 : Str = CallByName Inspect.59 Inspect.230 Inspect.347;
jump Inspect.346 Inspect.345;
else
jump Inspect.346 Inspect.230;
procedure Inspect.235 (Inspect.236, Inspect.233):
let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
ret Inspect.340;
procedure Inspect.237 (Inspect.238):
let Inspect.336 : Int1 = CallByName Bool.2;
let Inspect.335 : {Str, Int1} = Struct {Inspect.238, Inspect.336};
ret Inspect.335;
procedure Inspect.239 (Inspect.322):
let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
ret Inspect.323;
procedure Inspect.274 (Inspect.275, #Attr.12):
let Inspect.362 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.361 : Str = CallByName Num.96 Inspect.362;
let Inspect.360 : Str = CallByName Inspect.59 Inspect.275 Inspect.361;
ret Inspect.360;
procedure Inspect.289 (Inspect.290, #Attr.12):
let Inspect.356 : Decimal = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.355 : Str = CallByName Num.96 Inspect.356;
let Inspect.354 : Str = CallByName Inspect.59 Inspect.290 Inspect.355;
ret Inspect.354;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
ret Inspect.310;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.342 : U8 = GetTagId Inspect.299;
switch Inspect.342:
case 0:
let Inspect.341 : Str = CallByName Inspect.274 Inspect.145 Inspect.299;
ret Inspect.341;
default:
let Inspect.341 : Str = CallByName Inspect.289 Inspect.145 Inspect.299;
ret Inspect.341;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.41 (Inspect.224):
let Inspect.311 : List {[C I64, C Decimal], Str} = CallByName Inspect.30 Inspect.224;
ret Inspect.311;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : {Decimal, I64} = CallByName #Derived.0 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.53 (Inspect.273):
let Inspect.358 : [C I64, C Decimal] = TagId(0) Inspect.273;
let Inspect.357 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.358;
ret Inspect.357;
procedure Inspect.58 (Inspect.288):
let Inspect.351 : [C I64, C Decimal] = TagId(1) Inspect.288;
let Inspect.350 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.351;
ret Inspect.350;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.319;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure List.18 (List.158, List.159, List.160):
let List.572 : U64 = 0i64;
@ -164,13 +164,13 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.581 : {[C I64, C Decimal], Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.581;
procedure List.90 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28):
joinpoint List.574 List.161 List.162 List.163 List.164 List.165:
let List.576 : Int1 = CallByName Num.22 List.164 List.165;
if List.576 then
let List.580 : {[C I64, C Decimal], Str} = CallByName List.66 List.161 List.164;
inc List.580;
let List.166 : {Str, Int1} = CallByName Inspect.234 List.162 List.580;
let List.166 : {Str, Int1} = CallByName Inspect.229 List.162 List.580;
let List.579 : U64 = 1i64;
let List.578 : U64 = CallByName Num.51 List.164 List.579;
jump List.574 List.161 List.166 List.163 List.578 List.165;
@ -178,31 +178,31 @@ procedure List.90 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_g
dec List.161;
ret List.162;
in
jump List.574 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
jump List.574 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.300 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.300;
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.260;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.299 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.259;
procedure Num.96 (#Attr.2):
let Num.297 : Str = lowlevel NumToStr #Attr.2;
ret Num.297;
let Num.257 : Str = lowlevel NumToStr #Attr.2;
ret Num.257;
procedure Num.96 (#Attr.2):
let Num.298 : Str = lowlevel NumToStr #Attr.2;
ret Num.298;
let Num.258 : Str = lowlevel NumToStr #Attr.2;
ret Num.258;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.3 : Decimal = 3dec;
let Test.4 : I64 = 7i64;
let Test.2 : {Decimal, I64} = Struct {Test.3, Test.4};
let Test.1 : Str = CallByName Inspect.34 Test.2;
let Test.1 : Str = CallByName Inspect.33 Test.2;
ret Test.1;

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

@ -4,10 +4,10 @@ procedure #Derived.0 (#Derived.1):
procedure #Derived.2 (#Derived.3, #Derived.1):
let #Derived_gen.7 : Str = "a";
let #Derived_gen.8 : Str = CallByName Inspect.44 #Derived.1;
let #Derived_gen.8 : Str = CallByName Inspect.43 #Derived.1;
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.42 #Derived_gen.5;
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.5;
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
ret #Derived_gen.3;
@ -19,113 +19,113 @@ procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Inspect.230 (Inspect.231, Inspect.229):
let Inspect.356 : Str = "{";
let Inspect.332 : Str = CallByName Inspect.61 Inspect.231 Inspect.356;
let Inspect.328 : {Str, Int1} = CallByName Inspect.232 Inspect.332 Inspect.229;
let Inspect.329 : {} = Struct {};
let Inspect.324 : Str = CallByName Inspect.244 Inspect.328;
let Inspect.325 : Str = "}";
let Inspect.323 : Str = CallByName Inspect.61 Inspect.324 Inspect.325;
ret Inspect.323;
procedure Inspect.232 (Inspect.233, Inspect.229):
let Inspect.355 : Int1 = CallByName Bool.1;
let Inspect.336 : {Str, Int1} = Struct {Inspect.233, Inspect.355};
let Inspect.337 : {} = Struct {};
let Inspect.335 : {Str, Int1} = CallByName List.18 Inspect.229 Inspect.336 Inspect.337;
ret Inspect.335;
procedure Inspect.234 (Inspect.338, Inspect.339):
let Inspect.237 : Str = StructAtIndex 0 Inspect.339;
let Inspect.238 : Str = StructAtIndex 1 Inspect.339;
let Inspect.235 : Str = StructAtIndex 0 Inspect.338;
let Inspect.236 : Int1 = StructAtIndex 1 Inspect.338;
joinpoint Inspect.353 Inspect.239:
let Inspect.350 : Str = CallByName Inspect.61 Inspect.239 Inspect.237;
let Inspect.351 : Str = ": ";
let Inspect.345 : Str = CallByName Inspect.61 Inspect.350 Inspect.351;
let Inspect.341 : Str = CallByName Inspect.240 Inspect.345 Inspect.238;
let Inspect.342 : {} = Struct {};
let Inspect.340 : {Str, Int1} = CallByName Inspect.242 Inspect.341;
ret Inspect.340;
in
if Inspect.236 then
let Inspect.354 : Str = ", ";
let Inspect.352 : Str = CallByName Inspect.61 Inspect.235 Inspect.354;
jump Inspect.353 Inspect.352;
else
jump Inspect.353 Inspect.235;
procedure Inspect.240 (Inspect.241, Inspect.238):
let Inspect.348 : Str = CallByName Inspect.31 Inspect.238 Inspect.241;
ret Inspect.348;
procedure Inspect.242 (Inspect.243):
let Inspect.344 : Int1 = CallByName Bool.2;
let Inspect.343 : {Str, Int1} = Struct {Inspect.243, Inspect.344};
ret Inspect.343;
procedure Inspect.244 (Inspect.330):
let Inspect.331 : Str = StructAtIndex 0 Inspect.330;
ret Inspect.331;
procedure Inspect.251 (Inspect.252, Inspect.250):
let Inspect.365 : Str = "\"";
let Inspect.364 : Str = CallByName Inspect.61 Inspect.252 Inspect.365;
let Inspect.362 : Str = CallByName Inspect.61 Inspect.364 Inspect.250;
let Inspect.363 : Str = "\"";
let Inspect.361 : Str = CallByName Inspect.61 Inspect.362 Inspect.363;
ret Inspect.361;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.318 : Str = CallByName Inspect.230 Inspect.150 Inspect.307;
ret Inspect.318;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.349 : Str = CallByName Inspect.251 Inspect.150 Inspect.307;
ret Inspect.349;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
procedure Inspect.225 (Inspect.226, Inspect.224):
let Inspect.348 : Str = "{";
let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.348;
let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
let Inspect.321 : {} = Struct {};
let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
let Inspect.317 : Str = "}";
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
ret Inspect.315;
procedure Inspect.42 (Inspect.229):
let Inspect.319 : List {Str, Str} = CallByName Inspect.30 Inspect.229;
ret Inspect.319;
procedure Inspect.44 (Inspect.250):
let Inspect.357 : Str = CallByName Inspect.30 Inspect.250;
ret Inspect.357;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : Str = CallByName #Derived.0 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName #Derived.2 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.327 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
procedure Inspect.227 (Inspect.228, Inspect.224):
let Inspect.347 : Int1 = CallByName Bool.1;
let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.347};
let Inspect.329 : {} = Struct {};
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
ret Inspect.327;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.229 (Inspect.330, Inspect.331):
let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
joinpoint Inspect.345 Inspect.234:
let Inspect.342 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
let Inspect.343 : Str = ": ";
let Inspect.337 : Str = CallByName Inspect.59 Inspect.342 Inspect.343;
let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
let Inspect.334 : {} = Struct {};
let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
ret Inspect.332;
in
if Inspect.231 then
let Inspect.346 : Str = ", ";
let Inspect.344 : Str = CallByName Inspect.59 Inspect.230 Inspect.346;
jump Inspect.345 Inspect.344;
else
jump Inspect.345 Inspect.230;
procedure Inspect.235 (Inspect.236, Inspect.233):
let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
ret Inspect.340;
procedure Inspect.237 (Inspect.238):
let Inspect.336 : Int1 = CallByName Bool.2;
let Inspect.335 : {Str, Int1} = Struct {Inspect.238, Inspect.336};
ret Inspect.335;
procedure Inspect.239 (Inspect.322):
let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
ret Inspect.323;
procedure Inspect.246 (Inspect.247, Inspect.245):
let Inspect.357 : Str = "\"";
let Inspect.356 : Str = CallByName Inspect.59 Inspect.247 Inspect.357;
let Inspect.354 : Str = CallByName Inspect.59 Inspect.356 Inspect.245;
let Inspect.355 : Str = "\"";
let Inspect.353 : Str = CallByName Inspect.59 Inspect.354 Inspect.355;
ret Inspect.353;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
ret Inspect.310;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.341 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
ret Inspect.341;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.41 (Inspect.224):
let Inspect.311 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
ret Inspect.311;
procedure Inspect.43 (Inspect.245):
let Inspect.349 : Str = CallByName Inspect.30 Inspect.245;
ret Inspect.349;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : Str = CallByName #Derived.0 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.319;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure List.18 (List.158, List.159, List.160):
let List.572 : U64 = 0i64;
@ -147,7 +147,7 @@ procedure List.90 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_g
if List.576 then
let List.580 : {Str, Str} = CallByName List.66 List.161 List.164;
inc List.580;
let List.166 : {Str, Int1} = CallByName Inspect.234 List.162 List.580;
let List.166 : {Str, Int1} = CallByName Inspect.229 List.162 List.580;
let List.579 : U64 = 1i64;
let List.578 : U64 = CallByName Num.51 List.164 List.579;
jump List.574 List.161 List.166 List.163 List.578 List.165;
@ -158,18 +158,18 @@ procedure List.90 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_g
jump List.574 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.298 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.3 : Str = "foo";
let Test.1 : Str = CallByName Inspect.34 Test.3;
let Test.1 : Str = CallByName Inspect.33 Test.3;
ret Test.1;

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

@ -6,15 +6,15 @@ procedure #Derived.2 (#Derived.3, #Derived.1):
let #Derived_gen.11 : Str = "a";
let #Derived_gen.13 : Str = StructAtIndex 0 #Derived.1;
inc #Derived_gen.13;
let #Derived_gen.12 : Str = CallByName Inspect.44 #Derived_gen.13;
let #Derived_gen.12 : Str = CallByName Inspect.43 #Derived_gen.13;
let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.11, #Derived_gen.12};
let #Derived_gen.8 : Str = "b";
let #Derived_gen.10 : Str = StructAtIndex 1 #Derived.1;
dec #Derived_gen.13;
let #Derived_gen.9 : Str = CallByName Inspect.44 #Derived_gen.10;
let #Derived_gen.9 : Str = CallByName Inspect.43 #Derived_gen.10;
let #Derived_gen.7 : {Str, Str} = Struct {#Derived_gen.8, #Derived_gen.9};
let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6, #Derived_gen.7];
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.42 #Derived_gen.5;
let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.5;
let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
ret #Derived_gen.3;
@ -26,113 +26,113 @@ procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Inspect.230 (Inspect.231, Inspect.229):
let Inspect.356 : Str = "{";
let Inspect.332 : Str = CallByName Inspect.61 Inspect.231 Inspect.356;
let Inspect.328 : {Str, Int1} = CallByName Inspect.232 Inspect.332 Inspect.229;
let Inspect.329 : {} = Struct {};
let Inspect.324 : Str = CallByName Inspect.244 Inspect.328;
let Inspect.325 : Str = "}";
let Inspect.323 : Str = CallByName Inspect.61 Inspect.324 Inspect.325;
ret Inspect.323;
procedure Inspect.232 (Inspect.233, Inspect.229):
let Inspect.355 : Int1 = CallByName Bool.1;
let Inspect.336 : {Str, Int1} = Struct {Inspect.233, Inspect.355};
let Inspect.337 : {} = Struct {};
let Inspect.335 : {Str, Int1} = CallByName List.18 Inspect.229 Inspect.336 Inspect.337;
ret Inspect.335;
procedure Inspect.234 (Inspect.338, Inspect.339):
let Inspect.237 : Str = StructAtIndex 0 Inspect.339;
let Inspect.238 : Str = StructAtIndex 1 Inspect.339;
let Inspect.235 : Str = StructAtIndex 0 Inspect.338;
let Inspect.236 : Int1 = StructAtIndex 1 Inspect.338;
joinpoint Inspect.353 Inspect.239:
let Inspect.350 : Str = CallByName Inspect.61 Inspect.239 Inspect.237;
let Inspect.351 : Str = ": ";
let Inspect.345 : Str = CallByName Inspect.61 Inspect.350 Inspect.351;
let Inspect.341 : Str = CallByName Inspect.240 Inspect.345 Inspect.238;
let Inspect.342 : {} = Struct {};
let Inspect.340 : {Str, Int1} = CallByName Inspect.242 Inspect.341;
ret Inspect.340;
in
if Inspect.236 then
let Inspect.354 : Str = ", ";
let Inspect.352 : Str = CallByName Inspect.61 Inspect.235 Inspect.354;
jump Inspect.353 Inspect.352;
else
jump Inspect.353 Inspect.235;
procedure Inspect.240 (Inspect.241, Inspect.238):
let Inspect.348 : Str = CallByName Inspect.31 Inspect.238 Inspect.241;
ret Inspect.348;
procedure Inspect.242 (Inspect.243):
let Inspect.344 : Int1 = CallByName Bool.2;
let Inspect.343 : {Str, Int1} = Struct {Inspect.243, Inspect.344};
ret Inspect.343;
procedure Inspect.244 (Inspect.330):
let Inspect.331 : Str = StructAtIndex 0 Inspect.330;
ret Inspect.331;
procedure Inspect.251 (Inspect.252, Inspect.250):
let Inspect.365 : Str = "\"";
let Inspect.364 : Str = CallByName Inspect.61 Inspect.252 Inspect.365;
let Inspect.362 : Str = CallByName Inspect.61 Inspect.364 Inspect.250;
let Inspect.363 : Str = "\"";
let Inspect.361 : Str = CallByName Inspect.61 Inspect.362 Inspect.363;
ret Inspect.361;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.318 : Str = CallByName Inspect.230 Inspect.150 Inspect.307;
ret Inspect.318;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.349 : Str = CallByName Inspect.251 Inspect.150 Inspect.307;
ret Inspect.349;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
procedure Inspect.225 (Inspect.226, Inspect.224):
let Inspect.348 : Str = "{";
let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.348;
let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
let Inspect.321 : {} = Struct {};
let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
let Inspect.317 : Str = "}";
let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
ret Inspect.315;
procedure Inspect.42 (Inspect.229):
let Inspect.319 : List {Str, Str} = CallByName Inspect.30 Inspect.229;
ret Inspect.319;
procedure Inspect.44 (Inspect.250):
let Inspect.366 : Str = CallByName Inspect.30 Inspect.250;
ret Inspect.366;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : {Str, Str} = CallByName #Derived.0 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName #Derived.2 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.327 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
procedure Inspect.227 (Inspect.228, Inspect.224):
let Inspect.347 : Int1 = CallByName Bool.1;
let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.347};
let Inspect.329 : {} = Struct {};
let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
ret Inspect.327;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.229 (Inspect.330, Inspect.331):
let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
joinpoint Inspect.345 Inspect.234:
let Inspect.342 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
let Inspect.343 : Str = ": ";
let Inspect.337 : Str = CallByName Inspect.59 Inspect.342 Inspect.343;
let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
let Inspect.334 : {} = Struct {};
let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
ret Inspect.332;
in
if Inspect.231 then
let Inspect.346 : Str = ", ";
let Inspect.344 : Str = CallByName Inspect.59 Inspect.230 Inspect.346;
jump Inspect.345 Inspect.344;
else
jump Inspect.345 Inspect.230;
procedure Inspect.235 (Inspect.236, Inspect.233):
let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
ret Inspect.340;
procedure Inspect.237 (Inspect.238):
let Inspect.336 : Int1 = CallByName Bool.2;
let Inspect.335 : {Str, Int1} = Struct {Inspect.238, Inspect.336};
ret Inspect.335;
procedure Inspect.239 (Inspect.322):
let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
ret Inspect.323;
procedure Inspect.246 (Inspect.247, Inspect.245):
let Inspect.357 : Str = "\"";
let Inspect.356 : Str = CallByName Inspect.59 Inspect.247 Inspect.357;
let Inspect.354 : Str = CallByName Inspect.59 Inspect.356 Inspect.245;
let Inspect.355 : Str = "\"";
let Inspect.353 : Str = CallByName Inspect.59 Inspect.354 Inspect.355;
ret Inspect.353;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
ret Inspect.310;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.341 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
ret Inspect.341;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.41 (Inspect.224):
let Inspect.311 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
ret Inspect.311;
procedure Inspect.43 (Inspect.245):
let Inspect.358 : Str = CallByName Inspect.30 Inspect.245;
ret Inspect.358;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : {Str, Str} = CallByName #Derived.0 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.319;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure List.18 (List.158, List.159, List.160):
let List.572 : U64 = 0i64;
@ -154,7 +154,7 @@ procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_g
if List.576 then
let List.580 : {Str, Str} = CallByName List.66 List.161 List.164;
inc List.580;
let List.166 : {Str, Int1} = CallByName Inspect.234 List.162 List.580;
let List.166 : {Str, Int1} = CallByName Inspect.229 List.162 List.580;
let List.579 : U64 = 1i64;
let List.578 : U64 = CallByName Num.51 List.164 List.579;
jump List.574 List.161 List.166 List.163 List.578 List.165;
@ -165,20 +165,20 @@ procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_g
jump List.574 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.298 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.3 : Str = "foo";
let Test.4 : Str = "bar";
let Test.2 : {Str, Str} = Struct {Test.3, Test.4};
let Test.1 : Str = CallByName Inspect.34 Test.2;
let Test.1 : Str = CallByName Inspect.33 Test.2;
ret Test.1;

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

@ -1,47 +1,47 @@
procedure Inspect.251 (Inspect.252, Inspect.250):
let Inspect.327 : Str = "\"";
let Inspect.326 : Str = CallByName Inspect.61 Inspect.252 Inspect.327;
let Inspect.322 : Str = CallByName Inspect.61 Inspect.326 Inspect.250;
let Inspect.323 : Str = "\"";
let Inspect.321 : Str = CallByName Inspect.61 Inspect.322 Inspect.323;
ret Inspect.321;
procedure Inspect.246 (Inspect.247, Inspect.245):
let Inspect.319 : Str = "\"";
let Inspect.318 : Str = CallByName Inspect.59 Inspect.247 Inspect.319;
let Inspect.314 : Str = CallByName Inspect.59 Inspect.318 Inspect.245;
let Inspect.315 : Str = "\"";
let Inspect.313 : Str = CallByName Inspect.59 Inspect.314 Inspect.315;
ret Inspect.313;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
ret Inspect.315;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.44 (Inspect.250):
let Inspect.317 : Str = CallByName Inspect.30 Inspect.250;
procedure Inspect.43 (Inspect.245):
let Inspect.309 : Str = CallByName Inspect.30 Inspect.245;
ret Inspect.309;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : Str = CallByName Inspect.43 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName Inspect.246 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.317 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.317;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : Str = CallByName Inspect.44 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName Inspect.251 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.325 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
ret Inspect.325;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.2 : Str = "abc";
let Test.1 : Str = CallByName Inspect.34 Test.2;
let Test.1 : Str = CallByName Inspect.33 Test.2;
ret Test.1;

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

@ -8,119 +8,119 @@ procedure #Derived.3 (#Derived.4, #Derived.1):
ret #Derived_gen.3;
in
let #Derived_gen.7 : Str = "A";
let #Derived_gen.9 : Str = CallByName Inspect.44 #Derived.1;
let #Derived_gen.9 : Str = CallByName Inspect.43 #Derived.1;
let #Derived_gen.8 : List Str = Array [#Derived_gen.9];
let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.40 #Derived_gen.7 #Derived_gen.8;
let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.39 #Derived_gen.7 #Derived_gen.8;
jump #Derived_gen.5 #Derived_gen.6;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.205 (Inspect.206, #Attr.12):
let Inspect.350 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.349 : Str = CallByName Inspect.61 Inspect.206 Inspect.350;
ret Inspect.349;
procedure Inspect.200 (Inspect.201, #Attr.12):
let Inspect.342 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.341 : Str = CallByName Inspect.59 Inspect.201 Inspect.342;
ret Inspect.341;
procedure Inspect.207 (Inspect.208, #Attr.12):
let Inspect.344 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Inspect.343 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.342 : Str = "(";
let Inspect.341 : Str = CallByName Inspect.61 Inspect.208 Inspect.342;
let Inspect.329 : Str = CallByName Inspect.61 Inspect.341 Inspect.343;
let Inspect.325 : Str = CallByName Inspect.209 Inspect.329 Inspect.344;
let Inspect.326 : Str = ")";
let Inspect.324 : Str = CallByName Inspect.61 Inspect.325 Inspect.326;
procedure Inspect.202 (Inspect.203, #Attr.12):
let Inspect.336 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Inspect.335 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.334 : Str = "(";
let Inspect.333 : Str = CallByName Inspect.59 Inspect.203 Inspect.334;
let Inspect.321 : Str = CallByName Inspect.59 Inspect.333 Inspect.335;
let Inspect.317 : Str = CallByName Inspect.204 Inspect.321 Inspect.336;
let Inspect.318 : Str = ")";
let Inspect.316 : Str = CallByName Inspect.59 Inspect.317 Inspect.318;
ret Inspect.316;
procedure Inspect.204 (Inspect.205, Inspect.199):
let Inspect.325 : {} = Struct {};
let Inspect.324 : Str = CallByName List.18 Inspect.199 Inspect.205 Inspect.325;
ret Inspect.324;
procedure Inspect.209 (Inspect.210, Inspect.204):
let Inspect.333 : {} = Struct {};
let Inspect.332 : Str = CallByName List.18 Inspect.204 Inspect.210 Inspect.333;
ret Inspect.332;
procedure Inspect.206 (Inspect.207, Inspect.208):
let Inspect.332 : Str = " ";
let Inspect.327 : Str = CallByName Inspect.59 Inspect.207 Inspect.332;
let Inspect.326 : Str = CallByName Inspect.209 Inspect.327 Inspect.208;
ret Inspect.326;
procedure Inspect.211 (Inspect.212, Inspect.213):
let Inspect.340 : Str = " ";
let Inspect.335 : Str = CallByName Inspect.61 Inspect.212 Inspect.340;
let Inspect.334 : Str = CallByName Inspect.214 Inspect.335 Inspect.213;
ret Inspect.334;
procedure Inspect.209 (Inspect.210, Inspect.208):
let Inspect.330 : Str = CallByName Inspect.31 Inspect.208 Inspect.210;
ret Inspect.330;
procedure Inspect.214 (Inspect.215, Inspect.213):
let Inspect.338 : Str = CallByName Inspect.31 Inspect.213 Inspect.215;
ret Inspect.338;
procedure Inspect.246 (Inspect.247, Inspect.245):
let Inspect.351 : Str = "\"";
let Inspect.350 : Str = CallByName Inspect.59 Inspect.247 Inspect.351;
let Inspect.348 : Str = CallByName Inspect.59 Inspect.350 Inspect.245;
let Inspect.349 : Str = "\"";
let Inspect.347 : Str = CallByName Inspect.59 Inspect.348 Inspect.349;
ret Inspect.347;
procedure Inspect.251 (Inspect.252, Inspect.250):
let Inspect.359 : Str = "\"";
let Inspect.358 : Str = CallByName Inspect.61 Inspect.252 Inspect.359;
let Inspect.356 : Str = CallByName Inspect.61 Inspect.358 Inspect.250;
let Inspect.357 : Str = "\"";
let Inspect.355 : Str = CallByName Inspect.61 Inspect.356 Inspect.357;
ret Inspect.355;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.319 : U8 = GetTagId Inspect.307;
switch Inspect.319:
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.311 : U8 = GetTagId Inspect.299;
switch Inspect.311:
case 0:
let Inspect.318 : Str = CallByName Inspect.205 Inspect.150 Inspect.307;
ret Inspect.318;
let Inspect.310 : Str = CallByName Inspect.200 Inspect.145 Inspect.299;
ret Inspect.310;
default:
let Inspect.318 : Str = CallByName Inspect.207 Inspect.150 Inspect.307;
ret Inspect.318;
let Inspect.310 : Str = CallByName Inspect.202 Inspect.145 Inspect.299;
ret Inspect.310;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.339 : Str = CallByName Inspect.251 Inspect.150 Inspect.307;
ret Inspect.339;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.331 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
ret Inspect.331;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
ret Inspect.315;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.40 (Inspect.203, Inspect.204):
inc Inspect.204;
let Inspect.345 : Int1 = CallByName List.1 Inspect.204;
if Inspect.345 then
dec Inspect.204;
let Inspect.347 : [C Str, C Str List Str] = TagId(0) Inspect.203;
let Inspect.346 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.347;
ret Inspect.346;
procedure Inspect.39 (Inspect.198, Inspect.199):
inc Inspect.199;
let Inspect.337 : Int1 = CallByName List.1 Inspect.199;
if Inspect.337 then
dec Inspect.199;
let Inspect.339 : [C Str, C Str List Str] = TagId(0) Inspect.198;
let Inspect.338 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.339;
ret Inspect.338;
else
let Inspect.321 : [C Str, C Str List Str] = TagId(1) Inspect.203 Inspect.204;
let Inspect.320 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.321;
ret Inspect.320;
let Inspect.313 : [C Str, C Str List Str] = TagId(1) Inspect.198 Inspect.199;
let Inspect.312 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.313;
ret Inspect.312;
procedure Inspect.44 (Inspect.250):
let Inspect.351 : Str = CallByName Inspect.30 Inspect.250;
ret Inspect.351;
procedure Inspect.43 (Inspect.245):
let Inspect.343 : Str = CallByName Inspect.30 Inspect.245;
ret Inspect.343;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : Str = CallByName #Derived.0 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName #Derived.3 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : Str = CallByName #Derived.0 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName #Derived.3 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.328 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
ret Inspect.328;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.320 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.320;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure List.1 (List.105):
let List.584 : U64 = CallByName List.6 List.105;
@ -143,13 +143,13 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.581 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.581;
procedure List.90 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
procedure List.90 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
joinpoint List.574 List.161 List.162 List.163 List.164 List.165:
let List.576 : Int1 = CallByName Num.22 List.164 List.165;
if List.576 then
let List.580 : Str = CallByName List.66 List.161 List.164;
inc List.580;
let List.166 : Str = CallByName Inspect.211 List.162 List.580;
let List.166 : Str = CallByName Inspect.206 List.162 List.580;
let List.579 : U64 = 1i64;
let List.578 : U64 = CallByName Num.51 List.164 List.579;
jump List.574 List.161 List.166 List.163 List.578 List.165;
@ -157,21 +157,21 @@ procedure List.90 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_g
dec List.161;
ret List.162;
in
jump List.574 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
jump List.574 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.298 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.4 : Str = "foo";
let Test.3 : Str = CallByName Inspect.34 Test.4;
let Test.3 : Str = CallByName Inspect.33 Test.4;
ret Test.3;

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

@ -10,120 +10,120 @@ procedure #Derived.4 (#Derived.5, #Derived.1):
let #Derived.2 : Str = StructAtIndex 0 #Derived.1;
let #Derived.3 : Str = StructAtIndex 1 #Derived.1;
let #Derived_gen.7 : Str = "A";
let #Derived_gen.9 : Str = CallByName Inspect.44 #Derived.2;
let #Derived_gen.10 : Str = CallByName Inspect.44 #Derived.3;
let #Derived_gen.9 : Str = CallByName Inspect.43 #Derived.2;
let #Derived_gen.10 : Str = CallByName Inspect.43 #Derived.3;
let #Derived_gen.8 : List Str = Array [#Derived_gen.9, #Derived_gen.10];
let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.40 #Derived_gen.7 #Derived_gen.8;
let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.39 #Derived_gen.7 #Derived_gen.8;
jump #Derived_gen.5 #Derived_gen.6;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.205 (Inspect.206, #Attr.12):
let Inspect.350 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.349 : Str = CallByName Inspect.61 Inspect.206 Inspect.350;
ret Inspect.349;
procedure Inspect.200 (Inspect.201, #Attr.12):
let Inspect.342 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.341 : Str = CallByName Inspect.59 Inspect.201 Inspect.342;
ret Inspect.341;
procedure Inspect.207 (Inspect.208, #Attr.12):
let Inspect.344 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Inspect.343 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.342 : Str = "(";
let Inspect.341 : Str = CallByName Inspect.61 Inspect.208 Inspect.342;
let Inspect.329 : Str = CallByName Inspect.61 Inspect.341 Inspect.343;
let Inspect.325 : Str = CallByName Inspect.209 Inspect.329 Inspect.344;
let Inspect.326 : Str = ")";
let Inspect.324 : Str = CallByName Inspect.61 Inspect.325 Inspect.326;
procedure Inspect.202 (Inspect.203, #Attr.12):
let Inspect.336 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Inspect.335 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.334 : Str = "(";
let Inspect.333 : Str = CallByName Inspect.59 Inspect.203 Inspect.334;
let Inspect.321 : Str = CallByName Inspect.59 Inspect.333 Inspect.335;
let Inspect.317 : Str = CallByName Inspect.204 Inspect.321 Inspect.336;
let Inspect.318 : Str = ")";
let Inspect.316 : Str = CallByName Inspect.59 Inspect.317 Inspect.318;
ret Inspect.316;
procedure Inspect.204 (Inspect.205, Inspect.199):
let Inspect.325 : {} = Struct {};
let Inspect.324 : Str = CallByName List.18 Inspect.199 Inspect.205 Inspect.325;
ret Inspect.324;
procedure Inspect.209 (Inspect.210, Inspect.204):
let Inspect.333 : {} = Struct {};
let Inspect.332 : Str = CallByName List.18 Inspect.204 Inspect.210 Inspect.333;
ret Inspect.332;
procedure Inspect.206 (Inspect.207, Inspect.208):
let Inspect.332 : Str = " ";
let Inspect.327 : Str = CallByName Inspect.59 Inspect.207 Inspect.332;
let Inspect.326 : Str = CallByName Inspect.209 Inspect.327 Inspect.208;
ret Inspect.326;
procedure Inspect.211 (Inspect.212, Inspect.213):
let Inspect.340 : Str = " ";
let Inspect.335 : Str = CallByName Inspect.61 Inspect.212 Inspect.340;
let Inspect.334 : Str = CallByName Inspect.214 Inspect.335 Inspect.213;
ret Inspect.334;
procedure Inspect.209 (Inspect.210, Inspect.208):
let Inspect.330 : Str = CallByName Inspect.31 Inspect.208 Inspect.210;
ret Inspect.330;
procedure Inspect.214 (Inspect.215, Inspect.213):
let Inspect.338 : Str = CallByName Inspect.31 Inspect.213 Inspect.215;
ret Inspect.338;
procedure Inspect.246 (Inspect.247, Inspect.245):
let Inspect.351 : Str = "\"";
let Inspect.350 : Str = CallByName Inspect.59 Inspect.247 Inspect.351;
let Inspect.348 : Str = CallByName Inspect.59 Inspect.350 Inspect.245;
let Inspect.349 : Str = "\"";
let Inspect.347 : Str = CallByName Inspect.59 Inspect.348 Inspect.349;
ret Inspect.347;
procedure Inspect.251 (Inspect.252, Inspect.250):
let Inspect.359 : Str = "\"";
let Inspect.358 : Str = CallByName Inspect.61 Inspect.252 Inspect.359;
let Inspect.356 : Str = CallByName Inspect.61 Inspect.358 Inspect.250;
let Inspect.357 : Str = "\"";
let Inspect.355 : Str = CallByName Inspect.61 Inspect.356 Inspect.357;
ret Inspect.355;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.319 : U8 = GetTagId Inspect.307;
switch Inspect.319:
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.311 : U8 = GetTagId Inspect.299;
switch Inspect.311:
case 0:
let Inspect.318 : Str = CallByName Inspect.205 Inspect.150 Inspect.307;
ret Inspect.318;
let Inspect.310 : Str = CallByName Inspect.200 Inspect.145 Inspect.299;
ret Inspect.310;
default:
let Inspect.318 : Str = CallByName Inspect.207 Inspect.150 Inspect.307;
ret Inspect.318;
let Inspect.310 : Str = CallByName Inspect.202 Inspect.145 Inspect.299;
ret Inspect.310;
procedure Inspect.31 (Inspect.307, Inspect.150):
let Inspect.339 : Str = CallByName Inspect.251 Inspect.150 Inspect.307;
ret Inspect.339;
procedure Inspect.31 (Inspect.299, Inspect.145):
let Inspect.331 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
ret Inspect.331;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
ret Inspect.315;
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.40 (Inspect.203, Inspect.204):
inc Inspect.204;
let Inspect.345 : Int1 = CallByName List.1 Inspect.204;
if Inspect.345 then
dec Inspect.204;
let Inspect.347 : [C Str, C Str List Str] = TagId(0) Inspect.203;
let Inspect.346 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.347;
ret Inspect.346;
procedure Inspect.39 (Inspect.198, Inspect.199):
inc Inspect.199;
let Inspect.337 : Int1 = CallByName List.1 Inspect.199;
if Inspect.337 then
dec Inspect.199;
let Inspect.339 : [C Str, C Str List Str] = TagId(0) Inspect.198;
let Inspect.338 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.339;
ret Inspect.338;
else
let Inspect.321 : [C Str, C Str List Str] = TagId(1) Inspect.203 Inspect.204;
let Inspect.320 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.321;
ret Inspect.320;
let Inspect.313 : [C Str, C Str List Str] = TagId(1) Inspect.198 Inspect.199;
let Inspect.312 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.313;
ret Inspect.312;
procedure Inspect.44 (Inspect.250):
let Inspect.360 : Str = CallByName Inspect.30 Inspect.250;
ret Inspect.360;
procedure Inspect.43 (Inspect.245):
let Inspect.352 : Str = CallByName Inspect.30 Inspect.245;
ret Inspect.352;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : {Str, Str} = CallByName #Derived.0 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName #Derived.4 Inspect.312 Inspect.316;
ret Inspect.311;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : {Str, Str} = CallByName #Derived.0 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName #Derived.4 Inspect.304 Inspect.308;
ret Inspect.303;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.328 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
ret Inspect.328;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.320 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.320;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure List.1 (List.105):
let List.584 : U64 = CallByName List.6 List.105;
@ -152,7 +152,7 @@ procedure List.90 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_g
if List.576 then
let List.580 : Str = CallByName List.66 List.161 List.164;
inc List.580;
let List.166 : Str = CallByName Inspect.211 List.162 List.580;
let List.166 : Str = CallByName Inspect.206 List.162 List.580;
let List.579 : U64 = 1i64;
let List.578 : U64 = CallByName Num.51 List.164 List.579;
jump List.574 List.161 List.166 List.163 List.578 List.165;
@ -163,20 +163,20 @@ procedure List.90 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_g
jump List.574 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.298 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.5 : Str = "foo";
let Test.4 : Str = "foo";
let Test.1 : {Str, Str} = Struct {Test.4, Test.5};
let Test.3 : Str = CallByName Inspect.34 Test.1;
let Test.3 : Str = CallByName Inspect.33 Test.1;
ret Test.3;

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

@ -3,8 +3,8 @@ procedure List.6 (#Attr.2):
ret List.571;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.299 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.259;
procedure Test.0 ():
let Test.1 : List I64 = Array [1i64, 2i64];

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.2 : I64 = 1i64;

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

@ -1,6 +1,6 @@
procedure Num.45 (#Attr.2):
let Num.297 : I64 = lowlevel NumRound #Attr.2;
ret Num.297;
let Num.257 : I64 = lowlevel NumRound #Attr.2;
ret Num.257;
procedure Test.0 ():
let Test.2 : Decimal = 3.6dec;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.1 : I64 = 3i64;

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

@ -1,22 +1,22 @@
procedure Num.30 (#Attr.2):
let Num.304 : I64 = 0i64;
let Num.303 : Int1 = lowlevel Eq #Attr.2 Num.304;
ret Num.303;
let Num.264 : I64 = 0i64;
let Num.263 : Int1 = lowlevel Eq #Attr.2 Num.264;
ret Num.263;
procedure Num.39 (#Attr.2, #Attr.3):
let Num.299 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
ret Num.259;
procedure Num.40 (Num.267, Num.268):
let Num.300 : Int1 = CallByName Num.30 Num.268;
if Num.300 then
let Num.302 : {} = Struct {};
let Num.301 : [C {}, C I64] = TagId(0) Num.302;
ret Num.301;
procedure Num.40 (Num.227, Num.228):
let Num.260 : Int1 = CallByName Num.30 Num.228;
if Num.260 then
let Num.262 : {} = Struct {};
let Num.261 : [C {}, C I64] = TagId(0) Num.262;
ret Num.261;
else
let Num.298 : I64 = CallByName Num.39 Num.267 Num.268;
let Num.297 : [C {}, C I64] = TagId(1) Num.298;
ret Num.297;
let Num.258 : I64 = CallByName Num.39 Num.227 Num.228;
let Num.257 : [C {}, C I64] = TagId(1) Num.258;
ret Num.257;
procedure Test.0 ():
let Test.8 : I64 = 1000i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.10 : I64 = 41i64;

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

@ -44,31 +44,31 @@ procedure List.9 (List.333):
ret List.573;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Str.27 (Str.87):
let Str.250 : [C Int1, C I64] = CallByName Str.61 Str.87;
ret Str.250;
procedure Str.27 (Str.86):
let Str.249 : [C Int1, C I64] = CallByName Str.60 Str.86;
ret Str.249;
procedure Str.42 (#Attr.2):
let Str.258 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.258;
let Str.257 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.257;
procedure Str.61 (Str.194):
let Str.195 : {I64, U8} = CallByName Str.42 Str.194;
dec Str.194;
let Str.256 : U8 = StructAtIndex 1 Str.195;
let Str.257 : U8 = 0i64;
let Str.253 : Int1 = CallByName Bool.11 Str.256 Str.257;
if Str.253 then
let Str.255 : I64 = StructAtIndex 0 Str.195;
let Str.254 : [C Int1, C I64] = TagId(1) Str.255;
ret Str.254;
procedure Str.60 (Str.193):
let Str.194 : {I64, U8} = CallByName Str.42 Str.193;
dec Str.193;
let Str.255 : U8 = StructAtIndex 1 Str.194;
let Str.256 : U8 = 0i64;
let Str.252 : Int1 = CallByName Bool.11 Str.255 Str.256;
if Str.252 then
let Str.254 : I64 = StructAtIndex 0 Str.194;
let Str.253 : [C Int1, C I64] = TagId(1) Str.254;
ret Str.253;
else
let Str.252 : Int1 = false;
let Str.251 : [C Int1, C I64] = TagId(0) Str.252;
ret Str.251;
let Str.251 : Int1 = false;
let Str.250 : [C Int1, C I64] = TagId(0) Str.251;
ret Str.250;
procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2;

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

@ -178,72 +178,67 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
in
jump List.636 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
procedure Num.133 (#Attr.2):
let Num.336 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.336;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.260 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.260;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.300 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.300;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.309 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.309;
let Num.269 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.269;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.312 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.312;
let Num.272 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.272;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.334 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.334;
let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.294;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.318 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.318;
let Num.278 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.278;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.324 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.324;
let Num.284 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.284;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.335 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.335;
let Num.295 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.295;
procedure Num.71 (#Attr.2, #Attr.3):
let Num.297 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
ret Num.257;
procedure Num.72 (#Attr.2, #Attr.3):
let Num.298 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
ret Num.258;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.331 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.331;
let Num.291 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
let Str.258 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.258;
procedure Str.9 (Str.68):
let Str.257 : U64 = 0i64;
let Str.260 : U64 = CallByName List.6 Str.68;
let Str.258 : U64 = CallByName Num.133 Str.260;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.257 Str.258;
let Str.254 : Int1 = StructAtIndex 2 Str.69;
if Str.254 then
let Str.256 : Str = StructAtIndex 1 Str.69;
let Str.255 : [C {U64, U8}, C Str] = TagId(1) Str.256;
ret Str.255;
procedure Str.9 (Str.67):
let Str.256 : U64 = 0i64;
let Str.257 : U64 = CallByName List.6 Str.67;
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67 Str.256 Str.257;
let Str.253 : Int1 = StructAtIndex 2 Str.68;
if Str.253 then
let Str.255 : Str = StructAtIndex 1 Str.68;
let Str.254 : [C {U64, U8}, C Str] = TagId(1) Str.255;
ret Str.254;
else
let Str.252 : U8 = StructAtIndex 3 Str.69;
let Str.253 : U64 = StructAtIndex 0 Str.69;
let #Derived_gen.6 : Str = StructAtIndex 1 Str.69;
let Str.251 : U8 = StructAtIndex 3 Str.68;
let Str.252 : U64 = StructAtIndex 0 Str.68;
let #Derived_gen.6 : Str = StructAtIndex 1 Str.68;
dec #Derived_gen.6;
let Str.251 : {U64, U8} = Struct {Str.253, Str.252};
let Str.250 : [C {U64, U8}, C Str] = TagId(0) Str.251;
ret Str.250;
let Str.250 : {U64, U8} = Struct {Str.252, Str.251};
let Str.249 : [C {U64, U8}, C Str] = TagId(0) Str.250;
ret Str.249;
procedure Test.3 ():
let Test.0 : List U8 = Array [82i64, 111i64, 99i64];

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

@ -82,16 +82,16 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
jump List.587 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.300 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.300;
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.260;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.299 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.259;
procedure Test.1 (#Derived_gen.0):
joinpoint Test.26 Test.6:

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

@ -152,99 +152,94 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
in
jump List.632 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
procedure Num.133 (#Attr.2):
let Num.336 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.336;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.260 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.260;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.300 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.300;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.309 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.309;
let Num.269 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.269;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.312 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.312;
let Num.272 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.272;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.334 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.334;
let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.294;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.318 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.318;
let Num.278 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.278;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.324 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.324;
let Num.284 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.284;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.335 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.335;
let Num.295 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.295;
procedure Num.71 (#Attr.2, #Attr.3):
let Num.297 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
ret Num.257;
procedure Num.72 (#Attr.2, #Attr.3):
let Num.298 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
ret Num.258;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.331 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.331;
let Num.291 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Str.12 (#Attr.2):
let Str.259 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.259;
procedure Str.27 (Str.87):
let Str.250 : [C {}, C I64] = CallByName Str.61 Str.87;
ret Str.250;
procedure Str.42 (#Attr.2):
let Str.258 : {I64, U8} = lowlevel StrToNum #Attr.2;
let Str.258 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.258;
procedure Str.27 (Str.86):
let Str.249 : [C {}, C I64] = CallByName Str.60 Str.86;
ret Str.249;
procedure Str.42 (#Attr.2):
let Str.257 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.257;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.269 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.269;
let Str.268 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.268;
procedure Str.61 (Str.194):
let Str.195 : {I64, U8} = CallByName Str.42 Str.194;
dec Str.194;
let Str.256 : U8 = StructAtIndex 1 Str.195;
let Str.257 : U8 = 0i64;
let Str.253 : Int1 = CallByName Bool.11 Str.256 Str.257;
if Str.253 then
let Str.255 : I64 = StructAtIndex 0 Str.195;
let Str.254 : [C {}, C I64] = TagId(1) Str.255;
ret Str.254;
procedure Str.60 (Str.193):
let Str.194 : {I64, U8} = CallByName Str.42 Str.193;
dec Str.193;
let Str.255 : U8 = StructAtIndex 1 Str.194;
let Str.256 : U8 = 0i64;
let Str.252 : Int1 = CallByName Bool.11 Str.255 Str.256;
if Str.252 then
let Str.254 : I64 = StructAtIndex 0 Str.194;
let Str.253 : [C {}, C I64] = TagId(1) Str.254;
ret Str.253;
else
let Str.252 : {} = Struct {};
let Str.251 : [C {}, C I64] = TagId(0) Str.252;
ret Str.251;
let Str.251 : {} = Struct {};
let Str.250 : [C {}, C I64] = TagId(0) Str.251;
ret Str.250;
procedure Str.9 (Str.68):
let Str.267 : U64 = 0i64;
let Str.270 : U64 = CallByName List.6 Str.68;
let Str.268 : U64 = CallByName Num.133 Str.270;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.267 Str.268;
let Str.264 : Int1 = StructAtIndex 2 Str.69;
if Str.264 then
let Str.266 : Str = StructAtIndex 1 Str.69;
let Str.265 : [C {U64, U8}, C Str] = TagId(1) Str.266;
ret Str.265;
procedure Str.9 (Str.67):
let Str.266 : U64 = 0i64;
let Str.267 : U64 = CallByName List.6 Str.67;
let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67 Str.266 Str.267;
let Str.263 : Int1 = StructAtIndex 2 Str.68;
if Str.263 then
let Str.265 : Str = StructAtIndex 1 Str.68;
let Str.264 : [C {U64, U8}, C Str] = TagId(1) Str.265;
ret Str.264;
else
let Str.262 : U8 = StructAtIndex 3 Str.69;
let Str.263 : U64 = StructAtIndex 0 Str.69;
let #Derived_gen.7 : Str = StructAtIndex 1 Str.69;
let Str.261 : U8 = StructAtIndex 3 Str.68;
let Str.262 : U64 = StructAtIndex 0 Str.68;
let #Derived_gen.7 : Str = StructAtIndex 1 Str.68;
dec #Derived_gen.7;
let Str.261 : {U64, U8} = Struct {Str.263, Str.262};
let Str.260 : [C {U64, U8}, C Str] = TagId(0) Str.261;
ret Str.260;
let Str.260 : {U64, U8} = Struct {Str.262, Str.261};
let Str.259 : [C {U64, U8}, C Str] = TagId(0) Str.260;
ret Str.259;
procedure Test.0 ():
let Test.37 : Str = "-1234";

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

@ -1,6 +1,6 @@
procedure Num.20 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
joinpoint Test.12 Test.2 Test.3:

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

@ -1,10 +1,10 @@
procedure Num.96 (#Attr.2):
let Num.297 : Str = lowlevel NumToStr #Attr.2;
ret Num.297;
let Num.257 : Str = lowlevel NumToStr #Attr.2;
ret Num.257;
procedure Num.96 (#Attr.2):
let Num.298 : Str = lowlevel NumToStr #Attr.2;
ret Num.298;
let Num.258 : Str = lowlevel NumToStr #Attr.2;
ret Num.258;
procedure Test.1 (Test.4):
let Test.13 : [C U8, C U64] = TagId(1) Test.4;

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

@ -7,12 +7,12 @@ procedure Bool.2 ():
ret Bool.24;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.298 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.258;
procedure Test.0 (Test.8):
let Test.20 : Int1 = CallByName Bool.2;

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

@ -29,12 +29,12 @@ procedure List.90 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
jump List.574 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.298 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.257;
procedure Test.7 (Test.11, Test.12):
let Test.17 : {[<rnu>C *self, <null>], [<rnu><null>, C {[<rnu>C *self, <null>], *self}]} = Struct {Test.12, Test.11};

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

@ -1,11 +1,11 @@
procedure Num.31 (Num.239):
let Num.298 : I64 = 2i64;
let Num.297 : Int1 = CallByName Num.86 Num.239 Num.298;
ret Num.297;
procedure Num.31 (Num.199):
let Num.258 : I64 = 2i64;
let Num.257 : Int1 = CallByName Num.86 Num.199 Num.258;
ret Num.257;
procedure Num.86 (#Attr.2, #Attr.3):
let Num.299 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
ret Num.259;
procedure Test.2 (#Derived_gen.0, #Derived_gen.1):
let #Derived_gen.3 : [<rnu><null>, C I64 *self] = NullPointer;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.10 (Test.11):
let Test.28 : I64 = 1i64;

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

@ -22,12 +22,12 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
ret List.578;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.298 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
procedure Test.1 ():
let Test.8 : List I64 = Array [1i64, 2i64, 3i64];

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

@ -21,8 +21,8 @@ procedure List.66 (#Attr.2, #Attr.3):
ret List.576;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.2):
let Test.6 : List I64 = Array [1i64, 2i64, 3i64];

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

@ -7,8 +7,8 @@ procedure List.6 (#Attr.2):
ret List.572;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.1 : List I64 = Array [1i64, 2i64, 3i64];

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

@ -27,16 +27,16 @@ procedure List.66 (#Attr.2, #Attr.3):
ret List.576;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.249;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.251;
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -27,12 +27,12 @@ procedure List.66 (#Attr.2, #Attr.3):
ret List.576;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.251;
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -21,8 +21,8 @@ procedure List.5 (#Attr.2, #Attr.3):
procedure Num.19 (#Attr.2, #Attr.3):
let Num.299 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.259;
procedure Test.4 (Test.5, #Attr.12):
let Test.16 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;

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

@ -22,8 +22,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
ret List.576;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Test.2 (Test.3):
let Test.6 : U64 = 0i64;

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

@ -8,8 +8,8 @@ procedure List.59 (List.328):
ret List.571;
procedure Num.46 (#Attr.2, #Attr.3):
let Num.297 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.2 : List I64 = Array [4i64, 3i64, 2i64, 1i64];

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.298 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Test.0 ():
let Test.7 : I64 = 1i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.17 : {} = Struct {};

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.19 : I64 = 41i64;

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

@ -1,6 +1,6 @@
procedure Num.37 (#Attr.2, #Attr.3):
let Num.297 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.2 : Decimal = 1dec;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.5 : {} = Struct {};

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

@ -1,6 +1,6 @@
procedure Num.21 (#Attr.2, #Attr.3):
let Num.299 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.259;
procedure Test.1 (Test.6):
let Test.21 : Int1 = false;

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

@ -3,8 +3,8 @@ procedure Bool.11 (#Attr.2, #Attr.3):
ret Bool.23;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.251;
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
procedure Test.2 (Test.7):
let Test.24 : Str = ".trace(\"";

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

@ -1,14 +1,14 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.298 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.258;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.299 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.259;
procedure Test.1 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
joinpoint Test.12 Test.2 Test.3 Test.4:

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

@ -40,8 +40,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
ret List.576;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.299 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.259;
procedure Test.1 (Test.2):
let Test.28 : U64 = 0i64;

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

@ -1,10 +1,10 @@
procedure Num.22 (#Attr.2, #Attr.3):
let Num.300 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.300;
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.260;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.298 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.258;
procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
let #Derived_gen.4 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.4):
let Test.2 : I64 = StructAtIndex 0 Test.4;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.4):
let Test.2 : I64 = 10i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.2):
let Test.3 : I64 = StructAtIndex 0 Test.2;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.2):
let Test.3 : I64 = 10i64;

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

@ -22,8 +22,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
ret List.576;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.2):
let Test.6 : List U64 = StructAtIndex 0 Test.2;

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

@ -3,8 +3,8 @@ procedure Bool.2 ():
ret Bool.23;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.2):
let Test.8 : U32 = 0i64;

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

@ -3,12 +3,12 @@ procedure Bool.11 (#Attr.2, #Attr.3):
ret Bool.23;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.298 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.258;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.297 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (#Derived_gen.2, #Derived_gen.3):
joinpoint Test.11 Test.2 Test.3:

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

@ -1,10 +1,10 @@
procedure Num.20 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.252 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.252;
let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.251;
procedure Test.11 (Test.29, #Attr.12):
let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;

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

@ -40,8 +40,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
ret List.576;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.299 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.259;
procedure Test.1 (Test.2, Test.3, Test.4):
inc 2 Test.4;

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

@ -1,10 +1,10 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.298 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.299 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.259;
procedure Test.2 (Test.9, Test.10):
let Test.38 : U8 = 1i64;

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

@ -3,12 +3,12 @@ procedure Bool.2 ():
ret Bool.24;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.298 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.2, Test.3):
let Test.15 : U8 = GetTagId Test.2;

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

@ -3,12 +3,12 @@ procedure Bool.2 ():
ret Bool.23;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.298 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.257;
procedure Test.6 (Test.8, #Attr.12):
let Test.20 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;

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

@ -1,10 +1,10 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.298 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.258;
procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
joinpoint Test.7 Test.2 Test.3:

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

@ -184,44 +184,44 @@ procedure List.90 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_g
jump List.612 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
procedure Num.127 (#Attr.2):
let Num.304 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.304;
let Num.264 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.264;
procedure Num.137 (#Attr.2, #Attr.3):
let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.269;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.308 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.308;
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.268;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.305 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.305;
let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.265;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.310 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.310;
let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.270;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.316 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.316;
let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.276;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.318 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.318;
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.278;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.313 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.313;
let Num.273 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.273;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.317 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.317;
procedure Num.94 (#Attr.2, #Attr.3):
let Num.309 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.309;
let Num.277 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.277;
procedure Str.12 (#Attr.2):
let Str.251 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.251;
let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.250;
procedure Test.2 (Test.10):
let Test.15 : {Str, Str} = CallByName Encode.23 Test.10;
@ -421,7 +421,7 @@ procedure TotallyNotJson.26 (TotallyNotJson.152):
let TotallyNotJson.1062 : U64 = 120i64;
let TotallyNotJson.1059 : U64 = CallByName Num.21 TotallyNotJson.1061 TotallyNotJson.1062;
let TotallyNotJson.1060 : U64 = 100i64;
let TotallyNotJson.1058 : U64 = CallByName Num.94 TotallyNotJson.1059 TotallyNotJson.1060;
let TotallyNotJson.1058 : U64 = CallByName Num.137 TotallyNotJson.1059 TotallyNotJson.1060;
let TotallyNotJson.1055 : List U8 = CallByName List.68 TotallyNotJson.1058;
let TotallyNotJson.1057 : U8 = 34i64;
let TotallyNotJson.1056 : List U8 = Array [TotallyNotJson.1057];

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

@ -158,28 +158,28 @@ procedure List.90 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_g
jump List.600 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
procedure Num.127 (#Attr.2):
let Num.316 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.316;
let Num.276 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.276;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.317 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.317;
let Num.277 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.277;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.320 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.320;
let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.280;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.318 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.318;
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.278;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.319 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.319;
let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.279;
procedure Str.12 (#Attr.2):
let Str.251 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.251;
let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.250;
procedure Test.2 (Test.11):
let Test.18 : {{}, {}} = CallByName Encode.23 Test.11;

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

@ -78,16 +78,16 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
jump List.591 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.300 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.300;
let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.260;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.299 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.299;
let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.259;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.298 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.298;
let Num.258 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.258;
procedure Test.3 (Test.4, Test.12):
let Test.13 : [C U64, C U64] = TagId(0) Test.4;

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

@ -3,8 +3,8 @@ procedure Bool.2 ():
ret Bool.25;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.2):
joinpoint Test.12:

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.19 : I64 = 41i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.5 : I64 = 2i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.297 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.297;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.15 : I64 = 3i64;

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

@ -8,50 +8,50 @@ main =
1
# -emit:mono
procedure Inspect.253 (Inspect.254):
let Inspect.321 : Str = "<opaque>";
let Inspect.320 : Str = CallByName Inspect.61 Inspect.254 Inspect.321;
ret Inspect.320;
procedure Inspect.248 (Inspect.249):
let Inspect.313 : Str = "<opaque>";
let Inspect.312 : Str = CallByName Inspect.59 Inspect.249 Inspect.313;
ret Inspect.312;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.44 (Inspect.295):
let Inspect.310 : {} = Struct {};
let Inspect.309 : {} = CallByName Inspect.30 Inspect.310;
ret Inspect.309;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : {} = CallByName Inspect.44 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName Inspect.248 Inspect.304;
ret Inspect.303;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.315 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.315;
procedure Inspect.45 (Inspect.303):
let Inspect.318 : {} = Struct {};
let Inspect.317 : {} = CallByName Inspect.30 Inspect.318;
ret Inspect.317;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : {} = CallByName Inspect.45 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName Inspect.253 Inspect.312;
ret Inspect.311;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.323 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
ret Inspect.323;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.4 : {} = Struct {};
let Test.2 : Str = CallByName Inspect.34 Test.4;
let Test.2 : Str = CallByName Inspect.33 Test.4;
dbg Test.2;
dec Test.2;
let Test.3 : I64 = 1i64;

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

@ -11,49 +11,49 @@ main =
late (@Op {})
# -emit:mono
procedure Inspect.253 (Inspect.254):
let Inspect.321 : Str = "<opaque>";
let Inspect.320 : Str = CallByName Inspect.61 Inspect.254 Inspect.321;
ret Inspect.320;
procedure Inspect.248 (Inspect.249):
let Inspect.313 : Str = "<opaque>";
let Inspect.312 : Str = CallByName Inspect.59 Inspect.249 Inspect.313;
ret Inspect.312;
procedure Inspect.30 (Inspect.148):
ret Inspect.148;
procedure Inspect.30 (Inspect.143):
ret Inspect.143;
procedure Inspect.34 (Inspect.153):
let Inspect.309 : Str = CallByName Inspect.5 Inspect.153;
let Inspect.308 : Str = CallByName Inspect.62 Inspect.309;
ret Inspect.308;
procedure Inspect.33 (Inspect.148):
let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
ret Inspect.300;
procedure Inspect.36 (Inspect.305):
let Inspect.315 : Str = "";
procedure Inspect.35 (Inspect.297):
let Inspect.307 : Str = "";
ret Inspect.307;
procedure Inspect.44 (Inspect.295):
let Inspect.310 : {} = Struct {};
let Inspect.309 : {} = CallByName Inspect.30 Inspect.310;
ret Inspect.309;
procedure Inspect.5 (Inspect.146):
let Inspect.308 : {} = CallByName Inspect.44 Inspect.146;
let Inspect.305 : {} = Struct {};
let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
let Inspect.303 : Str = CallByName Inspect.248 Inspect.304;
ret Inspect.303;
procedure Inspect.59 (Inspect.296, Inspect.292):
let Inspect.315 : Str = CallByName Str.3 Inspect.296 Inspect.292;
dec Inspect.292;
ret Inspect.315;
procedure Inspect.45 (Inspect.303):
let Inspect.318 : {} = Struct {};
let Inspect.317 : {} = CallByName Inspect.30 Inspect.318;
ret Inspect.317;
procedure Inspect.5 (Inspect.151):
let Inspect.316 : {} = CallByName Inspect.45 Inspect.151;
let Inspect.313 : {} = Struct {};
let Inspect.312 : Str = CallByName Inspect.36 Inspect.313;
let Inspect.311 : Str = CallByName Inspect.253 Inspect.312;
ret Inspect.311;
procedure Inspect.61 (Inspect.304, Inspect.300):
let Inspect.323 : Str = CallByName Str.3 Inspect.304 Inspect.300;
dec Inspect.300;
ret Inspect.323;
procedure Inspect.62 (Inspect.306):
ret Inspect.306;
procedure Inspect.60 (Inspect.298):
ret Inspect.298;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.250;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.2 (Test.3):
let Test.4 : Str = CallByName Inspect.34 Test.3;
let Test.4 : Str = CallByName Inspect.33 Test.3;
dbg Test.4;
dec Test.4;
let Test.7 : I64 = 1i64;

14
crates/compiler/uitest/tests/recursion/generalization_among_large_recursive_group.txt
View file

@ -3,22 +3,22 @@
app "test" provides [main] to "./platform"
f = \{} ->
#^{-1} <2937><117>{} -<120>[[f(1)]]-> <116>[Ok <2945>{}]<80>*
#^{-1} <2897><113>{} -<116>[[f(1)]]-> <112>[Ok <2905>{}]<76>*
when g {} is
# ^ <2927><2945>{} -<2935>[[g(2)]]-> <72>[Ok <2945>{}]<102>*
# ^ <2887><2905>{} -<2895>[[g(2)]]-> <68>[Ok <2905>{}]<98>*
_ -> Ok {}
g = \{} ->
#^{-1} <2927><2945>{} -<2935>[[g(2)]]-> <72>[Ok <2945>{}]<102>*
#^{-1} <2887><2905>{} -<2895>[[g(2)]]-> <68>[Ok <2905>{}]<98>*
when h {} is
# ^ <2932><2945>{} -<2940>[[h(3)]]-> <94>[Ok <2945>{}]<124>*
# ^ <2892><2905>{} -<2900>[[h(3)]]-> <90>[Ok <2905>{}]<120>*
_ -> Ok {}
h = \{} ->
#^{-1} <2932><2945>{} -<2940>[[h(3)]]-> <94>[Ok <2945>{}]<124>*
#^{-1} <2892><2905>{} -<2900>[[h(3)]]-> <90>[Ok <2905>{}]<120>*
when f {} is
# ^ <2937><117>{} -<120>[[f(1)]]-> <116>[Ok <2945>{}]<80>*
# ^ <2897><113>{} -<116>[[f(1)]]-> <112>[Ok <2905>{}]<76>*
_ -> Ok {}
main = f {}
# ^ <2947><133>{} -<136>[[f(1)]]-> <138>[Ok <2945>{}]<2946>w_a
# ^ <2907><129>{} -<132>[[f(1)]]-> <134>[Ok <2905>{}]<2906>w_a

2
crates/compiler/uitest/tests/solve/to_int.txt
View file

@ -15,4 +15,4 @@ entry =
}
main = entry
# ^^^^^ { toI128 : Int * -[[Num.toI128(125)]]-> I128, toI16 : Int w_a -[[Num.toI16(119)]]-> I16, toI32 : Int w_b -[[Num.toI32(121)]]-> I32, toI64 : Int w_c -[[Num.toI64(123)]]-> I64, toI8 : Int w_d -[[Num.toI8(117)]]-> I8, toU128 : Int w_f -[[Num.toU128(135)]]-> U128, toU16 : Int w_g -[[Num.toU16(129)]]-> U16, toU32 : Int w_h -[[Num.toU32(131)]]-> U32, toU64 : Int w_i -[[Num.toU64(133)]]-> U64, toU8 : Int w_j -[[Num.toU8(127)]]-> U8 }
# ^^^^^ { toI128 : Int * -[[Num.toI128(125)]]-> I128, toI16 : Int w_a -[[Num.toI16(119)]]-> I16, toI32 : Int w_b -[[Num.toI32(121)]]-> I32, toI64 : Int w_c -[[Num.toI64(123)]]-> I64, toI8 : Int w_d -[[Num.toI8(117)]]-> I8, toU128 : Int w_e -[[Num.toU128(135)]]-> U128, toU16 : Int w_f -[[Num.toU16(129)]]-> U16, toU32 : Int w_g -[[Num.toU32(131)]]-> U32, toU64 : Int w_h -[[Num.toU64(133)]]-> U64, toU8 : Int w_i -[[Num.toU8(127)]]-> U8 }