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

update mono snapshots

Browse source
This commit is contained in:
Luke Boswell 2024-08-17 17:23:03 +10:00
parent 4be6c5d4ce
commit 5f67ffe21a
No known key found for this signature in database
GPG key ID: F6DB3C9DB47377B0
27 changed files with 196 additions and 196 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 generated
View file

@ -41,8 +41,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.238 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.238;
let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.248;
procedure Test.1 (Test.5):
ret Test.5;

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

@ -44,8 +44,8 @@ procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.1 ():
let Test.4 : Str = "";

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

@ -40,8 +40,8 @@ procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.3 : Str = "";

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

@ -164,32 +164,32 @@ procedure Num.96 (#Attr.2):
ret Num.285;
procedure Str.12 (#Attr.2):
let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.248;
let Str.258 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.258;
procedure Str.36 (#Attr.2):
let Str.249 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.249;
let Str.259 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.259;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.45 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.45 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.45;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.325 : Str = CallByName Encode.23 Test.56;

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

@ -105,32 +105,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.24 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.24 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.24;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.292 : Str = CallByName Encode.23 Test.56;

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

@ -112,32 +112,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.28;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.296 : Str = CallByName Encode.23 Test.56;

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

@ -38,32 +38,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.3 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.3 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.3;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.259 : Str = CallByName Encode.23 Test.56;

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

@ -110,32 +110,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.27 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.27 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.27;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.297 : Str = CallByName Encode.23 Test.56;

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

@ -113,32 +113,32 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.36 (#Attr.2):
let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.246;
let Str.256 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.256;
procedure Str.43 (#Attr.2):
let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.243;
let Str.253 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.253;
procedure Str.9 (Str.71):
let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
let Str.240 : Int1 = StructAtIndex 2 Str.72;
if Str.240 then
let Str.242 : Str = StructAtIndex 1 Str.72;
let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
ret Str.241;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.250 : Int1 = StructAtIndex 2 Str.74;
if Str.250 then
let Str.252 : Str = StructAtIndex 1 Str.74;
let Str.251 : [C {U64, U8}, C Str] = TagId(1) Str.252;
ret Str.251;
else
let Str.238 : U8 = StructAtIndex 3 Str.72;
let Str.239 : U64 = StructAtIndex 0 Str.72;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.72;
let Str.248 : U8 = StructAtIndex 3 Str.74;
let Str.249 : U64 = StructAtIndex 0 Str.74;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.74;
dec #Derived_gen.28;
let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
ret Str.236;
let Str.247 : {U64, U8} = Struct {Str.249, Str.248};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.247;
ret Str.246;
procedure Test.20 (Test.56):
let Test.301 : Str = CallByName Encode.23 Test.56;

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

@ -1184,12 +1184,12 @@ procedure Num.96 (#Attr.2):
ret Num.438;
procedure Str.12 (#Attr.2):
let Str.238 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.238;
let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.248;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.239 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.239;
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Test.0 ():
let Test.8 : Str = "a";

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

@ -178,8 +178,8 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.2 : List I64 = Array [1i64, 2i64, 3i64];

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

@ -292,8 +292,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.237;
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Test.0 ():
let Test.4 : Str = "bar";

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

@ -209,8 +209,8 @@ procedure Num.96 (#Attr.2):
ret Num.282;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.3 : Decimal = 3dec;

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

@ -179,8 +179,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.3 : Str = "foo";

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

@ -186,8 +186,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.3 : Str = "foo";

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

@ -40,8 +40,8 @@ procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.2 : Str = "abc";

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

@ -179,8 +179,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.4 : Str = "foo";

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

@ -182,8 +182,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.281;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.0 ():
let Test.5 : Str = "foo";

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

@ -45,27 +45,27 @@ procedure Num.22 (#Attr.2, #Attr.3):
let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.281;
procedure Str.27 (Str.82):
let Str.236 : [C Int1, C I64] = CallByName Str.64 Str.82;
ret Str.236;
procedure Str.27 (Str.84):
let Str.246 : [C Int1, C I64] = CallByName Str.66 Str.84;
ret Str.246;
procedure Str.42 (#Attr.2):
let Str.244 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.244;
let Str.254 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.254;
procedure Str.64 (Str.189):
let Str.190 : {I64, U8} = CallByName Str.42 Str.189;
let Str.242 : U8 = StructAtIndex 1 Str.190;
let Str.243 : U8 = 0i64;
let Str.239 : Int1 = CallByName Bool.11 Str.242 Str.243;
if Str.239 then
let Str.241 : I64 = StructAtIndex 0 Str.190;
let Str.240 : [C Int1, C I64] = TagId(1) Str.241;
ret Str.240;
procedure Str.66 (Str.191):
let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
if Str.249 then
let Str.251 : I64 = StructAtIndex 0 Str.192;
let Str.250 : [C Int1, C I64] = TagId(1) Str.251;
ret Str.250;
else
let Str.238 : Int1 = false;
let Str.237 : [C Int1, C I64] = TagId(0) Str.238;
ret Str.237;
let Str.248 : Int1 = false;
let Str.247 : [C Int1, C I64] = TagId(0) Str.248;
ret Str.247;
procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2;

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

@ -19,30 +19,30 @@ procedure Decode.26 (Decode.109, Decode.110):
ret Decode.126;
procedure Str.12 (#Attr.2):
let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.245;
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
procedure Str.27 (Str.82):
let Str.236 : [C {}, C I64] = CallByName Str.64 Str.82;
ret Str.236;
procedure Str.27 (Str.84):
let Str.246 : [C {}, C I64] = CallByName Str.66 Str.84;
ret Str.246;
procedure Str.42 (#Attr.2):
let Str.244 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.244;
let Str.254 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.254;
procedure Str.64 (Str.189):
let Str.190 : {I64, U8} = CallByName Str.42 Str.189;
let Str.242 : U8 = StructAtIndex 1 Str.190;
let Str.243 : U8 = 0i64;
let Str.239 : Int1 = CallByName Bool.11 Str.242 Str.243;
if Str.239 then
let Str.241 : I64 = StructAtIndex 0 Str.190;
let Str.240 : [C {}, C I64] = TagId(1) Str.241;
ret Str.240;
procedure Str.66 (Str.191):
let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
if Str.249 then
let Str.251 : I64 = StructAtIndex 0 Str.192;
let Str.250 : [C {}, C I64] = TagId(1) Str.251;
ret Str.250;
else
let Str.238 : {} = Struct {};
let Str.237 : [C {}, C I64] = TagId(0) Str.238;
ret Str.237;
let Str.248 : {} = Struct {};
let Str.247 : [C {}, C I64] = TagId(0) Str.248;
ret Str.247;
procedure Test.103 ():
let Test.101 : [C Str, C {List U8, I64}] = CallByName Test.19;

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

@ -1,6 +1,6 @@
procedure Str.3 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Test.1 (Test.5):
let Test.16 : [C {}, C U64, C Str] = TagId(0) Test.5;

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

@ -71,12 +71,12 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.283;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.236 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.236;
let Str.246 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.237;
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -70,8 +70,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.237;
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

4
crates/compiler/test_mono/generated/polymorphic_expression_unification.txt generated
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.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.237;
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Test.2 (Test.7):
let Test.24 : Str = ".trace(\"";

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

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

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

@ -99,12 +99,12 @@ procedure Num.96 (#Attr.2):
ret Num.281;
procedure Str.12 (#Attr.2):
let Str.237 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.237;
let Str.247 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.247;
procedure Str.36 (#Attr.2):
let Str.238 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.238;
let Str.248 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.248;
procedure Test.20 (Test.58):
let Test.295 : Str = CallByName Encode.23 Test.58;

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

@ -192,12 +192,12 @@ procedure Num.96 (#Attr.2):
ret Num.285;
procedure Str.12 (#Attr.2):
let Str.240 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.240;
let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.250;
procedure Str.36 (#Attr.2):
let Str.241 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.241;
let Str.251 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.251;
procedure Test.20 (Test.58):
inc Test.58;