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 7

mono tests

Browse source
This commit is contained in:
Folkert 2023-09-12 18:15:41 +02:00
parent 3909443ef4
commit 26c85d9ccc
No known key found for this signature in database
GPG key ID: 1F17F6FFD112B97C
15 changed files with 305 additions and 305 deletions
Download patch file Download diff file Expand all files Collapse all files

96
crates/compiler/test_mono/generated/capture_void_layout_task.txt
View file

@ -35,28 +35,28 @@ procedure Num.51 (#Attr.2, #Attr.3):
let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.292;
procedure Test.10 (Test.66, #Attr.12):
let Test.9 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
procedure Test.10 (Test.69, #Attr.12):
let Test.72 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let #Derived_gen.20 : Int1 = lowlevel RefCountIsUnique #Attr.12;
if #Derived_gen.20 then
free #Attr.12;
ret Test.9;
ret Test.72;
else
decref #Attr.12;
ret Test.9;
ret Test.72;
procedure Test.10 (Test.66, #Attr.12):
let Test.9 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
ret Test.9;
procedure Test.10 (Test.69, #Attr.12):
let Test.80 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
ret Test.80;
procedure Test.14 (Test.45, #Attr.12):
let Test.13 : {{}, []} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.12 : [<r>C {}, C *self {{}, []}] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.55 : {{}, []} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.54 : [<r>C {}, C *self {{}, []}] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
joinpoint #Derived_gen.18:
let Test.50 : {} = Struct {};
let Test.51 : U8 = GetTagId Test.12;
let Test.51 : U8 = GetTagId Test.54;
joinpoint Test.52 Test.15:
let Test.16 : [C {}, C []] = CallByName Test.20 Test.15 Test.13;
let Test.16 : [C {}, C []] = CallByName Test.20 Test.15 Test.55;
let Test.48 : {} = Struct {};
let Test.49 : U8 = GetTagId Test.16;
switch Test.49:
@ -71,11 +71,11 @@ procedure Test.14 (Test.45, #Attr.12):
in
switch Test.51:
case 0:
let Test.53 : {} = CallByName Test.10 Test.50 Test.12;
let Test.53 : {} = CallByName Test.10 Test.50 Test.54;
jump Test.52 Test.53;
default:
let Test.53 : {} = CallByName Test.14 Test.50 Test.12;
let Test.53 : {} = CallByName Test.14 Test.50 Test.54;
jump Test.52 Test.53;
in
@ -84,7 +84,7 @@ procedure Test.14 (Test.45, #Attr.12):
free #Attr.12;
jump #Derived_gen.18;
else
inc Test.12;
inc Test.54;
decref #Attr.12;
jump #Derived_gen.18;
@ -92,10 +92,10 @@ procedure Test.20 (Test.21, Test.18):
let Test.23 : [C {}, C []] = CallByName Test.32 Test.21 Test.18;
ret Test.23;
procedure Test.25 (Test.57, #Attr.12):
let Test.24 : [] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.60 : Str = "voided tag constructor is unreachable";
Crash Test.60
procedure Test.25 (Test.59, #Attr.12):
let Test.63 : [] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.62 : Str = "voided tag constructor is unreachable";
Crash Test.62
procedure Test.29 (Test.30, Test.31, Test.28):
let Test.42 : {{}, []} = Struct {Test.28, Test.31};
@ -103,23 +103,23 @@ procedure Test.29 (Test.30, Test.31, Test.28):
ret Test.41;
procedure Test.3 (Test.9):
let Test.65 : [<r>C {}, C *self {{}, []}] = TagId(0) Test.9;
ret Test.65;
let Test.68 : [<r>C {}, C *self {{}, []}] = TagId(0) Test.9;
ret Test.68;
procedure Test.3 (Test.9):
let Test.72 : [C {}, C []] = TagId(0) Test.9;
ret Test.72;
let Test.76 : [C {}, C []] = TagId(0) Test.9;
ret Test.76;
procedure Test.32 (Test.61, #Attr.12):
procedure Test.32 (Test.64, #Attr.12):
let Test.31 : [] = StructAtIndex 1 #Attr.12;
let Test.28 : {} = StructAtIndex 0 #Attr.12;
let Test.63 : [C {}, C []] = CallByName Test.33 Test.31;
ret Test.63;
let Test.66 : [C {}, C []] = CallByName Test.33 Test.31;
ret Test.66;
procedure Test.33 (Test.69):
let Test.71 : {} = Struct {};
let Test.70 : [C {}, C []] = CallByName Test.3 Test.71;
ret Test.70;
procedure Test.33 (Test.73):
let Test.75 : {} = Struct {};
let Test.74 : [C {}, C []] = CallByName Test.3 Test.75;
ret Test.74;
procedure Test.4 (Test.12, Test.13):
let Test.46 : [<r>C {}, C *self {{}, []}] = TagId(1) Test.12 Test.13;
@ -130,33 +130,33 @@ procedure Test.5 (Test.17, Test.18):
ret Test.19;
procedure Test.6 (Test.27, Test.28):
let Test.64 : {} = Struct {};
let Test.38 : [<r>C {}, C *self {{}, []}] = CallByName Test.3 Test.64;
let Test.67 : {} = Struct {};
let Test.38 : [<r>C {}, C *self {{}, []}] = CallByName Test.3 Test.67;
let Test.37 : [<r>C {}, C *self {{}, []}] = CallByName List.18 Test.27 Test.38 Test.28;
ret Test.37;
procedure Test.76 (Test.77):
let Test.78 : {{}, []} = UnionAtIndex (Id 0) (Index 0) Test.77;
dec Test.77;
let Test.79 : {} = StructAtIndex 0 Test.78;
ret Test.79;
procedure Test.81 (Test.82):
let Test.83 : {{}, []} = UnionAtIndex (Id 0) (Index 0) Test.82;
dec Test.82;
let Test.84 : {} = StructAtIndex 0 Test.83;
ret Test.84;
procedure Test.80 (Test.81):
let Test.82 : {{}, []} = UnionAtIndex (Id 0) (Index 0) Test.81;
dec Test.81;
let Test.83 : [] = StructAtIndex 1 Test.82;
ret Test.83;
procedure Test.85 (Test.86):
let Test.87 : {{}, []} = UnionAtIndex (Id 0) (Index 0) Test.86;
dec Test.86;
let Test.88 : [] = StructAtIndex 1 Test.87;
ret Test.88;
procedure Test.84 (Test.86, #Attr.12):
let Test.87 : U8 = GetTagId #Attr.12;
switch Test.87:
procedure Test.89 (Test.91, #Attr.12):
let Test.92 : U8 = GetTagId #Attr.12;
switch Test.92:
case 0:
let Test.85 : {} = CallByName Test.10 Test.86 #Attr.12;
ret Test.85;
let Test.90 : {} = CallByName Test.10 Test.91 #Attr.12;
ret Test.90;
default:
let Test.85 : {} = CallByName Test.14 Test.86 #Attr.12;
ret Test.85;
let Test.90 : {} = CallByName Test.14 Test.91 #Attr.12;
ret Test.90;
procedure Test.0 ():

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

@ -48,26 +48,26 @@ procedure Test.1 (Test.5):
procedure Test.11 (#Derived_gen.8, #Derived_gen.9):
joinpoint Test.27 Test.12 #Attr.12:
let Test.8 : Int1 = UnionAtIndex (Id 2) (Index 1) #Attr.12;
let Test.7 : [<rnw><null>, C *self Int1, C *self Int1] = UnionAtIndex (Id 2) (Index 0) #Attr.12;
let Test.34 : Int1 = UnionAtIndex (Id 2) (Index 1) #Attr.12;
let Test.33 : [<rnw><null>, C *self Int1, C *self Int1] = UnionAtIndex (Id 2) (Index 0) #Attr.12;
joinpoint #Derived_gen.12:
joinpoint Test.31 Test.29:
let Test.30 : U8 = GetTagId Test.7;
let Test.30 : U8 = GetTagId Test.33;
switch Test.30:
case 0:
dec Test.7;
dec Test.33;
let Test.28 : Str = CallByName Test.2 Test.29;
ret Test.28;
case 1:
let Test.28 : Str = CallByName Test.9 Test.29 Test.7;
let Test.28 : Str = CallByName Test.9 Test.29 Test.33;
ret Test.28;
default:
jump Test.27 Test.29 Test.7;
jump Test.27 Test.29 Test.33;
in
switch Test.8:
switch Test.34:
case 0:
let Test.32 : Str = CallByName Test.3 Test.12;
jump Test.31 Test.32;
@ -82,7 +82,7 @@ procedure Test.11 (#Derived_gen.8, #Derived_gen.9):
free #Attr.12;
jump #Derived_gen.12;
else
inc Test.7;
inc Test.33;
decref #Attr.12;
jump #Derived_gen.12;
in
@ -92,57 +92,57 @@ procedure Test.2 (Test.13):
ret Test.13;
procedure Test.3 (Test.14):
let Test.48 : Str = "!";
let Test.47 : Str = CallByName Str.3 Test.14 Test.48;
dec Test.48;
ret Test.47;
let Test.52 : Str = "!";
let Test.51 : Str = CallByName Str.3 Test.14 Test.52;
dec Test.52;
ret Test.51;
procedure Test.4 (Test.15):
let Test.44 : Str = "(";
let Test.46 : Str = ")";
let Test.45 : Str = CallByName Str.3 Test.15 Test.46;
dec Test.46;
let Test.43 : Str = CallByName Str.3 Test.44 Test.45;
dec Test.45;
ret Test.43;
let Test.48 : Str = "(";
let Test.50 : Str = ")";
let Test.49 : Str = CallByName Str.3 Test.15 Test.50;
dec Test.50;
let Test.47 : Str = CallByName Str.3 Test.48 Test.49;
dec Test.49;
ret Test.47;
procedure Test.6 (Test.7, Test.8, Test.5):
if Test.5 then
let Test.33 : [<rnw><null>, C *self Int1, C *self Int1] = TagId(1) Test.7 Test.8;
ret Test.33;
let Test.35 : [<rnw><null>, C *self Int1, C *self Int1] = TagId(1) Test.7 Test.8;
ret Test.35;
else
let Test.26 : [<rnw><null>, C *self Int1, C *self Int1] = TagId(2) Test.7 Test.8;
ret Test.26;
procedure Test.9 (Test.10, #Attr.12):
let Test.8 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.7 : [<rnw><null>, C *self Int1, C *self Int1] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.43 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.42 : [<rnw><null>, C *self Int1, C *self Int1] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
joinpoint #Derived_gen.14:
let Test.37 : U8 = GetTagId Test.7;
joinpoint Test.38 Test.36:
switch Test.8:
let Test.39 : U8 = GetTagId Test.42;
joinpoint Test.40 Test.38:
switch Test.43:
case 0:
let Test.35 : Str = CallByName Test.3 Test.36;
ret Test.35;
let Test.37 : Str = CallByName Test.3 Test.38;
ret Test.37;
default:
let Test.35 : Str = CallByName Test.4 Test.36;
ret Test.35;
let Test.37 : Str = CallByName Test.4 Test.38;
ret Test.37;
in
switch Test.37:
switch Test.39:
case 0:
dec Test.7;
let Test.39 : Str = CallByName Test.2 Test.10;
jump Test.38 Test.39;
dec Test.42;
let Test.41 : Str = CallByName Test.2 Test.10;
jump Test.40 Test.41;
case 1:
let Test.39 : Str = CallByName Test.9 Test.10 Test.7;
jump Test.38 Test.39;
let Test.41 : Str = CallByName Test.9 Test.10 Test.42;
jump Test.40 Test.41;
default:
let Test.39 : Str = CallByName Test.11 Test.10 Test.7;
jump Test.38 Test.39;
let Test.41 : Str = CallByName Test.11 Test.10 Test.42;
jump Test.40 Test.41;
in
let #Derived_gen.15 : Int1 = lowlevel RefCountIsUnique #Attr.12;
@ -150,14 +150,14 @@ procedure Test.9 (Test.10, #Attr.12):
free #Attr.12;
jump #Derived_gen.14;
else
inc Test.7;
inc Test.42;
decref #Attr.12;
jump #Derived_gen.14;
procedure Test.0 ():
let Test.41 : Int1 = false;
let Test.42 : Int1 = true;
let Test.20 : List Int1 = Array [Test.41, Test.42];
let Test.45 : Int1 = false;
let Test.46 : Int1 = true;
let Test.20 : List Int1 = Array [Test.45, Test.46];
let Test.21 : [<rnw><null>, C *self Int1, C *self Int1] = TagId(0) ;
let Test.23 : Int1 = CallByName Bool.2;
let Test.22 : Int1 = CallByName Test.1 Test.23;

14
crates/compiler/test_mono/generated/inline_return_joinpoints_in_union_lambda_set.txt
View file

@ -3,9 +3,9 @@ procedure Num.19 (#Attr.2, #Attr.3):
ret Num.293;
procedure Test.2 (Test.3, Test.1):
let Test.17 : Int1 = false;
let Test.18 : Int1 = lowlevel Eq Test.17 Test.3;
if Test.18 then
let Test.18 : Int1 = false;
let Test.19 : Int1 = lowlevel Eq Test.18 Test.3;
if Test.19 then
let Test.13 : [C , C I64] = TagId(0) ;
ret Test.13;
else
@ -13,14 +13,14 @@ procedure Test.2 (Test.3, Test.1):
ret Test.14;
procedure Test.4 (Test.5, #Attr.12):
let Test.1 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.16 : I64 = CallByName Num.19 Test.5 Test.1;
let Test.17 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.16 : I64 = CallByName Num.19 Test.5 Test.17;
ret Test.16;
procedure Test.0 (#Derived_gen.2):
joinpoint Test.7 Test.1:
let Test.20 : I64 = 1i64;
let Test.9 : I64 = CallByName Num.19 Test.1 Test.20;
let Test.21 : I64 = 1i64;
let Test.9 : I64 = CallByName Num.19 Test.1 Test.21;
let Test.12 : Int1 = false;
let Test.10 : [C , C I64] = CallByName Test.2 Test.12 Test.1;
let Test.11 : U8 = GetTagId Test.10;

26
crates/compiler/test_mono/generated/lambda_capture_niche_u8_vs_u64.txt
View file

@ -11,18 +11,18 @@ procedure Test.1 (Test.4):
ret Test.13;
procedure Test.1 (Test.4):
let Test.19 : [C U8, C U64] = TagId(0) Test.4;
ret Test.19;
let Test.20 : [C U8, C U64] = TagId(0) Test.4;
ret Test.20;
procedure Test.5 (Test.14, #Attr.12):
let Test.4 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.16 : Str = CallByName Num.96 Test.4;
let Test.17 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.16 : Str = CallByName Num.96 Test.17;
ret Test.16;
procedure Test.5 (Test.14, #Attr.12):
let Test.4 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.22 : Str = CallByName Num.96 Test.4;
ret Test.22;
let Test.24 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.23 : Str = CallByName Num.96 Test.24;
ret Test.23;
procedure Test.0 ():
let Test.2 : Int1 = true;
@ -39,13 +39,13 @@ procedure Test.0 ():
ret Test.7;
in
let Test.23 : Int1 = true;
let Test.24 : Int1 = lowlevel Eq Test.23 Test.2;
if Test.24 then
let Test.25 : Int1 = true;
let Test.26 : Int1 = lowlevel Eq Test.25 Test.2;
if Test.26 then
let Test.12 : U64 = 123i64;
let Test.11 : [C U8, C U64] = CallByName Test.1 Test.12;
jump Test.10 Test.11;
else
let Test.18 : U8 = 18i64;
let Test.17 : [C U8, C U64] = CallByName Test.1 Test.18;
jump Test.10 Test.17;
let Test.19 : U8 = 18i64;
let Test.18 : [C U8, C U64] = CallByName Test.1 Test.19;
jump Test.10 Test.18;

68
crates/compiler/test_mono/generated/lambda_capture_niches_have_captured_function_in_closure.txt
View file

@ -1,47 +1,37 @@
procedure Test.11 (Test.34):
let Test.35 : Str = "";
ret Test.35;
procedure Test.13 (Test.48, Test.12):
ret Test.12;
procedure Test.15 (Test.36):
procedure Test.11 (Test.36):
let Test.37 : Str = "";
ret Test.37;
procedure Test.16 (Test.51):
let Test.53 : Str = "s1";
ret Test.53;
procedure Test.13 (Test.52, Test.12):
ret Test.12;
procedure Test.15 (Test.38):
let Test.39 : Str = "";
ret Test.39;
procedure Test.16 (Test.55):
let Test.57 : Str = "s1";
ret Test.57;
procedure Test.2 (Test.7, Test.8):
let Test.27 : [C {} {}, C {} {}] = TagId(1) Test.7 Test.8;
ret Test.27;
procedure Test.2 (Test.7, Test.8):
let Test.41 : [C {} {}, C {} {}] = TagId(0) Test.7 Test.8;
ret Test.41;
let Test.43 : [C {} {}, C {} {}] = TagId(0) Test.7 Test.8;
ret Test.43;
procedure Test.3 (Test.17):
dec Test.17;
let Test.33 : {} = Struct {};
ret Test.33;
let Test.35 : {} = Struct {};
ret Test.35;
procedure Test.4 (Test.18):
ret Test.18;
procedure Test.9 (Test.26, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 0) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.46 : {} = Struct {};
let Test.45 : Str = CallByName Test.16 Test.46;
let Test.42 : Str = CallByName Test.4 Test.45;
let Test.44 : {} = Struct {};
let Test.43 : Str = CallByName Test.13 Test.44 Test.42;
ret Test.43;
procedure Test.9 (Test.26, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.34 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.33 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.32 : {} = Struct {};
let Test.31 : Str = CallByName Test.15 Test.32;
let Test.28 : {} = CallByName Test.3 Test.31;
@ -49,6 +39,16 @@ procedure Test.9 (Test.26, #Attr.12):
let Test.29 : Str = CallByName Test.11 Test.30;
ret Test.29;
procedure Test.9 (Test.26, #Attr.12):
let Test.50 : {} = UnionAtIndex (Id 0) (Index 1) #Attr.12;
let Test.49 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.48 : {} = Struct {};
let Test.47 : Str = CallByName Test.16 Test.48;
let Test.44 : Str = CallByName Test.4 Test.47;
let Test.46 : {} = Struct {};
let Test.45 : Str = CallByName Test.13 Test.46 Test.44;
ret Test.45;
procedure Test.0 ():
let Test.5 : Int1 = true;
joinpoint Test.22 Test.6:
@ -64,15 +64,15 @@ procedure Test.0 ():
ret Test.19;
in
let Test.54 : Int1 = true;
let Test.55 : Int1 = lowlevel Eq Test.54 Test.5;
if Test.55 then
let Test.58 : Int1 = true;
let Test.59 : Int1 = lowlevel Eq Test.58 Test.5;
if Test.59 then
let Test.24 : {} = Struct {};
let Test.25 : {} = Struct {};
let Test.23 : [C {} {}, C {} {}] = CallByName Test.2 Test.24 Test.25;
jump Test.22 Test.23;
else
let Test.39 : {} = Struct {};
let Test.40 : {} = Struct {};
let Test.38 : [C {} {}, C {} {}] = CallByName Test.2 Test.39 Test.40;
jump Test.22 Test.38;
let Test.41 : {} = Struct {};
let Test.42 : {} = Struct {};
let Test.40 : [C {} {}, C {} {}] = CallByName Test.2 Test.41 Test.42;
jump Test.22 Test.40;

30
crates/compiler/test_mono/generated/lambda_capture_niches_with_non_capturing_function.txt
View file

@ -3,23 +3,23 @@ procedure Test.1 (Test.5):
ret Test.15;
procedure Test.1 (Test.5):
let Test.23 : [C , C {}, C U64] = TagId(2) Test.5;
ret Test.23;
let Test.24 : [C , C {}, C U64] = TagId(2) Test.5;
ret Test.24;
procedure Test.2 (Test.8):
let Test.20 : Str = "";
ret Test.20;
let Test.21 : Str = "";
ret Test.21;
procedure Test.6 (Test.16, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 2) (Index 0) #Attr.12;
let Test.26 : Str = "";
ret Test.26;
procedure Test.6 (Test.16, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.19 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.18 : Str = "";
ret Test.18;
procedure Test.6 (Test.16, #Attr.12):
let Test.28 : U64 = UnionAtIndex (Id 2) (Index 0) #Attr.12;
let Test.27 : Str = "";
ret Test.27;
procedure Test.0 ():
let Test.3 : U8 = 0u8;
joinpoint Test.12 Test.4:
@ -46,11 +46,11 @@ procedure Test.0 ():
jump Test.12 Test.13;
case 1:
let Test.19 : [C , C {}, C U64] = TagId(0) ;
jump Test.12 Test.19;
let Test.20 : [C , C {}, C U64] = TagId(0) ;
jump Test.12 Test.20;
default:
let Test.22 : U64 = 1i64;
let Test.21 : [C , C {}, C U64] = CallByName Test.1 Test.22;
jump Test.12 Test.21;
let Test.23 : U64 = 1i64;
let Test.22 : [C , C {}, C U64] = CallByName Test.1 Test.23;
jump Test.12 Test.22;

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

@ -3,26 +3,26 @@ procedure Test.1 (Test.5):
ret Test.16;
procedure Test.1 (Test.5):
let Test.28 : [C {}, C U64, C Str] = TagId(1) Test.5;
ret Test.28;
let Test.30 : [C {}, C U64, C Str] = TagId(1) Test.5;
ret Test.30;
procedure Test.2 (Test.7):
let Test.22 : [C {}, C U64, C Str] = TagId(2) Test.7;
ret Test.22;
let Test.23 : [C {}, C U64, C Str] = TagId(2) Test.7;
ret Test.23;
procedure Test.6 (Test.17, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.31 : Str = "";
ret Test.31;
procedure Test.6 (Test.17, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.20 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.19 : Str = "";
ret Test.19;
procedure Test.8 (Test.23, #Attr.12):
let Test.7 : Str = UnionAtIndex (Id 2) (Index 0) #Attr.12;
ret Test.7;
procedure Test.6 (Test.17, #Attr.12):
let Test.34 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.33 : Str = "";
ret Test.33;
procedure Test.8 (Test.24, #Attr.12):
let Test.27 : Str = UnionAtIndex (Id 2) (Index 0) #Attr.12;
ret Test.27;
procedure Test.0 ():
let Test.3 : U8 = 0u8;
@ -50,12 +50,12 @@ procedure Test.0 ():
jump Test.13 Test.14;
case 1:
let Test.21 : Str = "foo";
let Test.20 : [C {}, C U64, C Str] = CallByName Test.2 Test.21;
jump Test.13 Test.20;
let Test.22 : Str = "foo";
let Test.21 : [C {}, C U64, C Str] = CallByName Test.2 Test.22;
jump Test.13 Test.21;
default:
let Test.27 : U64 = 1i64;
let Test.26 : [C {}, C U64, C Str] = CallByName Test.1 Test.27;
jump Test.13 Test.26;
let Test.29 : U64 = 1i64;
let Test.28 : [C {}, C U64, C Str] = CallByName Test.1 Test.29;
jump Test.13 Test.28;

24
crates/compiler/test_mono/generated/lambda_set_niche_same_layout_different_constructor.txt
View file

@ -3,12 +3,12 @@ procedure Test.1 (Test.4):
ret Test.13;
procedure Test.1 (Test.4):
let Test.18 : [C Str, C Str] = TagId(0) Test.4;
ret Test.18;
let Test.19 : [C Str, C Str] = TagId(0) Test.4;
ret Test.19;
procedure Test.5 (Test.12, #Attr.12):
let Test.4 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
dec Test.4;
let Test.15 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
dec Test.15;
let Test.14 : Str = "";
ret Test.14;
@ -17,13 +17,13 @@ procedure Test.0 ():
joinpoint Test.9 Test.3:
ret Test.3;
in
let Test.20 : Int1 = true;
let Test.21 : Int1 = lowlevel Eq Test.20 Test.2;
if Test.21 then
let Test.15 : Str = "";
let Test.10 : [C Str, C Str] = CallByName Test.1 Test.15;
let Test.21 : Int1 = true;
let Test.22 : Int1 = lowlevel Eq Test.21 Test.2;
if Test.22 then
let Test.16 : Str = "";
let Test.10 : [C Str, C Str] = CallByName Test.1 Test.16;
jump Test.9 Test.10;
else
let Test.19 : Str = "";
let Test.16 : [C Str, C Str] = CallByName Test.1 Test.19;
jump Test.9 Test.16;
let Test.20 : Str = "";
let Test.17 : [C Str, C Str] = CallByName Test.1 Test.20;
jump Test.9 Test.17;

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

@ -25,18 +25,18 @@ procedure Num.19 (#Attr.2, #Attr.3):
ret Num.294;
procedure Test.4 (Test.5, #Attr.12):
let Test.1 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.15 : U8 = CallByName Num.19 Test.5 Test.1;
let Test.16 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.15 : U8 = CallByName Num.19 Test.5 Test.16;
ret Test.15;
procedure Test.6 (Test.7, #Attr.12):
let Test.2 : U8 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.17 : U8 = CallByName Num.19 Test.7 Test.2;
ret Test.17;
let Test.19 : U8 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.18 : U8 = CallByName Num.19 Test.7 Test.19;
ret Test.18;
procedure Test.8 (Test.9):
let Test.19 : U8 = CallByName Num.19 Test.9 Test.9;
ret Test.19;
let Test.21 : U8 = CallByName Num.19 Test.9 Test.9;
ret Test.21;
procedure Test.0 ():
let Test.1 : U8 = 1i64;
@ -47,21 +47,21 @@ procedure Test.0 ():
ret Test.10;
in
let Test.12 : Str = "";
let Test.22 : Str = "A";
let Test.23 : Int1 = lowlevel Eq Test.22 Test.12;
dec Test.22;
if Test.23 then
let Test.24 : Str = "A";
let Test.25 : Int1 = lowlevel Eq Test.24 Test.12;
dec Test.24;
if Test.25 then
dec Test.12;
let Test.14 : [C U8, C U8, C ] = TagId(0) Test.1;
jump Test.13 Test.14;
else
let Test.20 : Str = "B";
let Test.21 : Int1 = lowlevel Eq Test.20 Test.12;
let Test.22 : Str = "B";
let Test.23 : Int1 = lowlevel Eq Test.22 Test.12;
dec Test.12;
dec Test.20;
if Test.21 then
let Test.16 : [C U8, C U8, C ] = TagId(1) Test.2;
jump Test.13 Test.16;
dec Test.22;
if Test.23 then
let Test.17 : [C U8, C U8, C ] = TagId(1) Test.2;
jump Test.13 Test.17;
else
let Test.18 : [C U8, C U8, C ] = TagId(2) ;
jump Test.13 Test.18;
let Test.20 : [C U8, C U8, C ] = TagId(2) ;
jump Test.13 Test.20;

30
crates/compiler/test_mono/generated/recursive_lambda_set_has_nested_non_recursive_lambda_sets_issue_5026.txt
View file

@ -2,19 +2,19 @@ procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Test.10 (Test.25):
dec Test.25;
let Test.29 : Int1 = CallByName Bool.2;
if Test.29 then
let Test.30 : [<rnu><null>, C {}] = CallByName Test.0;
ret Test.30;
procedure Test.10 (Test.26):
dec Test.26;
let Test.30 : Int1 = CallByName Bool.2;
if Test.30 then
let Test.31 : [<rnu><null>, C {}] = CallByName Test.0;
ret Test.31;
else
let Test.26 : [<rnu><null>, C {}] = TagId(1) ;
ret Test.26;
let Test.27 : [<rnu><null>, C {}] = TagId(1) ;
ret Test.27;
procedure Test.11 (Test.27):
let Test.28 : Str = "done";
ret Test.28;
procedure Test.11 (Test.28):
let Test.29 : Str = "done";
ret Test.29;
procedure Test.2 (Test.5):
let Test.17 : [<rnu><null>, C {}] = TagId(0) Test.5;
@ -25,11 +25,11 @@ procedure Test.3 (Test.7):
ret Test.14;
procedure Test.6 (Test.16, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.23 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
joinpoint #Derived_gen.2:
let Test.19 : {} = Struct {};
let Test.22 : Str = "foobar";
let Test.20 : [<rnu><null>, C {}] = CallByName Test.8 Test.22 Test.5;
let Test.20 : [<rnu><null>, C {}] = CallByName Test.8 Test.22 Test.23;
let Test.21 : U8 = GetTagId Test.20;
switch Test.21:
case 0:
@ -51,8 +51,8 @@ procedure Test.6 (Test.16, #Attr.12):
jump #Derived_gen.2;
procedure Test.8 (Test.9, Test.7):
let Test.24 : [<rnu><null>, C {}] = CallByName Test.10 Test.9;
ret Test.24;
let Test.25 : [<rnu><null>, C {}] = CallByName Test.10 Test.9;
ret Test.25;
procedure Test.0 ():
let Test.13 : {} = Struct {};

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

@ -12,24 +12,24 @@ procedure Num.21 (#Attr.2, #Attr.3):
procedure Test.1 (#Derived_gen.2, #Derived_gen.3):
joinpoint Test.11 Test.2 Test.3:
let Test.24 : U8 = 0i64;
let Test.20 : Int1 = CallByName Bool.11 Test.2 Test.24;
if Test.20 then
let Test.22 : U8 = 1i64;
let Test.23 : U8 = GetTagId Test.3;
switch Test.23:
let Test.26 : U8 = 0i64;
let Test.22 : Int1 = CallByName Bool.11 Test.2 Test.26;
if Test.22 then
let Test.24 : U8 = 1i64;
let Test.25 : U8 = GetTagId Test.3;
switch Test.25:
case 0:
let Test.21 : U8 = CallByName Test.4 Test.22 Test.3;
ret Test.21;
let Test.23 : U8 = CallByName Test.4 Test.24 Test.3;
ret Test.23;
default:
dec Test.3;
let Test.21 : U8 = CallByName Test.6 Test.22;
ret Test.21;
let Test.23 : U8 = CallByName Test.6 Test.24;
ret Test.23;
else
let Test.19 : U8 = 1i64;
let Test.13 : U8 = CallByName Num.20 Test.2 Test.19;
let Test.21 : U8 = 1i64;
let Test.13 : U8 = CallByName Num.20 Test.2 Test.21;
let Test.14 : [<rnu><null>, C *self U8] = TagId(0) Test.3 Test.2;
jump Test.11 Test.13 Test.14;
in
@ -37,17 +37,17 @@ procedure Test.1 (#Derived_gen.2, #Derived_gen.3):
procedure Test.4 (#Derived_gen.0, #Derived_gen.1):
joinpoint Test.15 Test.5 #Attr.12:
let Test.2 : U8 = UnionAtIndex (Id 0) (Index 1) #Attr.12;
let Test.3 : [<rnu><null>, C *self U8] = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.20 : U8 = UnionAtIndex (Id 0) (Index 1) #Attr.12;
let Test.19 : [<rnu><null>, C *self U8] = UnionAtIndex (Id 0) (Index 0) #Attr.12;
joinpoint #Derived_gen.4:
let Test.17 : U8 = CallByName Num.21 Test.2 Test.5;
let Test.18 : U8 = GetTagId Test.3;
let Test.17 : U8 = CallByName Num.21 Test.20 Test.5;
let Test.18 : U8 = GetTagId Test.19;
switch Test.18:
case 0:
jump Test.15 Test.17 Test.3;
jump Test.15 Test.17 Test.19;
default:
dec Test.3;
dec Test.19;
let Test.16 : U8 = CallByName Test.6 Test.17;
ret Test.16;
@ -57,7 +57,7 @@ procedure Test.4 (#Derived_gen.0, #Derived_gen.1):
free #Attr.12;
jump #Derived_gen.4;
else
inc Test.3;
inc Test.19;
decref #Attr.12;
jump #Derived_gen.4;
in

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

@ -7,35 +7,35 @@ procedure Str.3 (#Attr.2, #Attr.3):
ret Str.291;
procedure Test.11 (Test.29, #Attr.12):
let Test.10 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let #Derived_gen.11 : Int1 = lowlevel RefCountIsUnique #Attr.12;
if #Derived_gen.11 then
free #Attr.12;
ret Test.10;
ret Test.32;
else
decref #Attr.12;
ret Test.10;
ret Test.32;
procedure Test.11 (Test.29, Test.10):
ret Test.10;
procedure Test.14 (#Derived_gen.0, #Derived_gen.1):
joinpoint Test.37 Test.36 #Attr.12:
let Test.12 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.13 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
joinpoint Test.38 Test.37 #Attr.12:
let Test.46 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.45 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
joinpoint #Derived_gen.9:
let Test.43 : {} = Struct {};
let Test.42 : {} = CallByName Test.11 Test.43 Test.12;
let Test.38 : [<r>C {}, C I64 {}] = CallByName Test.9 Test.42 Test.13;
let Test.40 : {} = Struct {};
let Test.41 : U8 = GetTagId Test.38;
switch Test.41:
let Test.44 : {} = Struct {};
let Test.43 : {} = CallByName Test.11 Test.44 Test.46;
let Test.39 : [<r>C {}, C I64 {}] = CallByName Test.9 Test.43 Test.45;
let Test.41 : {} = Struct {};
let Test.42 : U8 = GetTagId Test.39;
switch Test.42:
case 0:
let Test.39 : {} = CallByName Test.11 Test.40 Test.38;
ret Test.39;
let Test.40 : {} = CallByName Test.11 Test.41 Test.39;
ret Test.40;
default:
jump Test.37 Test.40 Test.38;
jump Test.38 Test.41 Test.39;
in
let #Derived_gen.10 : Int1 = lowlevel RefCountIsUnique #Attr.12;
@ -46,7 +46,7 @@ procedure Test.14 (#Derived_gen.0, #Derived_gen.1):
decref #Attr.12;
jump #Derived_gen.9;
in
jump Test.37 #Derived_gen.0 #Derived_gen.1;
jump Test.38 #Derived_gen.0 #Derived_gen.1;
procedure Test.2 ():
let Test.6 : Str = "Hello";
@ -62,17 +62,17 @@ procedure Test.2 ():
ret Test.19;
procedure Test.3 (Test.8):
let Test.54 : I64 = 0i64;
let Test.55 : Int1 = lowlevel Eq Test.54 Test.8;
if Test.55 then
let Test.57 : I64 = 0i64;
let Test.58 : Int1 = lowlevel Eq Test.57 Test.8;
if Test.58 then
let Test.27 : {} = Struct {};
let Test.26 : [<r>C {}, C I64 {}] = CallByName Test.4 Test.27;
ret Test.26;
else
let Test.49 : {} = Struct {};
let Test.33 : {} = CallByName Test.4 Test.49;
let Test.32 : [<r>C {}, C I64 {}] = CallByName Test.5 Test.33 Test.8;
ret Test.32;
let Test.52 : {} = Struct {};
let Test.34 : {} = CallByName Test.4 Test.52;
let Test.33 : [<r>C {}, C I64 {}] = CallByName Test.5 Test.34 Test.8;
ret Test.33;
procedure Test.4 (Test.10):
let Test.28 : [<r>C {}, C I64 {}] = TagId(0) Test.10;
@ -82,14 +82,14 @@ procedure Test.4 (Test.10):
ret Test.10;
procedure Test.5 (Test.16, Test.13):
let Test.35 : [<r>C {}, C I64 {}] = TagId(1) Test.13 Test.16;
ret Test.35;
let Test.36 : [<r>C {}, C I64 {}] = TagId(1) Test.13 Test.16;
ret Test.36;
procedure Test.9 (Test.44, Test.8):
let Test.48 : I64 = 1i64;
let Test.47 : I64 = CallByName Num.20 Test.8 Test.48;
let Test.46 : [<r>C {}, C I64 {}] = CallByName Test.3 Test.47;
ret Test.46;
procedure Test.9 (Test.47, Test.8):
let Test.51 : I64 = 1i64;
let Test.50 : I64 = CallByName Num.20 Test.8 Test.51;
let Test.49 : [<r>C {}, C I64 {}] = CallByName Test.3 Test.50;
ret Test.49;
procedure Test.0 ():
let Test.24 : I64 = 4i64;

18
crates/compiler/test_mono/generated/specialize_closures.txt
View file

@ -23,15 +23,15 @@ procedure Test.1 (Test.2, Test.3):
procedure Test.7 (Test.9, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.21 : I64 = CallByName Num.19 Test.9 Test.4;
ret Test.21;
let Test.24 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.23 : I64 = CallByName Num.19 Test.9 Test.24;
ret Test.23;
procedure Test.8 (Test.10, #Attr.12):
let Test.6 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
if Test.6 then
let Test.19 : I64 = CallByName Num.21 Test.10 Test.5;
let Test.21 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.20 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
if Test.21 then
let Test.19 : I64 = CallByName Num.21 Test.10 Test.20;
ret Test.19;
else
ret Test.10;
@ -45,8 +45,8 @@ procedure Test.0 ():
let Test.11 : I64 = CallByName Test.1 Test.12 Test.13;
ret Test.11;
in
let Test.20 : Int1 = CallByName Bool.2;
if Test.20 then
let Test.22 : Int1 = CallByName Bool.2;
if Test.22 then
let Test.16 : [C I64, C I64 Int1] = TagId(0) Test.4;
jump Test.17 Test.16;
else

14
crates/compiler/test_mono/generated/specialize_lowlevel.txt
View file

@ -11,13 +11,13 @@ procedure Num.21 (#Attr.2, #Attr.3):
ret Num.292;
procedure Test.6 (Test.8, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.18 : I64 = CallByName Num.19 Test.8 Test.4;
ret Test.18;
let Test.20 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.19 : I64 = CallByName Num.19 Test.8 Test.20;
ret Test.19;
procedure Test.7 (Test.9, #Attr.12):
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.16 : I64 = CallByName Num.21 Test.9 Test.5;
let Test.17 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.16 : I64 = CallByName Num.21 Test.9 Test.17;
ret Test.16;
procedure Test.0 ():
@ -36,8 +36,8 @@ procedure Test.0 ():
ret Test.10;
in
let Test.17 : Int1 = CallByName Bool.2;
if Test.17 then
let Test.18 : Int1 = CallByName Bool.2;
if Test.18 then
let Test.14 : [C I64, C I64] = TagId(0) Test.4;
jump Test.15 Test.14;
else

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

@ -1,18 +1,18 @@
procedure #Derived.0 (#Derived.1):
let #Derived_gen.10 : [C {}, C {}] = TagId(0) #Derived.1;
let #Derived_gen.9 : [C {}, C {}] = CallByName Encode.23 #Derived_gen.10;
ret #Derived_gen.9;
let #Derived_gen.11 : [C {}, C {}] = TagId(0) #Derived.1;
let #Derived_gen.10 : [C {}, C {}] = CallByName Encode.23 #Derived_gen.11;
ret #Derived_gen.10;
procedure #Derived.2 (#Derived.3, #Derived.4, #Attr.12):
let #Derived.1 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
joinpoint #Derived_gen.14 #Derived_gen.13:
let #Derived_gen.12 : List U8 = CallByName Encode.24 #Derived.3 #Derived_gen.13 #Derived.4;
ret #Derived_gen.12;
let #Derived_gen.19 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
joinpoint #Derived_gen.15 #Derived_gen.14:
let #Derived_gen.13 : List U8 = CallByName Encode.24 #Derived.3 #Derived_gen.14 #Derived.4;
ret #Derived_gen.13;
in
let #Derived_gen.16 : Str = "A";
let #Derived_gen.17 : List [] = Array [];
let #Derived_gen.15 : {Str, List []} = CallByName TotallyNotJson.32 #Derived_gen.16 #Derived_gen.17;
jump #Derived_gen.14 #Derived_gen.15;
let #Derived_gen.17 : Str = "A";
let #Derived_gen.18 : List [] = Array [];
let #Derived_gen.16 : {Str, List []} = CallByName TotallyNotJson.32 #Derived_gen.17 #Derived_gen.18;
jump #Derived_gen.15 #Derived_gen.16;
procedure #Derived.5 (#Derived.6):
let #Derived_gen.1 : [C {}, C {}] = TagId(1) #Derived.6;
@ -20,7 +20,7 @@ procedure #Derived.5 (#Derived.6):
ret #Derived_gen.0;
procedure #Derived.7 (#Derived.8, #Derived.9, #Attr.12):
let #Derived.6 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let #Derived_gen.9 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
joinpoint #Derived_gen.5 #Derived_gen.4:
let #Derived_gen.3 : List U8 = CallByName Encode.24 #Derived.8 #Derived_gen.4 #Derived.9;
ret #Derived_gen.3;
@ -127,7 +127,7 @@ procedure List.8 (#Attr.2, #Attr.3):
let List.614 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.614;
procedure List.86 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
procedure List.86 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24):
joinpoint List.564 List.148 List.149 List.150 List.151 List.152:
let List.566 : Int1 = CallByName Num.22 List.151 List.152;
if List.566 then
@ -140,9 +140,9 @@ procedure List.86 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_g
dec List.148;
ret List.149;
in
jump List.564 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
jump List.564 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
procedure List.86 (#Derived_gen.32, #Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36):
procedure List.86 (#Derived_gen.34, #Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38):
joinpoint List.604 List.148 List.149 List.150 List.151 List.152:
let List.606 : Int1 = CallByName Num.22 List.151 List.152;
if List.606 then
@ -155,7 +155,7 @@ procedure List.86 (#Derived_gen.32, #Derived_gen.33, #Derived_gen.34, #Derived_g
dec List.148;
ret List.149;
in
jump List.604 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
jump List.604 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38;
procedure Num.127 (#Attr.2):
let Num.311 : U8 = lowlevel NumIntCast #Attr.2;