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

Merge branch 'main' into builtin-json

Browse source
This commit is contained in:
Luke Boswell 2023-04-04 17:21:08 +10:00
commit dc43290647
No known key found for this signature in database
GPG key ID: F6DB3C9DB47377B0
199 changed files with 10195 additions and 3810 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

@ -47,8 +47,8 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.276;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.268 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.268;
let Str.300 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.300;
procedure Test.1 (Test.5):
ret Test.5;

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

@ -319,31 +319,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.303;
procedure Str.12 (#Attr.2):
let Str.283 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.283;
let Str.315 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.315;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.275 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.275;
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
procedure Str.9 (Str.77):
let Str.273 : U64 = 0i64;
let Str.274 : U64 = CallByName List.6 Str.77;
let Str.78 : {U64, Str, Int1, U8} = CallByName Str.48 Str.77 Str.273 Str.274;
let Str.270 : Int1 = StructAtIndex 2 Str.78;
if Str.270 then
let Str.272 : Str = StructAtIndex 1 Str.78;
inc Str.272;
dec Str.78;
let Str.271 : [C {U64, U8}, C Str] = TagId(1) Str.272;
ret Str.271;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
inc Str.304;
dec Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
else
let Str.268 : U8 = StructAtIndex 3 Str.78;
let Str.269 : U64 = StructAtIndex 0 Str.78;
dec Str.78;
let Str.267 : {U64, U8} = Struct {Str.269, Str.268};
let Str.266 : [C {U64, U8}, C Str] = TagId(0) Str.267;
ret Str.266;
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
dec Str.80;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
procedure Test.0 ():
let Test.12 : Str = "bar";

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

@ -196,31 +196,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.284;
procedure Str.12 (#Attr.2):
let Str.281 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.281;
let Str.313 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.313;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.275 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.275;
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
procedure Str.9 (Str.77):
let Str.273 : U64 = 0i64;
let Str.274 : U64 = CallByName List.6 Str.77;
let Str.78 : {U64, Str, Int1, U8} = CallByName Str.48 Str.77 Str.273 Str.274;
let Str.270 : Int1 = StructAtIndex 2 Str.78;
if Str.270 then
let Str.272 : Str = StructAtIndex 1 Str.78;
inc Str.272;
dec Str.78;
let Str.271 : [C {U64, U8}, C Str] = TagId(1) Str.272;
ret Str.271;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
inc Str.304;
dec Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
else
let Str.268 : U8 = StructAtIndex 3 Str.78;
let Str.269 : U64 = StructAtIndex 0 Str.78;
dec Str.78;
let Str.267 : {U64, U8} = Struct {Str.269, Str.268};
let Str.266 : [C {U64, U8}, C Str] = TagId(0) Str.267;
ret Str.266;
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
dec Str.80;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
procedure Test.0 ():
let Test.11 : Str = "foo";

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

@ -204,31 +204,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.284;
procedure Str.12 (#Attr.2):
let Str.281 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.281;
let Str.313 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.313;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.275 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.275;
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
procedure Str.9 (Str.77):
let Str.273 : U64 = 0i64;
let Str.274 : U64 = CallByName List.6 Str.77;
let Str.78 : {U64, Str, Int1, U8} = CallByName Str.48 Str.77 Str.273 Str.274;
let Str.270 : Int1 = StructAtIndex 2 Str.78;
if Str.270 then
let Str.272 : Str = StructAtIndex 1 Str.78;
inc Str.272;
dec Str.78;
let Str.271 : [C {U64, U8}, C Str] = TagId(1) Str.272;
ret Str.271;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
inc Str.304;
dec Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
else
let Str.268 : U8 = StructAtIndex 3 Str.78;
let Str.269 : U64 = StructAtIndex 0 Str.78;
dec Str.78;
let Str.267 : {U64, U8} = Struct {Str.269, Str.268};
let Str.266 : [C {U64, U8}, C Str] = TagId(0) Str.267;
ret Str.266;
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
dec Str.80;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
procedure Test.0 ():
let Test.11 : Str = "foo";

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

@ -57,31 +57,31 @@ procedure Num.127 (#Attr.2):
ret Num.276;
procedure Str.12 (#Attr.2):
let Str.280 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.280;
let Str.312 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.312;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.275 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.275;
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
procedure Str.9 (Str.77):
let Str.273 : U64 = 0i64;
let Str.274 : U64 = CallByName List.6 Str.77;
let Str.78 : {U64, Str, Int1, U8} = CallByName Str.48 Str.77 Str.273 Str.274;
let Str.270 : Int1 = StructAtIndex 2 Str.78;
if Str.270 then
let Str.272 : Str = StructAtIndex 1 Str.78;
inc Str.272;
dec Str.78;
let Str.271 : [C {U64, U8}, C Str] = TagId(1) Str.272;
ret Str.271;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
inc Str.304;
dec Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
else
let Str.268 : U8 = StructAtIndex 3 Str.78;
let Str.269 : U64 = StructAtIndex 0 Str.78;
dec Str.78;
let Str.267 : {U64, U8} = Struct {Str.269, Str.268};
let Str.266 : [C {U64, U8}, C Str] = TagId(0) Str.267;
ret Str.266;
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
dec Str.80;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
procedure Test.0 ():
let Test.9 : Str = "abc";

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

@ -205,31 +205,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.286;
procedure Str.12 (#Attr.2):
let Str.281 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.281;
let Str.313 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.313;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.275 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.275;
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
procedure Str.9 (Str.77):
let Str.273 : U64 = 0i64;
let Str.274 : U64 = CallByName List.6 Str.77;
let Str.78 : {U64, Str, Int1, U8} = CallByName Str.48 Str.77 Str.273 Str.274;
let Str.270 : Int1 = StructAtIndex 2 Str.78;
if Str.270 then
let Str.272 : Str = StructAtIndex 1 Str.78;
inc Str.272;
dec Str.78;
let Str.271 : [C {U64, U8}, C Str] = TagId(1) Str.272;
ret Str.271;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
inc Str.304;
dec Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
else
let Str.268 : U8 = StructAtIndex 3 Str.78;
let Str.269 : U64 = StructAtIndex 0 Str.78;
dec Str.78;
let Str.267 : {U64, U8} = Struct {Str.269, Str.268};
let Str.266 : [C {U64, U8}, C Str] = TagId(0) Str.267;
ret Str.266;
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
dec Str.80;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
procedure Test.0 ():
let Test.12 : Str = "foo";

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

@ -211,31 +211,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.286;
procedure Str.12 (#Attr.2):
let Str.281 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.281;
let Str.313 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.313;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.275 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.275;
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
procedure Str.9 (Str.77):
let Str.273 : U64 = 0i64;
let Str.274 : U64 = CallByName List.6 Str.77;
let Str.78 : {U64, Str, Int1, U8} = CallByName Str.48 Str.77 Str.273 Str.274;
let Str.270 : Int1 = StructAtIndex 2 Str.78;
if Str.270 then
let Str.272 : Str = StructAtIndex 1 Str.78;
inc Str.272;
dec Str.78;
let Str.271 : [C {U64, U8}, C Str] = TagId(1) Str.272;
ret Str.271;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
inc Str.304;
dec Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
else
let Str.268 : U8 = StructAtIndex 3 Str.78;
let Str.269 : U64 = StructAtIndex 0 Str.78;
dec Str.78;
let Str.267 : {U64, U8} = Struct {Str.269, Str.268};
let Str.266 : [C {U64, U8}, C Str] = TagId(0) Str.267;
ret Str.266;
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
dec Str.80;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
procedure Test.0 ():
let Test.13 : Str = "foo";

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

@ -45,27 +45,27 @@ procedure Num.22 (#Attr.2, #Attr.3):
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Str.27 (Str.97):
let Str.266 : [C Int1, C I64] = CallByName Str.70 Str.97;
ret Str.266;
procedure Str.27 (Str.99):
let Str.298 : [C Int1, C I64] = CallByName Str.72 Str.99;
ret Str.298;
procedure Str.47 (#Attr.2):
let Str.274 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.274;
let Str.306 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.306;
procedure Str.70 (Str.232):
let Str.233 : {I64, U8} = CallByName Str.47 Str.232;
let Str.272 : U8 = StructAtIndex 1 Str.233;
let Str.273 : U8 = 0i64;
let Str.269 : Int1 = CallByName Bool.11 Str.272 Str.273;
if Str.269 then
let Str.271 : I64 = StructAtIndex 0 Str.233;
let Str.270 : [C Int1, C I64] = TagId(1) Str.271;
ret Str.270;
procedure Str.72 (Str.244):
let Str.245 : {I64, U8} = CallByName Str.47 Str.244;
let Str.304 : U8 = StructAtIndex 1 Str.245;
let Str.305 : U8 = 0i64;
let Str.301 : Int1 = CallByName Bool.11 Str.304 Str.305;
if Str.301 then
let Str.303 : I64 = StructAtIndex 0 Str.245;
let Str.302 : [C Int1, C I64] = TagId(1) Str.303;
ret Str.302;
else
let Str.268 : Int1 = false;
let Str.267 : [C Int1, C I64] = TagId(0) Str.268;
ret Str.267;
let Str.300 : Int1 = false;
let Str.299 : [C Int1, C I64] = TagId(0) Str.300;
ret Str.299;
procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2;

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

@ -759,27 +759,27 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.321;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.275 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.275;
let Str.307 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.307;
procedure Str.9 (Str.77):
let Str.273 : U64 = 0i64;
let Str.274 : U64 = CallByName List.6 Str.77;
let Str.78 : {U64, Str, Int1, U8} = CallByName Str.48 Str.77 Str.273 Str.274;
let Str.270 : Int1 = StructAtIndex 2 Str.78;
if Str.270 then
let Str.272 : Str = StructAtIndex 1 Str.78;
inc Str.272;
dec Str.78;
let Str.271 : [C {U64, U8}, C Str] = TagId(1) Str.272;
ret Str.271;
procedure Str.9 (Str.79):
let Str.305 : U64 = 0i64;
let Str.306 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.305 Str.306;
let Str.302 : Int1 = StructAtIndex 2 Str.80;
if Str.302 then
let Str.304 : Str = StructAtIndex 1 Str.80;
inc Str.304;
dec Str.80;
let Str.303 : [C {U64, U8}, C Str] = TagId(1) Str.304;
ret Str.303;
else
let Str.268 : U8 = StructAtIndex 3 Str.78;
let Str.269 : U64 = StructAtIndex 0 Str.78;
dec Str.78;
let Str.267 : {U64, U8} = Struct {Str.269, Str.268};
let Str.266 : [C {U64, U8}, C Str] = TagId(0) Str.267;
ret Str.266;
let Str.300 : U8 = StructAtIndex 3 Str.80;
let Str.301 : U64 = StructAtIndex 0 Str.80;
dec Str.80;
let Str.299 : {U64, U8} = Struct {Str.301, Str.300};
let Str.298 : [C {U64, U8}, C Str] = TagId(0) Str.299;
ret Str.298;
procedure Test.3 ():
let Test.0 : List U8 = Array [82i64, 111i64, 99i64];

13
crates/compiler/test_mono/generated/issue_4759.txt Normal file
View file

@ -0,0 +1,13 @@
procedure Test.1 (Test.2):
dec Test.2;
let Test.7 : Str = "ux";
let Test.8 : Str = "uy";
let Test.6 : {Str, Str} = Struct {Test.7, Test.8};
ret Test.6;
procedure Test.0 ():
let Test.10 : Str = "x";
let Test.11 : Str = "y";
let Test.9 : {Str, Str} = Struct {Test.10, Test.11};
let Test.3 : {Str, Str} = CallByName Test.1 Test.9;
ret Test.3;

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

@ -729,53 +729,53 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.321;
procedure Str.12 (#Attr.2):
let Str.275 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.275;
let Str.307 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.307;
procedure Str.27 (Str.97):
let Str.266 : [C {}, C I64] = CallByName Str.70 Str.97;
ret Str.266;
procedure Str.27 (Str.99):
let Str.298 : [C {}, C I64] = CallByName Str.72 Str.99;
ret Str.298;
procedure Str.47 (#Attr.2):
let Str.274 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.274;
let Str.306 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.306;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.289 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.289;
let Str.321 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.321;
procedure Str.70 (Str.232):
let Str.233 : {I64, U8} = CallByName Str.47 Str.232;
let Str.272 : U8 = StructAtIndex 1 Str.233;
let Str.273 : U8 = 0i64;
let Str.269 : Int1 = CallByName Bool.11 Str.272 Str.273;
if Str.269 then
let Str.271 : I64 = StructAtIndex 0 Str.233;
let Str.270 : [C {}, C I64] = TagId(1) Str.271;
ret Str.270;
procedure Str.72 (Str.244):
let Str.245 : {I64, U8} = CallByName Str.47 Str.244;
let Str.304 : U8 = StructAtIndex 1 Str.245;
let Str.305 : U8 = 0i64;
let Str.301 : Int1 = CallByName Bool.11 Str.304 Str.305;
if Str.301 then
let Str.303 : I64 = StructAtIndex 0 Str.245;
let Str.302 : [C {}, C I64] = TagId(1) Str.303;
ret Str.302;
else
let Str.268 : {} = Struct {};
let Str.267 : [C {}, C I64] = TagId(0) Str.268;
ret Str.267;
let Str.300 : {} = Struct {};
let Str.299 : [C {}, C I64] = TagId(0) Str.300;
ret Str.299;
procedure Str.9 (Str.77):
let Str.287 : U64 = 0i64;
let Str.288 : U64 = CallByName List.6 Str.77;
let Str.78 : {U64, Str, Int1, U8} = CallByName Str.48 Str.77 Str.287 Str.288;
let Str.284 : Int1 = StructAtIndex 2 Str.78;
if Str.284 then
let Str.286 : Str = StructAtIndex 1 Str.78;
inc Str.286;
dec Str.78;
let Str.285 : [C {U64, U8}, C Str] = TagId(1) Str.286;
ret Str.285;
procedure Str.9 (Str.79):
let Str.319 : U64 = 0i64;
let Str.320 : U64 = CallByName List.6 Str.79;
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.48 Str.79 Str.319 Str.320;
let Str.316 : Int1 = StructAtIndex 2 Str.80;
if Str.316 then
let Str.318 : Str = StructAtIndex 1 Str.80;
inc Str.318;
dec Str.80;
let Str.317 : [C {U64, U8}, C Str] = TagId(1) Str.318;
ret Str.317;
else
let Str.282 : U8 = StructAtIndex 3 Str.78;
let Str.283 : U64 = StructAtIndex 0 Str.78;
dec Str.78;
let Str.281 : {U64, U8} = Struct {Str.283, Str.282};
let Str.280 : [C {U64, U8}, C Str] = TagId(0) Str.281;
ret Str.280;
let Str.314 : U8 = StructAtIndex 3 Str.80;
let Str.315 : U64 = StructAtIndex 0 Str.80;
dec Str.80;
let Str.313 : {U64, U8} = Struct {Str.315, Str.314};
let Str.312 : [C {U64, U8}, C Str] = TagId(0) Str.313;
ret Str.312;
procedure Test.0 ():
let Test.37 : Str = "-1234";

56
crates/compiler/test_mono/generated/layout_cache_structure_with_multiple_recursive_structures.txt Normal file
View file

@ -0,0 +1,56 @@
procedure List.139 (List.140, List.141, List.138):
let List.513 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.140 List.141;
ret List.513;
procedure List.18 (List.136, List.137, List.138):
let List.494 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.92 List.136 List.137 List.138;
ret List.494;
procedure List.6 (#Attr.2):
let List.511 : U64 = lowlevel ListLen #Attr.2;
ret List.511;
procedure List.66 (#Attr.2, #Attr.3):
let List.510 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.510;
procedure List.80 (List.517, List.518, List.519, List.520, List.521):
joinpoint List.500 List.433 List.434 List.435 List.436 List.437:
let List.502 : Int1 = CallByName Num.22 List.436 List.437;
if List.502 then
let List.509 : [<rnu>C *self, <null>] = CallByName List.66 List.433 List.436;
let List.503 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.139 List.434 List.509 List.435;
let List.506 : U64 = 1i64;
let List.505 : U64 = CallByName Num.19 List.436 List.506;
jump List.500 List.433 List.503 List.435 List.505 List.437;
else
ret List.434;
in
jump List.500 List.517 List.518 List.519 List.520 List.521;
procedure List.92 (List.430, List.431, List.432):
let List.498 : U64 = 0i64;
let List.499 : U64 = CallByName List.6 List.430;
let List.497 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.80 List.430 List.431 List.432 List.498 List.499;
ret List.497;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.276;
procedure Test.7 (Test.11, Test.12):
let Test.17 : {[<rnu>C *self, <null>], [<rnu><null>, C {[<rnu>C *self, <null>], *self}]} = Struct {Test.12, Test.11};
let Test.16 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = TagId(0) Test.17;
ret Test.16;
procedure Test.0 ():
let Test.6 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = TagId(1) ;
let Test.8 : List [<rnu>C *self, <null>] = Array [];
let Test.15 : {} = Struct {};
let Test.9 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.18 Test.8 Test.6 Test.15;
dec Test.8;
ret Test.9;

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

@ -27,12 +27,12 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.275;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.266 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.266;
let Str.298 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.298;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.267 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.267;
let Str.299 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.299;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -28,8 +28,8 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.275;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.267 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.267;
let Str.299 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.299;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -1,6 +1,6 @@
procedure Str.3 (#Attr.2, #Attr.3):
let Str.267 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.267;
let Str.299 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.299;
procedure Test.2 (Test.4):
let Test.16 : U8 = GetTagId Test.4;

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.267 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.267;
let Str.299 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.299;
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.275;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.268 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.268;
let Str.300 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.300;
procedure Test.11 (Test.29, #Attr.12):
let Test.10 : {} = 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

@ -190,8 +190,8 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.286;
procedure Str.12 (#Attr.2):
let Str.267 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.267;
let Str.299 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.299;
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

@ -330,8 +330,8 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.305;
procedure Str.12 (#Attr.2):
let Str.268 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.268;
let Str.300 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.300;
procedure Test.2 (Test.11):
let Test.18 : {{}, {}} = CallByName Encode.23 Test.11;