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:04:16 -05:00
parent 09574203ce
commit 0a4862da88
No known key found for this signature in database
GPG key ID: F1F21AA5B1D9E43B
29 changed files with 466 additions and 426 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -40,8 +40,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.297;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.253 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.253;
let Str.252 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.252;
procedure Test.1 (Test.5):
ret Test.5;

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

@ -42,8 +42,8 @@ procedure Inspect.62 (Inspect.306):
ret Inspect.306;
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.4 : Str = "";

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

@ -38,8 +38,8 @@ procedure Inspect.62 (Inspect.306):
ret Inspect.306;
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.3 : Str = "";

157
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.50, #Derived_gen.51, #Derived_gen.52, #Derived_gen.53, #Derived_gen.54):
procedure List.80 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
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,40 +200,9 @@ procedure List.80 (#Derived_gen.50, #Derived_gen.51, #Derived_gen.52, #Derived_g
let List.686 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.686;
in
jump List.685 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54;
jump List.685 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
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
let List.647 : U8 = CallByName List.66 List.161 List.164;
let List.166 : List U8 = CallByName TotallyNotJson.183 List.162 List.647;
let List.646 : U64 = 1i64;
let List.645 : U64 = CallByName Num.51 List.164 List.646;
jump List.641 List.161 List.166 List.163 List.645 List.165;
else
dec List.161;
ret List.162;
in
jump List.641 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
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
let List.601 : {Str, Str} = CallByName List.66 List.161 List.164;
inc List.601;
let List.166 : {List U8, U64} = CallByName TotallyNotJson.203 List.162 List.601;
let List.600 : U64 = 1i64;
let List.599 : U64 = CallByName Num.51 List.164 List.600;
jump List.595 List.161 List.166 List.163 List.599 List.165;
else
dec List.161;
ret List.162;
in
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):
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
@ -247,69 +216,105 @@ procedure List.90 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_g
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;
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):
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
let List.647 : U8 = CallByName List.66 List.161 List.164;
let List.166 : List U8 = CallByName TotallyNotJson.183 List.162 List.647;
let List.646 : U64 = 1i64;
let List.645 : U64 = CallByName Num.51 List.164 List.646;
jump List.641 List.161 List.166 List.163 List.645 List.165;
else
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;
procedure List.90 (#Derived_gen.47, #Derived_gen.48, #Derived_gen.49, #Derived_gen.50, #Derived_gen.51):
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
let List.601 : {Str, Str} = CallByName List.66 List.161 List.164;
inc List.601;
let List.166 : {List U8, U64} = CallByName TotallyNotJson.203 List.162 List.601;
let List.600 : U64 = 1i64;
let List.599 : U64 = CallByName Num.51 List.164 List.600;
jump List.595 List.161 List.166 List.163 List.599 List.165;
else
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;
procedure Num.127 (#Attr.2):
let Num.312 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.312;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.316 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.316;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.313 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
let Num.313 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.313;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.317 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.317;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.314 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.314;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.318 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.318;
let Num.319 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.319;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.324 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.324;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.326 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.326;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.321 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.321;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.325 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
let Num.325 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.325;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.327 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.327;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.322 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.322;
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.317 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.317;
let Num.318 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.318;
procedure Str.12 (#Attr.2):
let Str.263 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.263;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.260 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.260;
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
procedure Str.9 (Str.68):
let Str.258 : U64 = 0i64;
let Str.259 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.258 Str.259;
let Str.255 : Int1 = StructAtIndex 2 Str.69;
if Str.255 then
let Str.257 : Str = StructAtIndex 1 Str.69;
let Str.256 : [C {U64, U8}, C Str] = TagId(1) Str.257;
ret Str.256;
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;
else
let Str.253 : U8 = StructAtIndex 3 Str.69;
let Str.254 : U64 = StructAtIndex 0 Str.69;
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;
dec #Derived_gen.55;
let Str.252 : {U64, U8} = Struct {Str.254, Str.253};
let Str.251 : [C {U64, U8}, C Str] = TagId(0) Str.252;
ret Str.251;
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;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1043, TotallyNotJson.149):
let TotallyNotJson.1046 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;

95
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.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
procedure List.80 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
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.18, #Derived_gen.19, #Derived_gen.20, #Derived_g
let List.652 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.652;
in
jump List.651 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
jump List.651 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
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.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
procedure List.90 (#Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33):
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,69 +190,74 @@ procedure List.90 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_g
dec List.161;
ret List.162;
in
jump List.595 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
jump List.595 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33;
procedure Num.127 (#Attr.2):
let Num.302 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.302;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.306 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.306;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.303 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
let Num.303 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.303;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.307 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.307;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.304 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.304;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.308 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.308;
let Num.309 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.309;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.314 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.314;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.316 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.316;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.311 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.311;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.315 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
let Num.315 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.315;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.317 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.317;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.312 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.312;
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.307 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.307;
let Num.308 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.308;
procedure Str.12 (#Attr.2):
let Str.262 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.262;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.260 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.260;
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
procedure Str.9 (Str.68):
let Str.258 : U64 = 0i64;
let Str.259 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.258 Str.259;
let Str.255 : Int1 = StructAtIndex 2 Str.69;
if Str.255 then
let Str.257 : Str = StructAtIndex 1 Str.69;
let Str.256 : [C {U64, U8}, C Str] = TagId(1) Str.257;
ret Str.256;
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;
else
let Str.253 : U8 = StructAtIndex 3 Str.69;
let Str.254 : U64 = StructAtIndex 0 Str.69;
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;
dec #Derived_gen.34;
let Str.252 : {U64, U8} = Struct {Str.254, Str.253};
let Str.251 : [C {U64, U8}, C Str] = TagId(0) Str.252;
ret Str.251;
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;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1009, TotallyNotJson.149):
let TotallyNotJson.1012 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;

95
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.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
procedure List.80 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29):
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.22, #Derived_gen.23, #Derived_gen.24, #Derived_g
let List.652 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.652;
in
jump List.651 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
jump List.651 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29;
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.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34):
procedure List.90 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36, #Derived_gen.37):
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,69 +197,74 @@ procedure List.90 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_g
dec List.161;
ret List.162;
in
jump List.595 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
jump List.595 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37;
procedure Num.127 (#Attr.2):
let Num.302 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.302;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.306 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.306;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.303 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
let Num.303 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.303;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.307 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.307;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.304 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.304;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.308 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.308;
let Num.309 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.309;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.314 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.314;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.316 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.316;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.311 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.311;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.315 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
let Num.315 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.315;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.317 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.317;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.312 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.312;
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.307 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.307;
let Num.308 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.308;
procedure Str.12 (#Attr.2):
let Str.262 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.262;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.260 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.260;
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
procedure Str.9 (Str.68):
let Str.258 : U64 = 0i64;
let Str.259 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.258 Str.259;
let Str.255 : Int1 = StructAtIndex 2 Str.69;
if Str.255 then
let Str.257 : Str = StructAtIndex 1 Str.69;
let Str.256 : [C {U64, U8}, C Str] = TagId(1) Str.257;
ret Str.256;
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;
else
let Str.253 : U8 = StructAtIndex 3 Str.69;
let Str.254 : U64 = StructAtIndex 0 Str.69;
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;
dec #Derived_gen.38;
let Str.252 : {U64, U8} = Struct {Str.254, Str.253};
let Str.251 : [C {U64, U8}, C Str] = TagId(0) Str.252;
ret Str.251;
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;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1009, TotallyNotJson.149):
let TotallyNotJson.1012 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;

81
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.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
procedure List.80 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
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.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
let List.617 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.617;
in
jump List.616 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
jump List.616 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
procedure List.90 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
procedure List.90 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
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,61 +119,66 @@ procedure List.90 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen
dec List.161;
ret List.162;
in
jump List.587 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
jump List.587 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.298 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.298;
let Num.299 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.299;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.300 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.300;
let Num.301 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.301;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.304 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.304;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.306 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.306;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.302 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.302;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.305 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
let Num.305 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.305;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.307 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.307;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.303 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.303;
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.299 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.299;
let Num.300 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.300;
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.260 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.260;
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
procedure Str.9 (Str.68):
let Str.258 : U64 = 0i64;
let Str.259 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.258 Str.259;
let Str.255 : Int1 = StructAtIndex 2 Str.69;
if Str.255 then
let Str.257 : Str = StructAtIndex 1 Str.69;
let Str.256 : [C {U64, U8}, C Str] = TagId(1) Str.257;
ret Str.256;
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;
else
let Str.253 : U8 = StructAtIndex 3 Str.69;
let Str.254 : U64 = StructAtIndex 0 Str.69;
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;
dec #Derived_gen.13;
let Str.252 : {U64, U8} = Struct {Str.254, Str.253};
let Str.251 : [C {U64, U8}, C Str] = TagId(0) Str.252;
ret Str.251;
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;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.973, TotallyNotJson.149):
let TotallyNotJson.976 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;

99
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.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
procedure List.80 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
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.26, #Derived_gen.27, #Derived_gen.28, #Derived_g
let List.658 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.658;
in
jump List.657 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
jump List.657 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
procedure List.90 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
procedure List.90 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
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.13, #Derived_gen.14, #Derived_gen.15, #Derived_g
dec List.161;
ret List.162;
in
jump List.613 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
jump List.613 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
procedure List.90 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
procedure List.90 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
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,69 +192,74 @@ procedure List.90 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_g
dec List.161;
ret List.162;
in
jump List.601 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
jump List.601 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
procedure Num.127 (#Attr.2):
let Num.304 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.304;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.308 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.308;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.305 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
let Num.305 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.305;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.309 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.309;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.306 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.306;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.310 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.310;
let Num.311 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.311;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.316 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.316;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.318 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.318;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.313 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.313;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.317 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
let Num.317 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.317;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.319 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.319;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.314 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.314;
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.309 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.309;
let Num.310 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.310;
procedure Str.12 (#Attr.2):
let Str.262 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.262;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.260 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.260;
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
procedure Str.9 (Str.68):
let Str.258 : U64 = 0i64;
let Str.259 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.258 Str.259;
let Str.255 : Int1 = StructAtIndex 2 Str.69;
if Str.255 then
let Str.257 : Str = StructAtIndex 1 Str.69;
let Str.256 : [C {U64, U8}, C Str] = TagId(1) Str.257;
ret Str.256;
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;
else
let Str.253 : U8 = StructAtIndex 3 Str.69;
let Str.254 : U64 = StructAtIndex 0 Str.69;
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;
dec #Derived_gen.34;
let Str.252 : {U64, U8} = Struct {Str.254, Str.253};
let Str.251 : [C {U64, U8}, C Str] = TagId(0) Str.252;
ret Str.251;
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;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1014, TotallyNotJson.149):
let TotallyNotJson.1017 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;

125
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.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
procedure List.80 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
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,9 +164,24 @@ procedure List.80 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_g
let List.658 : [C {U64, Int1}, C {U64, Int1}] = TagId(1) List.490;
ret List.658;
in
jump List.657 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
jump List.657 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
procedure List.90 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
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):
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
@ -180,84 +195,74 @@ procedure List.90 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_g
dec List.161;
ret List.162;
in
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;
jump List.601 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
procedure Num.127 (#Attr.2):
let Num.304 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.304;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.308 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.308;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.305 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
let Num.305 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.305;
procedure Num.133 (#Attr.2):
let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
ret Num.297;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.309 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.309;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.306 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.306;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.310 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.310;
let Num.311 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.311;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.316 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.316;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.318 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.318;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.313 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.313;
procedure Num.75 (#Attr.2, #Attr.3):
let Num.317 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
let Num.317 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.317;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.319 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.319;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.314 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.314;
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.309 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.309;
let Num.310 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
ret Num.310;
procedure Str.12 (#Attr.2):
let Str.262 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.262;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.260 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.260;
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
procedure Str.9 (Str.68):
let Str.258 : U64 = 0i64;
let Str.259 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.258 Str.259;
let Str.255 : Int1 = StructAtIndex 2 Str.69;
if Str.255 then
let Str.257 : Str = StructAtIndex 1 Str.69;
let Str.256 : [C {U64, U8}, C Str] = TagId(1) Str.257;
ret Str.256;
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;
else
let Str.253 : U8 = StructAtIndex 3 Str.69;
let Str.254 : U64 = StructAtIndex 0 Str.69;
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;
dec #Derived_gen.35;
let Str.252 : {U64, U8} = Struct {Str.254, Str.253};
let Str.251 : [C {U64, U8}, C Str] = TagId(0) Str.252;
ret Str.251;
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;
procedure TotallyNotJson.150 (TotallyNotJson.151, TotallyNotJson.1014, TotallyNotJson.149):
let TotallyNotJson.1017 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.149;

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

@ -1193,12 +1193,12 @@ procedure Num.96 (#Attr.2):
ret Num.464;
procedure Str.12 (#Attr.2):
let Str.253 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.253;
let Str.252 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.252;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.254 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.254;
let Str.253 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.253;
procedure Test.0 ():
let Test.8 : Str = "a";

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

@ -167,8 +167,8 @@ procedure Num.96 (#Attr.2):
ret Num.297;
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.2 : List I64 = Array [1i64, 2i64, 3i64];

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

@ -269,8 +269,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.299;
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.0 ():
let Test.4 : Str = "bar";

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

@ -197,8 +197,8 @@ procedure Num.96 (#Attr.2):
ret Num.298;
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.3 : Decimal = 3dec;

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

@ -166,8 +166,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.297;
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.3 : Str = "foo";

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

@ -173,8 +173,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.297;
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.3 : Str = "foo";

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

@ -38,8 +38,8 @@ procedure Inspect.62 (Inspect.306):
ret Inspect.306;
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.2 : Str = "abc";

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

@ -168,8 +168,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.297;
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 = "foo";

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

@ -171,8 +171,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.297;
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.5 : Str = "foo";

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

@ -47,28 +47,28 @@ procedure Num.22 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
procedure Str.27 (Str.88):
let Str.251 : [C Int1, C I64] = CallByName Str.61 Str.88;
ret Str.251;
procedure Str.27 (Str.87):
let Str.250 : [C Int1, C I64] = CallByName Str.61 Str.87;
ret Str.250;
procedure Str.42 (#Attr.2):
let Str.259 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.259;
let Str.258 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.258;
procedure Str.61 (Str.195):
let Str.196 : {I64, U8} = CallByName Str.42 Str.195;
dec Str.195;
let Str.257 : U8 = StructAtIndex 1 Str.196;
let Str.258 : U8 = 0i64;
let Str.254 : Int1 = CallByName Bool.11 Str.257 Str.258;
if Str.254 then
let Str.256 : I64 = StructAtIndex 0 Str.196;
let Str.255 : [C Int1, C I64] = TagId(1) Str.256;
ret Str.255;
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;
else
let Str.253 : Int1 = false;
let Str.252 : [C Int1, C I64] = TagId(0) Str.253;
ret Str.252;
let Str.252 : Int1 = false;
let Str.251 : [C Int1, C I64] = TagId(0) Str.252;
ret Str.251;
procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2;

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

@ -178,6 +178,10 @@ 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.300 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.300;
@ -219,26 +223,27 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.331;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.260 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.260;
let Str.259 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.259;
procedure Str.9 (Str.68):
let Str.258 : U64 = 0i64;
let Str.259 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.258 Str.259;
let Str.255 : Int1 = StructAtIndex 2 Str.69;
if Str.255 then
let Str.257 : Str = StructAtIndex 1 Str.69;
let Str.256 : [C {U64, U8}, C Str] = TagId(1) Str.257;
ret Str.256;
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;
else
let Str.253 : U8 = StructAtIndex 3 Str.69;
let Str.254 : U64 = StructAtIndex 0 Str.69;
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;
dec #Derived_gen.6;
let Str.252 : {U64, U8} = Struct {Str.254, Str.253};
let Str.251 : [C {U64, U8}, C Str] = TagId(0) Str.252;
ret Str.251;
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;
procedure Test.3 ():
let Test.0 : List U8 = Array [82i64, 111i64, 99i64];

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

@ -152,6 +152,10 @@ 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.300 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.300;
@ -193,53 +197,54 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.331;
procedure Str.12 (#Attr.2):
let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.260;
procedure Str.27 (Str.88):
let Str.251 : [C {}, C I64] = CallByName Str.61 Str.88;
ret Str.251;
procedure Str.42 (#Attr.2):
let Str.259 : {I64, U8} = lowlevel StrToNum #Attr.2;
let Str.259 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.259;
procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
let Str.270 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.270;
procedure Str.27 (Str.87):
let Str.250 : [C {}, C I64] = CallByName Str.61 Str.87;
ret Str.250;
procedure Str.61 (Str.195):
let Str.196 : {I64, U8} = CallByName Str.42 Str.195;
dec Str.195;
let Str.257 : U8 = StructAtIndex 1 Str.196;
let Str.258 : U8 = 0i64;
let Str.254 : Int1 = CallByName Bool.11 Str.257 Str.258;
if Str.254 then
let Str.256 : I64 = StructAtIndex 0 Str.196;
let Str.255 : [C {}, C I64] = TagId(1) Str.256;
ret Str.255;
procedure Str.42 (#Attr.2):
let Str.258 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.258;
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;
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;
else
let Str.253 : {} = Struct {};
let Str.252 : [C {}, C I64] = TagId(0) Str.253;
ret Str.252;
let Str.252 : {} = Struct {};
let Str.251 : [C {}, C I64] = TagId(0) Str.252;
ret Str.251;
procedure Str.9 (Str.68):
let Str.268 : U64 = 0i64;
let Str.269 : U64 = CallByName List.6 Str.68;
let Str.69 : {U64, Str, Int1, U8} = CallByName Str.43 Str.68 Str.268 Str.269;
let Str.265 : Int1 = StructAtIndex 2 Str.69;
if Str.265 then
let Str.267 : Str = StructAtIndex 1 Str.69;
let Str.266 : [C {U64, U8}, C Str] = TagId(1) Str.267;
ret Str.266;
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;
else
let Str.263 : U8 = StructAtIndex 3 Str.69;
let Str.264 : U64 = StructAtIndex 0 Str.69;
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;
dec #Derived_gen.7;
let Str.262 : {U64, U8} = Struct {Str.264, Str.263};
let Str.261 : [C {U64, U8}, C Str] = TagId(0) Str.262;
ret Str.261;
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;
procedure Test.0 ():
let Test.37 : Str = "-1234";

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

@ -31,12 +31,12 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.297;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.251 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.251;
let Str.250 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.250;
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 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -31,8 +31,8 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.297;
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 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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.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.2 (Test.7):
let Test.24 : Str = ".trace(\"";

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

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

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

@ -220,8 +220,8 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.309;
procedure Str.12 (#Attr.2):
let Str.252 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.252;
let Str.251 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.251;
procedure Test.2 (Test.10):
let Test.15 : {Str, Str} = CallByName Encode.23 Test.10;

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

@ -178,8 +178,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.319;
procedure Str.12 (#Attr.2):
let Str.252 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.252;
let Str.251 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.251;
procedure Test.2 (Test.11):
let Test.18 : {{}, {}} = CallByName Encode.23 Test.11;

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

@ -46,8 +46,8 @@ procedure Inspect.62 (Inspect.306):
ret Inspect.306;
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 : {} = Struct {};

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

@ -49,8 +49,8 @@ procedure Inspect.62 (Inspect.306):
ret Inspect.306;
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.3):
let Test.4 : Str = CallByName Inspect.34 Test.3;