roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-11-05 01:58:58 +03:00
Code Issues Packages Projects Releases Wiki Activity

add test_mono files

Browse Source
This commit is contained in:
Isaac Van Doren 2023-10-14 15:38:31 -05:00
parent 886b855594
commit 3df2ace4a6
No known key found for this signature in database
GPG Key ID: CFA524CD470E5B94
16 changed files with 223 additions and 223 deletions
Show Stats 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.291; ret Num.291;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.291 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.294 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.291; ret Str.294;
procedure Test.1 (Test.5): procedure Test.1 (Test.5):
ret Test.5; ret Test.5;

52
crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt
View File

@ -345,38 +345,38 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.311; ret Num.311;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.307 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.310 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.307;
procedure Str.4 (#Attr.2, #Attr.3):
let Str.310 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.310; ret Str.310;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): procedure Str.4 (#Attr.2, #Attr.3):
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; let Str.313 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.298;
procedure Str.55 (#Attr.2):
let Str.313 : List Str = lowlevel StrGraphemes #Attr.2;
ret Str.313; ret Str.313;
procedure Str.9 (Str.79): procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.296 : U64 = 0i64; let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
let Str.297 : U64 = CallByName List.6 Str.79; ret Str.301;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80; procedure Str.55 (#Attr.2):
if Str.293 then let Str.316 : List Str = lowlevel StrGraphemes #Attr.2;
let Str.295 : Str = StructAtIndex 1 Str.80; ret Str.316;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294; procedure Str.9 (Str.80):
let Str.299 : U64 = 0i64;
let Str.300 : U64 = CallByName List.6 Str.80;
let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
let Str.296 : Int1 = StructAtIndex 2 Str.81;
if Str.296 then
let Str.298 : Str = StructAtIndex 1 Str.81;
let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
ret Str.297;
else else
let Str.291 : U8 = StructAtIndex 3 Str.80; let Str.294 : U8 = StructAtIndex 3 Str.81;
let Str.292 : U64 = StructAtIndex 0 Str.80; let Str.295 : U64 = StructAtIndex 0 Str.81;
let #Derived_gen.58 : Str = StructAtIndex 1 Str.80; let #Derived_gen.58 : Str = StructAtIndex 1 Str.81;
dec #Derived_gen.58; dec #Derived_gen.58;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291}; let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290; let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
ret Str.289; ret Str.292;
procedure TotallyNotJson.100 (TotallyNotJson.850): procedure TotallyNotJson.100 (TotallyNotJson.850):
let TotallyNotJson.1830 : Str = "a"; let TotallyNotJson.1830 : Str = "a";

52
crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt
View File

@ -288,38 +288,38 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.301; ret Num.301;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.303 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.300;
procedure Str.4 (#Attr.2, #Attr.3):
let Str.303 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.303; ret Str.303;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): procedure Str.4 (#Attr.2, #Attr.3):
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; let Str.306 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.298;
procedure Str.55 (#Attr.2):
let Str.306 : List Str = lowlevel StrGraphemes #Attr.2;
ret Str.306; ret Str.306;
procedure Str.9 (Str.79): procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.296 : U64 = 0i64; let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
let Str.297 : U64 = CallByName List.6 Str.79; ret Str.301;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80; procedure Str.55 (#Attr.2):
if Str.293 then let Str.309 : List Str = lowlevel StrGraphemes #Attr.2;
let Str.295 : Str = StructAtIndex 1 Str.80; ret Str.309;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294; procedure Str.9 (Str.80):
let Str.299 : U64 = 0i64;
let Str.300 : U64 = CallByName List.6 Str.80;
let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
let Str.296 : Int1 = StructAtIndex 2 Str.81;
if Str.296 then
let Str.298 : Str = StructAtIndex 1 Str.81;
let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
ret Str.297;
else else
let Str.291 : U8 = StructAtIndex 3 Str.80; let Str.294 : U8 = StructAtIndex 3 Str.81;
let Str.292 : U64 = StructAtIndex 0 Str.80; let Str.295 : U64 = StructAtIndex 0 Str.81;
let #Derived_gen.36 : Str = StructAtIndex 1 Str.80; let #Derived_gen.36 : Str = StructAtIndex 1 Str.81;
dec #Derived_gen.36; dec #Derived_gen.36;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291}; let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290; let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
ret Str.289; ret Str.292;
procedure TotallyNotJson.100 (TotallyNotJson.850): procedure TotallyNotJson.100 (TotallyNotJson.850):
let TotallyNotJson.1479 : Str = "a"; let TotallyNotJson.1479 : Str = "a";

52
crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt
View File

@ -295,38 +295,38 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.301; ret Num.301;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.303 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.300;
procedure Str.4 (#Attr.2, #Attr.3):
let Str.303 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.303; ret Str.303;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): procedure Str.4 (#Attr.2, #Attr.3):
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; let Str.306 : Str = lowlevel StrJoinWith #Attr.2 #Attr.3;
ret Str.298;
procedure Str.55 (#Attr.2):
let Str.306 : List Str = lowlevel StrGraphemes #Attr.2;
ret Str.306; ret Str.306;
procedure Str.9 (Str.79): procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.296 : U64 = 0i64; let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
let Str.297 : U64 = CallByName List.6 Str.79; ret Str.301;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297;
let Str.293 : Int1 = StructAtIndex 2 Str.80; procedure Str.55 (#Attr.2):
if Str.293 then let Str.309 : List Str = lowlevel StrGraphemes #Attr.2;
let Str.295 : Str = StructAtIndex 1 Str.80; ret Str.309;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295;
ret Str.294; procedure Str.9 (Str.80):
let Str.299 : U64 = 0i64;
let Str.300 : U64 = CallByName List.6 Str.80;
let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
let Str.296 : Int1 = StructAtIndex 2 Str.81;
if Str.296 then
let Str.298 : Str = StructAtIndex 1 Str.81;
let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
ret Str.297;
else else
let Str.291 : U8 = StructAtIndex 3 Str.80; let Str.294 : U8 = StructAtIndex 3 Str.81;
let Str.292 : U64 = StructAtIndex 0 Str.80; let Str.295 : U64 = StructAtIndex 0 Str.81;
let #Derived_gen.40 : Str = StructAtIndex 1 Str.80; let #Derived_gen.40 : Str = StructAtIndex 1 Str.81;
dec #Derived_gen.40; dec #Derived_gen.40;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291}; let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290; let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
ret Str.289; ret Str.292;
procedure TotallyNotJson.100 (TotallyNotJson.850): procedure TotallyNotJson.100 (TotallyNotJson.850):
let TotallyNotJson.1479 : Str = "a"; let TotallyNotJson.1479 : Str = "a";

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

@ -162,30 +162,30 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.293; ret Num.293;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.299 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.302 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.299; ret Str.302;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298; ret Str.301;
procedure Str.9 (Str.79): procedure Str.9 (Str.80):
let Str.296 : U64 = 0i64; let Str.299 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79; let Str.300 : U64 = CallByName List.6 Str.80;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297; let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
let Str.293 : Int1 = StructAtIndex 2 Str.80; let Str.296 : Int1 = StructAtIndex 2 Str.81;
if Str.293 then if Str.296 then
let Str.295 : Str = StructAtIndex 1 Str.80; let Str.298 : Str = StructAtIndex 1 Str.81;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295; let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
ret Str.294; ret Str.297;
else else
let Str.291 : U8 = StructAtIndex 3 Str.80; let Str.294 : U8 = StructAtIndex 3 Str.81;
let Str.292 : U64 = StructAtIndex 0 Str.80; let Str.295 : U64 = StructAtIndex 0 Str.81;
let #Derived_gen.13 : Str = StructAtIndex 1 Str.80; let #Derived_gen.13 : Str = StructAtIndex 1 Str.81;
dec #Derived_gen.13; dec #Derived_gen.13;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291}; let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290; let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
ret Str.289; ret Str.292;
procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1175, TotallyNotJson.181): procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1175, TotallyNotJson.181):
let TotallyNotJson.1178 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181; let TotallyNotJson.1178 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;

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

@ -243,30 +243,30 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.303; ret Num.303;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.303 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.300; ret Str.303;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298; ret Str.301;
procedure Str.9 (Str.79): procedure Str.9 (Str.80):
let Str.296 : U64 = 0i64; let Str.299 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79; let Str.300 : U64 = CallByName List.6 Str.80;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297; let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
let Str.293 : Int1 = StructAtIndex 2 Str.80; let Str.296 : Int1 = StructAtIndex 2 Str.81;
if Str.293 then if Str.296 then
let Str.295 : Str = StructAtIndex 1 Str.80; let Str.298 : Str = StructAtIndex 1 Str.81;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295; let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
ret Str.294; ret Str.297;
else else
let Str.291 : U8 = StructAtIndex 3 Str.80; let Str.294 : U8 = StructAtIndex 3 Str.81;
let Str.292 : U64 = StructAtIndex 0 Str.80; let Str.295 : U64 = StructAtIndex 0 Str.81;
let #Derived_gen.34 : Str = StructAtIndex 1 Str.80; let #Derived_gen.34 : Str = StructAtIndex 1 Str.81;
dec #Derived_gen.34; dec #Derived_gen.34;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291}; let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290; let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
ret Str.289; ret Str.292;
procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1216, TotallyNotJson.181): procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1216, TotallyNotJson.181):
let TotallyNotJson.1219 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181; let TotallyNotJson.1219 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;

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

@ -246,30 +246,30 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.303; ret Num.303;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.303 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.300; ret Str.303;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298; ret Str.301;
procedure Str.9 (Str.79): procedure Str.9 (Str.80):
let Str.296 : U64 = 0i64; let Str.299 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79; let Str.300 : U64 = CallByName List.6 Str.80;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297; let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
let Str.293 : Int1 = StructAtIndex 2 Str.80; let Str.296 : Int1 = StructAtIndex 2 Str.81;
if Str.293 then if Str.296 then
let Str.295 : Str = StructAtIndex 1 Str.80; let Str.298 : Str = StructAtIndex 1 Str.81;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295; let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
ret Str.294; ret Str.297;
else else
let Str.291 : U8 = StructAtIndex 3 Str.80; let Str.294 : U8 = StructAtIndex 3 Str.81;
let Str.292 : U64 = StructAtIndex 0 Str.80; let Str.295 : U64 = StructAtIndex 0 Str.81;
let #Derived_gen.35 : Str = StructAtIndex 1 Str.80; let #Derived_gen.35 : Str = StructAtIndex 1 Str.81;
dec #Derived_gen.35; dec #Derived_gen.35;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291}; let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290; let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
ret Str.289; ret Str.292;
procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1216, TotallyNotJson.181): procedure TotallyNotJson.182 (TotallyNotJson.183, TotallyNotJson.1216, TotallyNotJson.181):
let TotallyNotJson.1219 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181; let TotallyNotJson.1219 : List U8 = CallByName TotallyNotJson.26 TotallyNotJson.181;

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.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.291; ret Num.291;
procedure Str.27 (Str.99): procedure Str.27 (Str.100):
let Str.289 : [C Int1, C I64] = CallByName Str.72 Str.99; let Str.292 : [C Int1, C I64] = CallByName Str.73 Str.100;
ret Str.289; ret Str.292;
procedure Str.47 (#Attr.2): procedure Str.47 (#Attr.2):
let Str.297 : {I64, U8} = lowlevel StrToNum #Attr.2; let Str.300 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.297; ret Str.300;
procedure Str.72 (Str.235): procedure Str.73 (Str.236):
let Str.236 : {I64, U8} = CallByName Str.47 Str.235; let Str.237 : {I64, U8} = CallByName Str.47 Str.236;
dec Str.235; dec Str.236;
let Str.295 : U8 = StructAtIndex 1 Str.236; let Str.298 : U8 = StructAtIndex 1 Str.237;
let Str.296 : U8 = 0i64; let Str.299 : U8 = 0i64;
let Str.292 : Int1 = CallByName Bool.11 Str.295 Str.296; let Str.295 : Int1 = CallByName Bool.11 Str.298 Str.299;
if Str.292 then if Str.295 then
let Str.294 : I64 = StructAtIndex 0 Str.236; let Str.297 : I64 = StructAtIndex 0 Str.237;
let Str.293 : [C Int1, C I64] = TagId(1) Str.294; let Str.296 : [C Int1, C I64] = TagId(1) Str.297;
ret Str.293; ret Str.296;
else else
let Str.291 : Int1 = false; let Str.294 : Int1 = false;
let Str.290 : [C Int1, C I64] = TagId(0) Str.291; let Str.293 : [C Int1, C I64] = TagId(0) Str.294;
ret Str.290; ret Str.293;
procedure Test.0 (): procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2; let Test.3 : Int1 = CallByName Bool.2;

34
crates/compiler/test_mono/generated/issue_4749.txt
View File

@ -236,26 +236,26 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.324; ret Num.324;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.298 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; let Str.301 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.298; ret Str.301;
procedure Str.9 (Str.79): procedure Str.9 (Str.80):
let Str.296 : U64 = 0i64; let Str.299 : U64 = 0i64;
let Str.297 : U64 = CallByName List.6 Str.79; let Str.300 : U64 = CallByName List.6 Str.80;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.296 Str.297; let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.299 Str.300;
let Str.293 : Int1 = StructAtIndex 2 Str.80; let Str.296 : Int1 = StructAtIndex 2 Str.81;
if Str.293 then if Str.296 then
let Str.295 : Str = StructAtIndex 1 Str.80; let Str.298 : Str = StructAtIndex 1 Str.81;
let Str.294 : [C {U64, U8}, C Str] = TagId(1) Str.295; let Str.297 : [C {U64, U8}, C Str] = TagId(1) Str.298;
ret Str.294; ret Str.297;
else else
let Str.291 : U8 = StructAtIndex 3 Str.80; let Str.294 : U8 = StructAtIndex 3 Str.81;
let Str.292 : U64 = StructAtIndex 0 Str.80; let Str.295 : U64 = StructAtIndex 0 Str.81;
let #Derived_gen.6 : Str = StructAtIndex 1 Str.80; let #Derived_gen.6 : Str = StructAtIndex 1 Str.81;
dec #Derived_gen.6; dec #Derived_gen.6;
let Str.290 : {U64, U8} = Struct {Str.292, Str.291}; let Str.293 : {U64, U8} = Struct {Str.295, Str.294};
let Str.289 : [C {U64, U8}, C Str] = TagId(0) Str.290; let Str.292 : [C {U64, U8}, C Str] = TagId(0) Str.293;
ret Str.289; ret Str.292;
procedure Test.3 (): procedure Test.3 ():
let Test.0 : List U8 = Array [82i64, 111i64, 99i64]; let Test.0 : List U8 = Array [82i64, 111i64, 99i64];

74
crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt
View File

@ -210,53 +210,53 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.324; ret Num.324;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.298 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.301 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.298; ret Str.301;
procedure Str.27 (Str.99): procedure Str.27 (Str.100):
let Str.289 : [C {}, C I64] = CallByName Str.72 Str.99; let Str.292 : [C {}, C I64] = CallByName Str.73 Str.100;
ret Str.289; ret Str.292;
procedure Str.47 (#Attr.2): procedure Str.47 (#Attr.2):
let Str.297 : {I64, U8} = lowlevel StrToNum #Attr.2; let Str.300 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.297; ret Str.300;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4): procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.308 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4; let Str.311 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.308; ret Str.311;
procedure Str.72 (Str.235): procedure Str.73 (Str.236):
let Str.236 : {I64, U8} = CallByName Str.47 Str.235; let Str.237 : {I64, U8} = CallByName Str.47 Str.236;
dec Str.235; dec Str.236;
let Str.295 : U8 = StructAtIndex 1 Str.236; let Str.298 : U8 = StructAtIndex 1 Str.237;
let Str.296 : U8 = 0i64; let Str.299 : U8 = 0i64;
let Str.292 : Int1 = CallByName Bool.11 Str.295 Str.296; let Str.295 : Int1 = CallByName Bool.11 Str.298 Str.299;
if Str.292 then if Str.295 then
let Str.294 : I64 = StructAtIndex 0 Str.236; let Str.297 : I64 = StructAtIndex 0 Str.237;
let Str.293 : [C {}, C I64] = TagId(1) Str.294; let Str.296 : [C {}, C I64] = TagId(1) Str.297;
ret Str.296;
else
let Str.294 : {} = Struct {};
let Str.293 : [C {}, C I64] = TagId(0) Str.294;
ret Str.293; ret Str.293;
else
let Str.291 : {} = Struct {};
let Str.290 : [C {}, C I64] = TagId(0) Str.291;
ret Str.290;
procedure Str.9 (Str.79): procedure Str.9 (Str.80):
let Str.306 : U64 = 0i64; let Str.309 : U64 = 0i64;
let Str.307 : U64 = CallByName List.6 Str.79; let Str.310 : U64 = CallByName List.6 Str.80;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.306 Str.307; let Str.81 : {U64, Str, Int1, U8} = CallByName Str.48 Str.80 Str.309 Str.310;
let Str.303 : Int1 = StructAtIndex 2 Str.80; let Str.306 : Int1 = StructAtIndex 2 Str.81;
if Str.303 then if Str.306 then
let Str.305 : Str = StructAtIndex 1 Str.80; let Str.308 : Str = StructAtIndex 1 Str.81;
let Str.304 : [C {U64, U8}, C Str] = TagId(1) Str.305; let Str.307 : [C {U64, U8}, C Str] = TagId(1) Str.308;
ret Str.304; ret Str.307;
else else
let Str.301 : U8 = StructAtIndex 3 Str.80; let Str.304 : U8 = StructAtIndex 3 Str.81;
let Str.302 : U64 = StructAtIndex 0 Str.80; let Str.305 : U64 = StructAtIndex 0 Str.81;
let #Derived_gen.6 : Str = StructAtIndex 1 Str.80; let #Derived_gen.6 : Str = StructAtIndex 1 Str.81;
dec #Derived_gen.6; dec #Derived_gen.6;
let Str.300 : {U64, U8} = Struct {Str.302, Str.301}; let Str.303 : {U64, U8} = Struct {Str.305, Str.304};
let Str.299 : [C {U64, U8}, C Str] = TagId(0) Str.300; let Str.302 : [C {U64, U8}, C Str] = TagId(0) Str.303;
ret Str.299; ret Str.302;
procedure Test.0 (): procedure Test.0 ():
let Test.37 : Str = "-1234"; 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.291; ret Num.291;
procedure Str.16 (#Attr.2, #Attr.3): procedure Str.16 (#Attr.2, #Attr.3):
let Str.289 : Str = lowlevel StrRepeat #Attr.2 #Attr.3; let Str.292 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.289; ret Str.292;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.290 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.293 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.290; ret Str.293;
procedure Test.1 (): procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong"; 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.291; ret Num.291;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.290 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.293 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.290; ret Str.293;
procedure Test.1 (): procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong"; 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; ret Bool.23;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.290 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.293 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.290; ret Str.293;
procedure Test.2 (Test.7): procedure Test.2 (Test.7):
let Test.24 : Str = ".trace(\""; 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.291; ret Num.291;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.291 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.294 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.291; ret Str.294;
procedure Test.11 (Test.29, #Attr.12): procedure Test.11 (Test.29, #Attr.12):
let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #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

@ -232,8 +232,8 @@ procedure Num.94 (#Attr.2, #Attr.3):
ret Num.303; ret Num.303;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.290 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.293 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.290; ret Str.293;
procedure Test.2 (Test.10): procedure Test.2 (Test.10):
let Test.15 : {Str, Str} = CallByName Encode.23 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.313; ret Num.313;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.290 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.293 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.290; ret Str.293;
procedure Test.2 (Test.11): procedure Test.2 (Test.11):
let Test.18 : {{}, {}} = CallByName Encode.23 Test.11; let Test.18 : {{}, {}} = CallByName Encode.23 Test.11;