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

Fix mono tests

Browse source
This commit is contained in:
Richard Feldman 2022-08-12 15:28:05 -04:00
parent f0cd968aa8
commit 58c3575e44
No known key found for this signature in database
GPG key ID: F1F21AA5B1D9E43B
9 changed files with 128 additions and 128 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -399,31 +399,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.285;
procedure Str.12 (#Attr.2):
let Str.212 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.212;
let Str.219 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.219;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
let Str.211 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.211;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
let Str.209 : U64 = 0i64;
let Str.210 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.209 Str.210;
let Str.206 : Int1 = StructAtIndex 2 Str.70;
if Str.206 then
let Str.208 : Str = StructAtIndex 1 Str.70;
inc Str.208;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
let Str.207 : [C {U64, U8}, C Str] = TagId(1) Str.208;
ret Str.207;
else
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
let Str.204 : U8 = StructAtIndex 3 Str.70;
let Str.205 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
let Str.203 : {U64, U8} = Struct {Str.205, Str.204};
let Str.202 : [C {U64, U8}, C Str] = TagId(0) Str.203;
ret Str.202;
procedure Test.0 ():
let Test.12 : Str = "bar";

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

@ -240,31 +240,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.266;
procedure Str.12 (#Attr.2):
let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.210;
let Str.217 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.217;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
let Str.211 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.211;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
let Str.209 : U64 = 0i64;
let Str.210 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.209 Str.210;
let Str.206 : Int1 = StructAtIndex 2 Str.70;
if Str.206 then
let Str.208 : Str = StructAtIndex 1 Str.70;
inc Str.208;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
let Str.207 : [C {U64, U8}, C Str] = TagId(1) Str.208;
ret Str.207;
else
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
let Str.204 : U8 = StructAtIndex 3 Str.70;
let Str.205 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
let Str.203 : {U64, U8} = Struct {Str.205, Str.204};
let Str.202 : [C {U64, U8}, C Str] = TagId(0) Str.203;
ret Str.202;
procedure Test.0 ():
let Test.11 : Str = "foo";

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

@ -248,31 +248,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.266;
procedure Str.12 (#Attr.2):
let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.210;
let Str.217 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.217;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
let Str.211 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.211;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
let Str.209 : U64 = 0i64;
let Str.210 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.209 Str.210;
let Str.206 : Int1 = StructAtIndex 2 Str.70;
if Str.206 then
let Str.208 : Str = StructAtIndex 1 Str.70;
inc Str.208;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
let Str.207 : [C {U64, U8}, C Str] = TagId(1) Str.208;
ret Str.207;
else
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
let Str.204 : U8 = StructAtIndex 3 Str.70;
let Str.205 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
let Str.203 : {U64, U8} = Struct {Str.205, Str.204};
let Str.202 : [C {U64, U8}, C Str] = TagId(0) Str.203;
ret Str.202;
procedure Test.0 ():
let Test.11 : Str = "foo";

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

@ -61,31 +61,31 @@ procedure Num.123 (#Attr.2):
ret Num.258;
procedure Str.12 (#Attr.2):
let Str.209 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.209;
let Str.216 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.216;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
let Str.211 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.211;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
let Str.209 : U64 = 0i64;
let Str.210 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.209 Str.210;
let Str.206 : Int1 = StructAtIndex 2 Str.70;
if Str.206 then
let Str.208 : Str = StructAtIndex 1 Str.70;
inc Str.208;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
let Str.207 : [C {U64, U8}, C Str] = TagId(1) Str.208;
ret Str.207;
else
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
let Str.204 : U8 = StructAtIndex 3 Str.70;
let Str.205 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
let Str.203 : {U64, U8} = Struct {Str.205, Str.204};
let Str.202 : [C {U64, U8}, C Str] = TagId(0) Str.203;
ret Str.202;
procedure Test.0 ():
let Test.9 : Str = "abc";

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

@ -245,31 +245,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.268;
procedure Str.12 (#Attr.2):
let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.210;
let Str.217 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.217;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
let Str.211 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.211;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
let Str.209 : U64 = 0i64;
let Str.210 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.209 Str.210;
let Str.206 : Int1 = StructAtIndex 2 Str.70;
if Str.206 then
let Str.208 : Str = StructAtIndex 1 Str.70;
inc Str.208;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
let Str.207 : [C {U64, U8}, C Str] = TagId(1) Str.208;
ret Str.207;
else
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
let Str.204 : U8 = StructAtIndex 3 Str.70;
let Str.205 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
let Str.203 : {U64, U8} = Struct {Str.205, Str.204};
let Str.202 : [C {U64, U8}, C Str] = TagId(0) Str.203;
ret Str.202;
procedure Test.0 ():
let Test.12 : Str = "foo";

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

@ -251,31 +251,31 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.268;
procedure Str.12 (#Attr.2):
let Str.210 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.210;
let Str.217 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.217;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.204 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.204;
let Str.211 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;
ret Str.211;
procedure Str.9 (Str.69):
let Str.202 : U64 = 0i64;
let Str.203 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.202 Str.203;
let Str.199 : Int1 = StructAtIndex 2 Str.70;
if Str.199 then
let Str.201 : Str = StructAtIndex 1 Str.70;
inc Str.201;
let Str.209 : U64 = 0i64;
let Str.210 : U64 = CallByName List.6 Str.69;
let Str.70 : {U64, Str, Int1, U8} = CallByName Str.48 Str.69 Str.209 Str.210;
let Str.206 : Int1 = StructAtIndex 2 Str.70;
if Str.206 then
let Str.208 : Str = StructAtIndex 1 Str.70;
inc Str.208;
dec Str.70;
let Str.200 : [C {U64, U8}, C Str] = TagId(1) Str.201;
ret Str.200;
let Str.207 : [C {U64, U8}, C Str] = TagId(1) Str.208;
ret Str.207;
else
let Str.197 : U8 = StructAtIndex 3 Str.70;
let Str.198 : U64 = StructAtIndex 0 Str.70;
let Str.204 : U8 = StructAtIndex 3 Str.70;
let Str.205 : U64 = StructAtIndex 0 Str.70;
dec Str.70;
let Str.196 : {U64, U8} = Struct {Str.198, Str.197};
let Str.195 : [C {U64, U8}, C Str] = TagId(0) Str.196;
ret Str.195;
let Str.203 : {U64, U8} = Struct {Str.205, Str.204};
let Str.202 : [C {U64, U8}, C Str] = TagId(0) Str.203;
ret Str.202;
procedure Test.0 ():
let Test.13 : Str = "foo";

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

@ -42,26 +42,26 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.257;
procedure Str.27 (Str.89):
let Str.195 : [C Int1, C I64] = CallByName Str.62 Str.89;
ret Str.195;
let Str.202 : [C Int1, C I64] = CallByName Str.62 Str.89;
ret Str.202;
procedure Str.47 (#Attr.2):
let Str.203 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.203;
let Str.210 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.210;
procedure Str.62 (Str.190):
let Str.191 : {I64, U8} = CallByName Str.47 Str.190;
let Str.201 : U8 = StructAtIndex 1 Str.191;
let Str.202 : U8 = 0i64;
let Str.198 : Int1 = CallByName Bool.7 Str.201 Str.202;
if Str.198 then
let Str.200 : I64 = StructAtIndex 0 Str.191;
let Str.199 : [C Int1, C I64] = TagId(1) Str.200;
ret Str.199;
let Str.208 : U8 = StructAtIndex 1 Str.191;
let Str.209 : U8 = 0i64;
let Str.205 : Int1 = CallByName Bool.7 Str.208 Str.209;
if Str.205 then
let Str.207 : I64 = StructAtIndex 0 Str.191;
let Str.206 : [C Int1, C I64] = TagId(1) Str.207;
ret Str.206;
else
let Str.197 : Int1 = false;
let Str.196 : [C Int1, C I64] = TagId(0) Str.197;
ret Str.196;
let Str.204 : Int1 = false;
let Str.203 : [C Int1, C I64] = TagId(0) Str.204;
ret Str.203;
procedure Test.0 ():
let Test.4 : Int1 = true;

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.257;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.195 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.195;
let Str.202 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.202;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.196 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.196;
let Str.203 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.203;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -29,8 +29,8 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.196 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.196;
let Str.203 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.203;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";