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

moved all crates into seperate folder + related path fixes

Browse source
This commit is contained in:
Anton-4 2022-07-01 17:37:43 +02:00
parent 12ef03bb86
commit eee85fa45d
No known key found for this signature in database
GPG key ID: C954D6E0F9C0ABFD
1063 changed files with 92 additions and 93 deletions
Download patch file Download diff file Expand all files Collapse all files

4
crates/compiler/test_mono/generated/alias_variable.txt Normal file
View file

@ -0,0 +1,4 @@
procedure Test.0 ():
let Test.1 : I64 = 5i64;
let Test.3 : I64 = 3i64;
ret Test.3;

3
crates/compiler/test_mono/generated/alias_variable_and_return_it.txt Normal file
View file

@ -0,0 +1,3 @@
procedure Test.0 ():
let Test.2 : I64 = 5i64;
ret Test.2;

17
crates/compiler/test_mono/generated/aliased_polymorphic_closure.txt Normal file
View file

@ -0,0 +1,17 @@
procedure Test.2 (Test.6, #Attr.12):
let Test.1 : U8 = StructAtIndex 0 #Attr.12;
let Test.11 : {U8} = Struct {Test.1};
ret Test.11;
procedure Test.4 (Test.5, #Attr.12):
let Test.1 : U8 = StructAtIndex 0 #Attr.12;
ret Test.1;
procedure Test.0 ():
let Test.1 : U8 = 1i64;
let Test.8 : {} = Struct {};
let Test.10 : {} = Struct {};
let Test.14 : {U8} = Struct {Test.1};
let Test.9 : {U8} = CallByName Test.2 Test.10 Test.14;
let Test.7 : U8 = CallByName Test.4 Test.8 Test.9;
ret Test.7;

9
crates/compiler/test_mono/generated/branch_store_variable.txt Normal file
View file

@ -0,0 +1,9 @@
procedure Test.0 ():
let Test.2 : I64 = 0i64;
let Test.5 : I64 = 1i64;
let Test.6 : Int1 = lowlevel Eq Test.5 Test.2;
if Test.6 then
let Test.3 : I64 = 12i64;
ret Test.3;
else
ret Test.2;

20
crates/compiler/test_mono/generated/closure_in_list.txt Normal file
View file

@ -0,0 +1,20 @@
procedure List.6 (#Attr.2):
let List.152 : U64 = lowlevel ListLen #Attr.2;
ret List.152;
procedure Test.1 (Test.5):
let Test.2 : I64 = 41i64;
let Test.10 : {I64} = Struct {Test.2};
let Test.9 : List {I64} = Array [Test.10];
ret Test.9;
procedure Test.3 (Test.8, #Attr.12):
let Test.2 : I64 = StructAtIndex 0 #Attr.12;
ret Test.2;
procedure Test.0 ():
let Test.7 : {} = Struct {};
let Test.4 : List {I64} = CallByName Test.1 Test.7;
let Test.6 : U64 = CallByName List.6 Test.4;
dec Test.4;
ret Test.6;

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

@ -0,0 +1,13 @@
procedure Dict.1 ():
let Dict.28 : Dict [] [] = lowlevel DictEmpty ;
ret Dict.28;
procedure Dict.7 (#Attr.2):
let Dict.27 : U64 = lowlevel DictSize #Attr.2;
dec #Attr.2;
ret Dict.27;
procedure Test.0 ():
let Test.2 : Dict [] [] = CallByName Dict.1;
let Test.1 : U64 = CallByName Dict.7 Test.2;
ret Test.1;

43
crates/compiler/test_mono/generated/empty_list_of_function_type.txt Normal file
View file

@ -0,0 +1,43 @@
procedure List.2 (#Attr.2, #Attr.3):
let List.157 : U64 = lowlevel ListLen #Attr.2;
let List.154 : Int1 = lowlevel NumLt #Attr.3 List.157;
if List.154 then
let List.156 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.155 : [C {}, C {}] = Ok List.156;
ret List.155;
else
let List.153 : {} = Struct {};
let List.152 : [C {}, C {}] = Err List.153;
ret List.152;
procedure Test.2 (Test.6):
let Test.18 : Str = "bar";
ret Test.18;
procedure Test.0 ():
let Test.1 : List {} = Array [];
joinpoint Test.16 Test.3:
let Test.14 : U64 = 0i64;
let Test.7 : [C {}, C {}] = CallByName List.2 Test.3 Test.14;
dec Test.3;
let Test.11 : U8 = 1i64;
let Test.12 : U8 = GetTagId Test.7;
let Test.13 : Int1 = lowlevel Eq Test.11 Test.12;
if Test.13 then
let Test.5 : {} = UnionAtIndex (Id 1) (Index 0) Test.7;
let Test.9 : Str = "foo";
let Test.8 : Str = CallByName Test.2 Test.9;
dec Test.9;
ret Test.8;
else
let Test.10 : Str = "bad!";
ret Test.10;
in
let Test.19 : Int1 = false;
if Test.19 then
jump Test.16 Test.1;
else
dec Test.1;
let Test.17 : {} = Struct {};
let Test.15 : List {} = Array [Test.17];
jump Test.16 Test.15;

24
crates/compiler/test_mono/generated/encode.txt Normal file
View file

@ -0,0 +1,24 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.152 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.152;
procedure Test.20 (Test.22):
let Test.34 : {U8} = Struct {Test.22};
ret Test.34;
procedure Test.21 (Test.27):
let Test.33 : {U8} = CallByName Test.20 Test.27;
ret Test.33;
procedure Test.23 (Test.24, Test.35, #Attr.12):
let Test.22 : U8 = StructAtIndex 0 #Attr.12;
let Test.37 : List U8 = CallByName List.4 Test.24 Test.22;
ret Test.37;
procedure Test.0 ():
let Test.32 : U8 = 15i64;
let Test.28 : {U8} = CallByName Test.21 Test.32;
let Test.30 : List U8 = Array [];
let Test.31 : {} = Struct {};
let Test.29 : List U8 = CallByName Test.23 Test.30 Test.31 Test.28;
ret Test.29;

104
crates/compiler/test_mono/generated/encode_custom_type.txt Normal file
View file

@ -0,0 +1,104 @@
procedure Encode.22 (Encode.93):
ret Encode.93;
procedure Encode.22 (Encode.93):
ret Encode.93;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.107 : List U8 = CallByName Test.3 Encode.94 Encode.96;
ret Encode.107;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.114 : List U8 = CallByName Json.65 Encode.94 Encode.96 Encode.102;
ret Encode.114;
procedure Encode.25 (Encode.100, Encode.101):
let Encode.104 : List U8 = Array [];
let Encode.105 : {} = CallByName Test.2 Encode.100;
let Encode.103 : List U8 = CallByName Encode.23 Encode.104 Encode.105 Encode.101;
ret Encode.103;
procedure Json.1 ():
let Json.102 : {} = Struct {};
ret Json.102;
procedure Json.17 (Json.64):
let Json.104 : {Str} = Struct {Json.64};
let Json.103 : {Str} = CallByName Encode.22 Json.104;
ret Json.103;
procedure Json.65 (Json.66, Json.105, #Attr.12):
let Json.64 : Str = StructAtIndex 0 #Attr.12;
inc Json.64;
dec #Attr.12;
let Json.114 : I32 = 34i64;
let Json.113 : U8 = CallByName Num.122 Json.114;
let Json.111 : List U8 = CallByName List.4 Json.66 Json.113;
let Json.112 : List U8 = CallByName Str.12 Json.64;
let Json.108 : List U8 = CallByName List.8 Json.111 Json.112;
let Json.110 : I32 = 34i64;
let Json.109 : U8 = CallByName Num.122 Json.110;
let Json.107 : List U8 = CallByName List.4 Json.108 Json.109;
ret Json.107;
procedure List.4 (#Attr.2, #Attr.3):
let List.141 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.141;
procedure List.8 (#Attr.2, #Attr.3):
let List.142 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.142;
procedure Num.122 (#Attr.2):
let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.272;
procedure Str.12 (#Attr.2):
let Str.73 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.73;
procedure Str.9 (#Attr.2):
let #Attr.3 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
let Str.69 : Int1 = StructAtIndex 2 #Attr.3;
if Str.69 then
let Str.71 : Str = StructAtIndex 1 #Attr.3;
inc Str.71;
dec #Attr.3;
let Str.70 : [C {U64, U8}, C Str] = Ok Str.71;
ret Str.70;
else
let Str.67 : U8 = StructAtIndex 3 #Attr.3;
let Str.68 : U64 = StructAtIndex 0 #Attr.3;
dec #Attr.3;
let Str.66 : {U64, U8} = Struct {Str.68, Str.67};
let Str.65 : [C {U64, U8}, C Str] = Err Str.66;
ret Str.65;
procedure Test.2 (Test.8):
let Test.18 : {} = Struct {};
let Test.17 : {} = CallByName Encode.22 Test.18;
ret Test.17;
procedure Test.3 (Test.4, Test.5):
let Test.21 : Str = "Hello, World!\n";
let Test.20 : {Str} = CallByName Json.17 Test.21;
let Test.19 : List U8 = CallByName Encode.23 Test.4 Test.20 Test.5;
ret Test.19;
procedure Test.0 ():
let Test.15 : {} = Struct {};
let Test.16 : {} = CallByName Json.1;
let Test.14 : List U8 = CallByName Encode.25 Test.15 Test.16;
let Test.6 : [C {U64, U8}, C Str] = CallByName Str.9 Test.14;
let Test.11 : U8 = 1i64;
let Test.12 : U8 = GetTagId Test.6;
let Test.13 : Int1 = lowlevel Eq Test.11 Test.12;
if Test.13 then
let Test.7 : Str = UnionAtIndex (Id 1) (Index 0) Test.6;
inc Test.7;
dec Test.6;
ret Test.7;
else
dec Test.6;
let Test.10 : Str = "<bad>";
ret Test.10;

27
crates/compiler/test_mono/generated/factorial.txt Normal file
View file

@ -0,0 +1,27 @@
procedure Num.20 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.274;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.15, Test.16):
joinpoint Test.7 Test.2 Test.3:
let Test.13 : I64 = 0i64;
let Test.14 : Int1 = lowlevel Eq Test.13 Test.2;
if Test.14 then
ret Test.3;
else
let Test.12 : I64 = 1i64;
let Test.10 : I64 = CallByName Num.20 Test.2 Test.12;
let Test.11 : I64 = CallByName Num.21 Test.2 Test.3;
jump Test.7 Test.10 Test.11;
in
jump Test.7 Test.15 Test.16;
procedure Test.0 ():
let Test.5 : I64 = 10i64;
let Test.6 : I64 = 1i64;
let Test.4 : I64 = CallByName Test.1 Test.5 Test.6;
ret Test.4;

11
crates/compiler/test_mono/generated/fst.txt Normal file
View file

@ -0,0 +1,11 @@
procedure Test.1 (Test.2, Test.3):
inc Test.2;
ret Test.2;
procedure Test.0 ():
let Test.5 : List I64 = Array [1i64, 2i64, 3i64];
let Test.6 : List I64 = Array [3i64, 2i64, 1i64];
let Test.4 : List I64 = CallByName Test.1 Test.5 Test.6;
dec Test.6;
dec Test.5;
ret Test.4;

25
crates/compiler/test_mono/generated/guard_pattern_true.txt Normal file
View file

@ -0,0 +1,25 @@
procedure Test.1 (Test.3):
let Test.6 : I64 = 2i64;
joinpoint Test.11:
let Test.10 : I64 = 0i64;
ret Test.10;
in
let Test.13 : I64 = 2i64;
let Test.14 : Int1 = lowlevel Eq Test.13 Test.6;
if Test.14 then
joinpoint Test.8 Test.12:
if Test.12 then
let Test.7 : I64 = 42i64;
ret Test.7;
else
jump Test.11;
in
let Test.9 : Int1 = false;
jump Test.8 Test.9;
else
jump Test.11;
procedure Test.0 ():
let Test.5 : {} = Struct {};
let Test.4 : I64 = CallByName Test.1 Test.5;
ret Test.4;

30
crates/compiler/test_mono/generated/has_none.txt Normal file
View file

@ -0,0 +1,30 @@
procedure Test.4 (Test.30):
joinpoint Test.14 Test.5:
let Test.24 : Int1 = 1i64;
let Test.25 : Int1 = GetTagId Test.5;
let Test.26 : Int1 = lowlevel Eq Test.24 Test.25;
if Test.26 then
let Test.15 : Int1 = false;
ret Test.15;
else
let Test.20 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.5;
let Test.21 : U8 = 1i64;
let Test.22 : U8 = GetTagId Test.20;
let Test.23 : Int1 = lowlevel Eq Test.21 Test.22;
if Test.23 then
let Test.16 : Int1 = true;
ret Test.16;
else
let Test.8 : [<rnu><null>, C [C I64, C ] *self] = UnionAtIndex (Id 0) (Index 1) Test.5;
jump Test.14 Test.8;
in
jump Test.14 Test.30;
procedure Test.0 ():
let Test.29 : I64 = 3i64;
let Test.27 : [C I64, C ] = Just Test.29;
let Test.28 : [<rnu><null>, C [C I64, C ] *self] = Nil ;
let Test.13 : [<rnu><null>, C [C I64, C ] *self] = Cons Test.27 Test.28;
let Test.12 : Int1 = CallByName Test.4 Test.13;
dec Test.13;
ret Test.12;

22
crates/compiler/test_mono/generated/if_guard_bind_variable_false.txt Normal file
View file

@ -0,0 +1,22 @@
procedure Bool.7 (#Attr.2, #Attr.3):
let Bool.14 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.14;
procedure Test.1 (Test.3):
let Test.6 : I64 = 10i64;
joinpoint Test.8 Test.12:
if Test.12 then
let Test.7 : I64 = 0i64;
ret Test.7;
else
let Test.11 : I64 = 42i64;
ret Test.11;
in
let Test.10 : I64 = 5i64;
let Test.9 : Int1 = CallByName Bool.7 Test.6 Test.10;
jump Test.8 Test.9;
procedure Test.0 ():
let Test.5 : {} = Struct {};
let Test.4 : I64 = CallByName Test.1 Test.5;
ret Test.4;

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

@ -0,0 +1,13 @@
procedure Test.0 ():
let Test.6 : Int1 = true;
if Test.6 then
let Test.7 : I64 = 1i64;
ret Test.7;
else
let Test.4 : Int1 = false;
if Test.4 then
let Test.5 : I64 = 2i64;
ret Test.5;
else
let Test.3 : I64 = 3i64;
ret Test.3;

3
crates/compiler/test_mono/generated/ir_assignment.txt Normal file
View file

@ -0,0 +1,3 @@
procedure Test.0 ():
let Test.1 : I64 = 5i64;
ret Test.1;

19
crates/compiler/test_mono/generated/ir_int_add.txt Normal file
View file

@ -0,0 +1,19 @@
procedure List.6 (#Attr.2):
let List.152 : U64 = lowlevel ListLen #Attr.2;
ret List.152;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.0 ():
let Test.1 : List I64 = Array [1i64, 2i64];
let Test.7 : U64 = 5i64;
let Test.8 : U64 = 4i64;
let Test.5 : U64 = CallByName Num.19 Test.7 Test.8;
let Test.6 : U64 = 3i64;
let Test.3 : U64 = CallByName Num.19 Test.5 Test.6;
let Test.4 : U64 = CallByName List.6 Test.1;
dec Test.1;
let Test.2 : U64 = CallByName Num.19 Test.3 Test.4;
ret Test.2;

3
crates/compiler/test_mono/generated/ir_int_literal.txt Normal file
View file

@ -0,0 +1,3 @@
procedure Test.0 ():
let Test.1 : I64 = 5i64;
ret Test.1;

9
crates/compiler/test_mono/generated/ir_plus.txt Normal file
View file

@ -0,0 +1,9 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.2 : I64 = 1i64;
let Test.3 : I64 = 2i64;
let Test.1 : I64 = CallByName Num.19 Test.2 Test.3;
ret Test.1;

8
crates/compiler/test_mono/generated/ir_round.txt Normal file
View file

@ -0,0 +1,8 @@
procedure Num.45 (#Attr.2):
let Num.273 : I64 = lowlevel NumRound #Attr.2;
ret Num.273;
procedure Test.0 ():
let Test.2 : Float64 = 3.6f64;
let Test.1 : I64 = CallByName Num.45 Test.2;
ret Test.1;

9
crates/compiler/test_mono/generated/ir_two_defs.txt Normal file
View file

@ -0,0 +1,9 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.1 : I64 = 3i64;
let Test.2 : I64 = 4i64;
let Test.3 : I64 = CallByName Num.19 Test.1 Test.2;
ret Test.3;

25
crates/compiler/test_mono/generated/ir_when_idiv.txt Normal file
View file

@ -0,0 +1,25 @@
procedure Num.40 (#Attr.2, #Attr.3):
let Num.278 : I64 = 0i64;
let Num.275 : Int1 = lowlevel NotEq #Attr.3 Num.278;
if Num.275 then
let Num.277 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
let Num.276 : [C {}, C I64] = Ok Num.277;
ret Num.276;
else
let Num.274 : {} = Struct {};
let Num.273 : [C {}, C I64] = Err Num.274;
ret Num.273;
procedure Test.0 ():
let Test.8 : I64 = 1000i64;
let Test.9 : I64 = 10i64;
let Test.2 : [C {}, C I64] = CallByName Num.40 Test.8 Test.9;
let Test.5 : U8 = 1i64;
let Test.6 : U8 = GetTagId Test.2;
let Test.7 : Int1 = lowlevel Eq Test.5 Test.6;
if Test.7 then
let Test.1 : I64 = UnionAtIndex (Id 1) (Index 0) Test.2;
ret Test.1;
else
let Test.4 : I64 = -1i64;
ret Test.4;

18
crates/compiler/test_mono/generated/ir_when_just.txt Normal file
View file

@ -0,0 +1,18 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.10 : I64 = 41i64;
let Test.1 : [C I64, C ] = Just Test.10;
let Test.7 : U8 = 0i64;
let Test.8 : U8 = GetTagId Test.1;
let Test.9 : Int1 = lowlevel Eq Test.7 Test.8;
if Test.9 then
let Test.3 : I64 = UnionAtIndex (Id 0) (Index 0) Test.1;
let Test.5 : I64 = 1i64;
let Test.4 : I64 = CallByName Num.19 Test.3 Test.5;
ret Test.4;
else
let Test.6 : I64 = 1i64;
ret Test.6;

12
crates/compiler/test_mono/generated/ir_when_maybe.txt Normal file
View file

@ -0,0 +1,12 @@
procedure Test.0 ():
let Test.9 : I64 = 3i64;
let Test.3 : [C I64, C ] = Just Test.9;
let Test.6 : U8 = 0i64;
let Test.7 : U8 = GetTagId Test.3;
let Test.8 : Int1 = lowlevel Eq Test.6 Test.7;
if Test.8 then
let Test.2 : I64 = UnionAtIndex (Id 0) (Index 0) Test.3;
ret Test.2;
else
let Test.5 : I64 = 0i64;
ret Test.5;

6
crates/compiler/test_mono/generated/ir_when_record.txt Normal file
View file

@ -0,0 +1,6 @@
procedure Test.0 ():
let Test.4 : I64 = 1i64;
let Test.5 : Float64 = 3.14f64;
let Test.2 : {I64, Float64} = Struct {Test.4, Test.5};
let Test.1 : I64 = StructAtIndex 0 Test.2;
ret Test.1;

18
crates/compiler/test_mono/generated/ir_when_these.txt Normal file
View file

@ -0,0 +1,18 @@
procedure Test.0 ():
let Test.10 : I64 = 1i64;
let Test.11 : I64 = 2i64;
let Test.5 : [C I64, C I64 I64, C I64] = These Test.10 Test.11;
let Test.9 : U8 = GetTagId Test.5;
switch Test.9:
case 2:
let Test.2 : I64 = UnionAtIndex (Id 2) (Index 0) Test.5;
ret Test.2;
case 0:
let Test.3 : I64 = UnionAtIndex (Id 0) (Index 0) Test.5;
ret Test.3;
default:
let Test.4 : I64 = UnionAtIndex (Id 1) (Index 0) Test.5;
ret Test.4;

18
crates/compiler/test_mono/generated/is_nil.txt Normal file
View file

@ -0,0 +1,18 @@
procedure Test.3 (Test.4):
let Test.13 : Int1 = 1i64;
let Test.14 : Int1 = GetTagId Test.4;
let Test.15 : Int1 = lowlevel Eq Test.13 Test.14;
if Test.15 then
let Test.11 : Int1 = true;
ret Test.11;
else
let Test.12 : Int1 = false;
ret Test.12;
procedure Test.0 ():
let Test.16 : I64 = 2i64;
let Test.17 : [<rnu><null>, C I64 *self] = Nil ;
let Test.10 : [<rnu><null>, C I64 *self] = Cons Test.16 Test.17;
let Test.9 : Int1 = CallByName Test.3 Test.10;
dec Test.10;
ret Test.9;

19
crates/compiler/test_mono/generated/issue_2535_polymorphic_fields_referenced_in_list.txt Normal file
View file

@ -0,0 +1,19 @@
procedure Test.1 ():
let Test.11 : I64 = 2i64;
let Test.12 : U8 = 1i64;
let Test.10 : {I64, U8} = Struct {Test.11, Test.12};
ret Test.10;
procedure Test.1 ():
let Test.7 : I64 = 1i64;
let Test.8 : U8 = 2i64;
let Test.6 : {I64, U8} = Struct {Test.7, Test.8};
ret Test.6;
procedure Test.0 ():
let Test.9 : {I64, U8} = CallByName Test.1;
let Test.3 : U8 = StructAtIndex 1 Test.9;
let Test.5 : {I64, U8} = CallByName Test.1;
let Test.4 : U8 = StructAtIndex 1 Test.5;
let Test.2 : List U8 = Array [Test.3, Test.4];
ret Test.2;

40
crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt Normal file
View file

@ -0,0 +1,40 @@
procedure List.9 (#Attr.2):
let List.158 : U64 = 0i64;
let List.159 : U64 = lowlevel ListLen #Attr.2;
let List.154 : Int1 = lowlevel NotEq List.158 List.159;
if List.154 then
let List.157 : U64 = 0i64;
let List.156 : I64 = lowlevel ListGetUnsafe #Attr.2 List.157;
let List.155 : [C Int1, C I64] = Ok List.156;
ret List.155;
else
let List.153 : Int1 = true;
let List.152 : [C Int1, C I64] = Err List.153;
ret List.152;
procedure Str.27 (#Attr.2):
let #Attr.3 : {I64, U8} = lowlevel StrToNum #Attr.2;
let Str.70 : U8 = StructAtIndex 1 #Attr.3;
let Str.71 : U8 = 0i64;
let Str.67 : Int1 = lowlevel NumGt Str.70 Str.71;
if Str.67 then
let Str.69 : Int1 = false;
let Str.68 : [C Int1, C I64] = Err Str.69;
ret Str.68;
else
let Str.66 : I64 = StructAtIndex 0 #Attr.3;
let Str.65 : [C Int1, C I64] = Ok Str.66;
ret Str.65;
procedure Test.0 ():
let Test.4 : Int1 = true;
if Test.4 then
let Test.6 : List I64 = Array [];
let Test.5 : [C Int1, C I64] = CallByName List.9 Test.6;
dec Test.6;
ret Test.5;
else
let Test.3 : Str = "";
let Test.2 : [C Int1, C I64] = CallByName Str.27 Test.3;
dec Test.3;
ret Test.2;

7
crates/compiler/test_mono/generated/issue_2725_alias_polymorphic_lambda.txt Normal file
View file

@ -0,0 +1,7 @@
procedure Test.2 (Test.3):
ret Test.3;
procedure Test.0 ():
let Test.6 : I64 = 42i64;
let Test.5 : I64 = CallByName Test.2 Test.6;
ret Test.5;

6
crates/compiler/test_mono/generated/issue_2810.txt Normal file
View file

@ -0,0 +1,6 @@
procedure Test.0 ():
let Test.19 : [C [<rnnu>C [C *self, C ]], C ] = SystemTool ;
let Test.17 : [<rnnu>C [C *self, C ]] = Job Test.19;
let Test.16 : [C [<rnnu>C [C *self, C ]], C ] = FromJob Test.17;
let Test.7 : [<rnnu>C [C *self, C ]] = Job Test.16;
ret Test.7;

3
crates/compiler/test_mono/generated/issue_2811.txt Normal file
View file

@ -0,0 +1,3 @@
procedure Test.0 ():
let Test.6 : Str = "bash";
ret Test.6;

6
crates/compiler/test_mono/generated/let_with_record_pattern.txt Normal file
View file

@ -0,0 +1,6 @@
procedure Test.0 ():
let Test.4 : I64 = 2i64;
let Test.5 : Float64 = 3.14f64;
let Test.3 : {I64, Float64} = Struct {Test.4, Test.5};
let Test.1 : I64 = StructAtIndex 0 Test.3;
ret Test.1;

8
crates/compiler/test_mono/generated/let_with_record_pattern_list.txt Normal file
View file

@ -0,0 +1,8 @@
procedure Test.0 ():
let Test.4 : List I64 = Array [1i64, 3i64, 4i64];
let Test.5 : Float64 = 3.14f64;
let Test.3 : {List I64, Float64} = Struct {Test.4, Test.5};
let Test.1 : List I64 = StructAtIndex 0 Test.3;
inc Test.1;
dec Test.3;
ret Test.1;

5
crates/compiler/test_mono/generated/let_x_in_x.txt Normal file
View file

@ -0,0 +1,5 @@
procedure Test.0 ():
let Test.1 : I64 = 5i64;
let Test.2 : I64 = 1337i64;
let Test.4 : I64 = 17i64;
ret Test.2;

8
crates/compiler/test_mono/generated/let_x_in_x_indirect.txt Normal file
View file

@ -0,0 +1,8 @@
procedure Test.0 ():
let Test.1 : I64 = 5i64;
let Test.2 : I64 = 1337i64;
let Test.3 : I64 = 17i64;
let Test.5 : I64 = 1i64;
let Test.7 : {I64, I64} = Struct {Test.2, Test.3};
let Test.6 : I64 = StructAtIndex 0 Test.7;
ret Test.6;

25
crates/compiler/test_mono/generated/linked_list_length_twice.txt Normal file
View file

@ -0,0 +1,25 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Test.4 (Test.6):
let Test.16 : Int1 = 1i64;
let Test.17 : Int1 = GetTagId Test.6;
let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
if Test.18 then
let Test.12 : I64 = 0i64;
ret Test.12;
else
let Test.7 : [<rnu><null>, C I64 *self] = UnionAtIndex (Id 0) (Index 1) Test.6;
let Test.14 : I64 = 1i64;
let Test.15 : I64 = CallByName Test.4 Test.7;
let Test.13 : I64 = CallByName Num.19 Test.14 Test.15;
ret Test.13;
procedure Test.0 ():
let Test.3 : [<rnu><null>, C I64 *self] = Nil ;
let Test.9 : I64 = CallByName Test.4 Test.3;
let Test.10 : I64 = CallByName Test.4 Test.3;
dec Test.3;
let Test.8 : I64 = CallByName Num.19 Test.9 Test.10;
ret Test.8;

9
crates/compiler/test_mono/generated/list_append.txt Normal file
View file

@ -0,0 +1,9 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.152 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.152;
procedure Test.0 ():
let Test.2 : List I64 = Array [1i64];
let Test.3 : I64 = 2i64;
let Test.1 : List I64 = CallByName List.4 Test.2 Test.3;
ret Test.1;

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

@ -0,0 +1,13 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.152 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.152;
procedure Test.1 (Test.2):
let Test.6 : I64 = 42i64;
let Test.5 : List I64 = CallByName List.4 Test.2 Test.6;
ret Test.5;
procedure Test.0 ():
let Test.4 : List I64 = Array [1i64, 2i64];
let Test.3 : List I64 = CallByName Test.1 Test.4;
ret Test.3;

45
crates/compiler/test_mono/generated/list_cannot_update_inplace.txt Normal file
View file

@ -0,0 +1,45 @@
procedure List.3 (List.65, List.66, List.67):
let List.155 : {List I64, I64} = CallByName List.57 List.65 List.66 List.67;
let List.154 : List I64 = StructAtIndex 0 List.155;
inc List.154;
dec List.155;
ret List.154;
procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
let List.160 : U64 = lowlevel ListLen #Attr.2;
let List.158 : Int1 = lowlevel NumLt #Attr.3 List.160;
if List.158 then
let List.159 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.159;
else
let List.157 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret List.157;
procedure List.6 (#Attr.2):
let List.153 : U64 = lowlevel ListLen #Attr.2;
ret List.153;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 ():
let Test.8 : List I64 = Array [1i64, 2i64, 3i64];
ret Test.8;
procedure Test.2 (Test.3):
let Test.12 : U64 = 0i64;
let Test.13 : I64 = 0i64;
let Test.11 : List I64 = CallByName List.3 Test.3 Test.12 Test.13;
ret Test.11;
procedure Test.0 ():
let Test.10 : List I64 = CallByName Test.1;
let Test.9 : List I64 = CallByName Test.2 Test.10;
let Test.5 : U64 = CallByName List.6 Test.9;
dec Test.9;
let Test.7 : List I64 = CallByName Test.1;
let Test.6 : U64 = CallByName List.6 Test.7;
dec Test.7;
let Test.4 : U64 = CallByName Num.19 Test.5 Test.6;
ret Test.4;

23
crates/compiler/test_mono/generated/list_get.txt Normal file
View file

@ -0,0 +1,23 @@
procedure List.2 (#Attr.2, #Attr.3):
let List.157 : U64 = lowlevel ListLen #Attr.2;
let List.154 : Int1 = lowlevel NumLt #Attr.3 List.157;
if List.154 then
let List.156 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.155 : [C {}, C I64] = Ok List.156;
ret List.155;
else
let List.153 : {} = Struct {};
let List.152 : [C {}, C I64] = Err List.153;
ret List.152;
procedure Test.1 (Test.2):
let Test.6 : List I64 = Array [1i64, 2i64, 3i64];
let Test.7 : U64 = 0i64;
let Test.5 : [C {}, C I64] = CallByName List.2 Test.6 Test.7;
dec Test.6;
ret Test.5;
procedure Test.0 ():
let Test.4 : {} = Struct {};
let Test.3 : [C {}, C I64] = CallByName Test.1 Test.4;
ret Test.3;

21
crates/compiler/test_mono/generated/list_len.txt Normal file
View file

@ -0,0 +1,21 @@
procedure List.6 (#Attr.2):
let List.152 : U64 = lowlevel ListLen #Attr.2;
ret List.152;
procedure List.6 (#Attr.2):
let List.153 : U64 = lowlevel ListLen #Attr.2;
ret List.153;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.1 : List I64 = Array [1i64, 2i64, 3i64];
let Test.2 : List Float64 = Array [1f64];
let Test.4 : U64 = CallByName List.6 Test.1;
dec Test.1;
let Test.5 : U64 = CallByName List.6 Test.2;
dec Test.2;
let Test.3 : U64 = CallByName Num.19 Test.4 Test.5;
ret Test.3;

61
crates/compiler/test_mono/generated/list_map_closure_borrows.txt Normal file
View file

@ -0,0 +1,61 @@
procedure List.2 (#Attr.2, #Attr.3):
let List.157 : U64 = lowlevel ListLen #Attr.2;
let List.154 : Int1 = lowlevel NumLt #Attr.3 List.157;
if List.154 then
let List.156 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.155 : [C {}, C Str] = Ok List.156;
ret List.155;
else
let List.153 : {} = Struct {};
let List.152 : [C {}, C Str] = Err List.153;
ret List.152;
procedure List.5 (#Attr.2, #Attr.3):
let List.158 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
ret List.158;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.65 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.65;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.66 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.66;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";
let Test.22 : Str = "g";
let Test.20 : Str = CallByName Str.3 Test.21 Test.22;
dec Test.22;
let Test.19 : List Str = Array [Test.20];
ret Test.19;
procedure Test.2 ():
let Test.15 : List Str = CallByName Test.1;
let Test.16 : {} = Struct {};
let Test.14 : List Str = CallByName List.5 Test.15 Test.16;
dec Test.15;
ret Test.14;
procedure Test.3 (Test.4):
let Test.18 : U64 = 2i64;
let Test.17 : Str = CallByName Str.16 Test.4 Test.18;
ret Test.17;
procedure Test.0 ():
let Test.12 : List Str = CallByName Test.2;
let Test.13 : U64 = 0i64;
let Test.6 : [C {}, C Str] = CallByName List.2 Test.12 Test.13;
dec Test.12;
let Test.9 : U8 = 1i64;
let Test.10 : U8 = GetTagId Test.6;
let Test.11 : Int1 = lowlevel Eq Test.9 Test.10;
if Test.11 then
let Test.5 : Str = UnionAtIndex (Id 1) (Index 0) Test.6;
inc Test.5;
dec Test.6;
ret Test.5;
else
dec Test.6;
let Test.8 : Str = "Hello, World!\n";
ret Test.8;

60
crates/compiler/test_mono/generated/list_map_closure_owns.txt Normal file
View file

@ -0,0 +1,60 @@
procedure List.2 (#Attr.2, #Attr.3):
let List.157 : U64 = lowlevel ListLen #Attr.2;
let List.154 : Int1 = lowlevel NumLt #Attr.3 List.157;
if List.154 then
let List.156 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.155 : [C {}, C Str] = Ok List.156;
ret List.155;
else
let List.153 : {} = Struct {};
let List.152 : [C {}, C Str] = Err List.153;
ret List.152;
procedure List.5 (#Attr.2, #Attr.3):
inc #Attr.2;
let List.158 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
decref #Attr.2;
ret List.158;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.66 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.66;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";
let Test.22 : Str = "g";
let Test.20 : Str = CallByName Str.3 Test.21 Test.22;
dec Test.22;
let Test.19 : List Str = Array [Test.20];
ret Test.19;
procedure Test.2 ():
let Test.15 : List Str = CallByName Test.1;
let Test.16 : {} = Struct {};
let Test.14 : List Str = CallByName List.5 Test.15 Test.16;
dec Test.15;
ret Test.14;
procedure Test.3 (Test.4):
let Test.18 : Str = "!";
let Test.17 : Str = CallByName Str.3 Test.4 Test.18;
dec Test.18;
ret Test.17;
procedure Test.0 ():
let Test.12 : List Str = CallByName Test.2;
let Test.13 : U64 = 0i64;
let Test.6 : [C {}, C Str] = CallByName List.2 Test.12 Test.13;
dec Test.12;
let Test.9 : U8 = 1i64;
let Test.10 : U8 = GetTagId Test.6;
let Test.11 : Int1 = lowlevel Eq Test.9 Test.10;
if Test.11 then
let Test.5 : Str = UnionAtIndex (Id 1) (Index 0) Test.6;
inc Test.5;
dec Test.6;
ret Test.5;
else
dec Test.6;
let Test.8 : Str = "Hello, World!\n";
ret Test.8;

27
crates/compiler/test_mono/generated/list_pass_to_function.txt Normal file
View file

@ -0,0 +1,27 @@
procedure List.3 (List.65, List.66, List.67):
let List.153 : {List I64, I64} = CallByName List.57 List.65 List.66 List.67;
let List.152 : List I64 = StructAtIndex 0 List.153;
inc List.152;
dec List.153;
ret List.152;
procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
let List.158 : U64 = lowlevel ListLen #Attr.2;
let List.156 : Int1 = lowlevel NumLt #Attr.3 List.158;
if List.156 then
let List.157 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.157;
else
let List.155 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret List.155;
procedure Test.2 (Test.3):
let Test.6 : U64 = 0i64;
let Test.7 : I64 = 0i64;
let Test.5 : List I64 = CallByName List.3 Test.3 Test.6 Test.7;
ret Test.5;
procedure Test.0 ():
let Test.1 : List I64 = Array [1i64, 2i64, 3i64];
let Test.4 : List I64 = CallByName Test.2 Test.1;
ret Test.4;

22
crates/compiler/test_mono/generated/list_sort_asc.txt Normal file
View file

@ -0,0 +1,22 @@
procedure List.28 (#Attr.2, #Attr.3):
let List.155 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
let Bool.14 : Int1 = lowlevel ListIsUnique #Attr.2;
if Bool.14 then
ret List.155;
else
decref #Attr.2;
ret List.155;
procedure List.54 (List.99):
let List.153 : {} = Struct {};
let List.152 : List I64 = CallByName List.28 List.99 List.153;
ret List.152;
procedure Num.46 (#Attr.2, #Attr.3):
let Num.273 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.2 : List I64 = Array [4i64, 3i64, 2i64, 1i64];
let Test.1 : List I64 = CallByName List.54 Test.2;
ret Test.1;

9
crates/compiler/test_mono/generated/mk_pair_of.txt Normal file
View file

@ -0,0 +1,9 @@
procedure Test.1 (Test.2):
inc Test.2;
let Test.6 : {List I64, List I64} = Struct {Test.2, Test.2};
ret Test.6;
procedure Test.0 ():
let Test.5 : List I64 = Array [1i64, 2i64, 3i64];
let Test.4 : {List I64, List I64} = CallByName Test.1 Test.5;
ret Test.4;

20
crates/compiler/test_mono/generated/monomorphized_applied_tag.txt Normal file
View file

@ -0,0 +1,20 @@
procedure Test.2 (Test.4):
let Test.10 : U8 = 0i64;
let Test.11 : U8 = GetTagId Test.4;
let Test.12 : Int1 = lowlevel Eq Test.10 Test.11;
if Test.12 then
let Test.5 : Str = UnionAtIndex (Id 0) (Index 0) Test.4;
inc Test.5;
dec Test.4;
ret Test.5;
else
let Test.6 : Str = UnionAtIndex (Id 1) (Index 0) Test.4;
inc Test.6;
dec Test.4;
ret Test.6;
procedure Test.0 ():
let Test.13 : Str = "A";
let Test.1 : [C Str, C Str] = A Test.13;
let Test.7 : Str = CallByName Test.2 Test.1;
ret Test.7;

9
crates/compiler/test_mono/generated/monomorphized_floats.txt Normal file
View file

@ -0,0 +1,9 @@
procedure Test.2 (Test.3, Test.4):
let Test.7 : U64 = 18i64;
ret Test.7;
procedure Test.0 ():
let Test.6 : Float64 = 100f64;
let Test.1 : Float32 = 100f64;
let Test.5 : U64 = CallByName Test.2 Test.1 Test.6;
ret Test.5;

9
crates/compiler/test_mono/generated/monomorphized_ints.txt Normal file
View file

@ -0,0 +1,9 @@
procedure Test.2 (Test.3, Test.4):
let Test.7 : U64 = 18i64;
ret Test.7;
procedure Test.0 ():
let Test.6 : U32 = 100i64;
let Test.1 : U8 = 100i64;
let Test.5 : U64 = CallByName Test.2 Test.1 Test.6;
ret Test.5;

21
crates/compiler/test_mono/generated/monomorphized_ints_aliased.txt Normal file
View file

@ -0,0 +1,21 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.5 (Test.7, Test.8):
let Test.17 : U64 = 1i64;
ret Test.17;
procedure Test.6 (Test.7, Test.8):
let Test.14 : U64 = 1i64;
ret Test.14;
procedure Test.0 ():
let Test.15 : U8 = 100i64;
let Test.16 : U32 = 100i64;
let Test.10 : U64 = CallByName Test.5 Test.15 Test.16;
let Test.12 : U32 = 100i64;
let Test.13 : U8 = 100i64;
let Test.11 : U64 = CallByName Test.6 Test.12 Test.13;
let Test.9 : U64 = CallByName Num.19 Test.10 Test.11;
ret Test.9;

11
crates/compiler/test_mono/generated/monomorphized_list.txt Normal file
View file

@ -0,0 +1,11 @@
procedure Test.2 (Test.3, Test.4):
let Test.7 : U64 = 18i64;
ret Test.7;
procedure Test.0 ():
let Test.6 : List U16 = Array [1i64, 2i64, 3i64];
let Test.1 : List U8 = Array [1i64, 2i64, 3i64];
let Test.5 : U64 = CallByName Test.2 Test.1 Test.6;
dec Test.6;
dec Test.1;
ret Test.5;

9
crates/compiler/test_mono/generated/monomorphized_tag.txt Normal file
View file

@ -0,0 +1,9 @@
procedure Test.2 (Test.4, Test.5):
let Test.8 : U8 = 18i64;
ret Test.8;
procedure Test.0 ():
let Test.7 : U8 = 0u8;
let Test.1 : Int1 = false;
let Test.6 : U8 = CallByName Test.2 Test.1 Test.7;
ret Test.6;

10
crates/compiler/test_mono/generated/monomorphized_tag_with_aliased_args.txt Normal file
View file

@ -0,0 +1,10 @@
procedure Test.4 (Test.8):
let Test.10 : U64 = 1i64;
ret Test.10;
procedure Test.0 ():
let Test.1 : Int1 = false;
let Test.2 : Int1 = false;
let Test.3 : {Int1, Int1} = Struct {Test.1, Test.2};
let Test.9 : U64 = CallByName Test.4 Test.3;
ret Test.9;

15
crates/compiler/test_mono/generated/nested_closure.txt Normal file
View file

@ -0,0 +1,15 @@
procedure Test.1 (Test.5):
let Test.2 : I64 = 42i64;
let Test.3 : {I64} = Struct {Test.2};
ret Test.3;
procedure Test.3 (Test.9, #Attr.12):
let Test.2 : I64 = StructAtIndex 0 #Attr.12;
ret Test.2;
procedure Test.0 ():
let Test.8 : {} = Struct {};
let Test.4 : {I64} = CallByName Test.1 Test.8;
let Test.7 : {} = Struct {};
let Test.6 : I64 = CallByName Test.3 Test.7 Test.4;
ret Test.6;

30
crates/compiler/test_mono/generated/nested_pattern_match.txt Normal file
View file

@ -0,0 +1,30 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.19 : I64 = 41i64;
let Test.18 : [C I64, C ] = Just Test.19;
let Test.2 : [C [C I64, C ], C ] = Just Test.18;
joinpoint Test.15:
let Test.8 : I64 = 1i64;
ret Test.8;
in
let Test.13 : U8 = 0i64;
let Test.14 : U8 = GetTagId Test.2;
let Test.17 : Int1 = lowlevel Eq Test.13 Test.14;
if Test.17 then
let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.11 : U8 = 0i64;
let Test.12 : U8 = GetTagId Test.10;
let Test.16 : Int1 = lowlevel Eq Test.11 Test.12;
if Test.16 then
let Test.9 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.9;
let Test.7 : I64 = 1i64;
let Test.6 : I64 = CallByName Num.19 Test.5 Test.7;
ret Test.6;
else
jump Test.15;
else
jump Test.15;

3
crates/compiler/test_mono/generated/one_element_tag.txt Normal file
View file

@ -0,0 +1,3 @@
procedure Test.0 ():
let Test.4 : I64 = 2i64;
ret Test.4;

8
crates/compiler/test_mono/generated/opaque_assign_to_symbol.txt Normal file
View file

@ -0,0 +1,8 @@
procedure Test.3 (Test.4):
let Test.8 : [C {}, C U8] = Ok Test.4;
ret Test.8;
procedure Test.0 ():
let Test.7 : U8 = 98i64;
let Test.6 : [C {}, C U8] = CallByName Test.3 Test.7;
ret Test.6;

42
crates/compiler/test_mono/generated/optional_when.txt Normal file
View file

@ -0,0 +1,42 @@
procedure Num.21 (#Attr.2, #Attr.3):
let Num.275 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.275;
procedure Test.1 (Test.6):
let Test.21 : Int1 = false;
let Test.22 : Int1 = lowlevel Eq Test.21 Test.6;
if Test.22 then
let Test.8 : I64 = 3i64;
ret Test.8;
else
let Test.10 : I64 = 5i64;
ret Test.10;
procedure Test.1 (Test.6):
let Test.27 : Int1 = StructAtIndex 1 Test.6;
let Test.28 : Int1 = false;
let Test.29 : Int1 = lowlevel Eq Test.28 Test.27;
if Test.29 then
let Test.8 : I64 = StructAtIndex 0 Test.6;
ret Test.8;
else
let Test.10 : I64 = StructAtIndex 0 Test.6;
ret Test.10;
procedure Test.0 ():
let Test.35 : I64 = 7i64;
let Test.36 : Int1 = false;
let Test.34 : {I64, Int1} = Struct {Test.35, Test.36};
let Test.2 : I64 = CallByName Test.1 Test.34;
let Test.33 : Int1 = false;
let Test.3 : I64 = CallByName Test.1 Test.33;
let Test.30 : I64 = 11i64;
let Test.31 : Int1 = true;
let Test.24 : {I64, Int1} = Struct {Test.30, Test.31};
let Test.4 : I64 = CallByName Test.1 Test.24;
let Test.23 : Int1 = true;
let Test.5 : I64 = CallByName Test.1 Test.23;
let Test.17 : I64 = CallByName Num.21 Test.2 Test.3;
let Test.16 : I64 = CallByName Num.21 Test.17 Test.4;
let Test.15 : I64 = CallByName Num.21 Test.16 Test.5;
ret Test.15;

6
crates/compiler/test_mono/generated/peano.txt Normal file
View file

@ -0,0 +1,6 @@
procedure Test.0 ():
let Test.11 : [<rnu><null>, C *self] = Z ;
let Test.10 : [<rnu><null>, C *self] = S Test.11;
let Test.9 : [<rnu><null>, C *self] = S Test.10;
let Test.3 : [<rnu><null>, C *self] = S Test.9;
ret Test.3;

15
crates/compiler/test_mono/generated/peano1.txt Normal file
View file

@ -0,0 +1,15 @@
procedure Test.0 ():
let Test.15 : [<rnu><null>, C *self] = Z ;
let Test.14 : [<rnu><null>, C *self] = S Test.15;
let Test.13 : [<rnu><null>, C *self] = S Test.14;
let Test.3 : [<rnu><null>, C *self] = S Test.13;
let Test.10 : Int1 = 1i64;
let Test.11 : Int1 = GetTagId Test.3;
dec Test.3;
let Test.12 : Int1 = lowlevel Eq Test.10 Test.11;
if Test.12 then
let Test.8 : I64 = 0i64;
ret Test.8;
else
let Test.9 : I64 = 1i64;
ret Test.9;

26
crates/compiler/test_mono/generated/peano2.txt Normal file
View file

@ -0,0 +1,26 @@
procedure Test.0 ():
let Test.21 : [<rnu><null>, C *self] = Z ;
let Test.20 : [<rnu><null>, C *self] = S Test.21;
let Test.19 : [<rnu><null>, C *self] = S Test.20;
let Test.3 : [<rnu><null>, C *self] = S Test.19;
let Test.16 : Int1 = 0i64;
let Test.17 : Int1 = GetTagId Test.3;
let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
if Test.18 then
let Test.12 : [<rnu><null>, C *self] = UnionAtIndex (Id 0) (Index 0) Test.3;
inc Test.12;
dec Test.3;
let Test.13 : Int1 = 0i64;
let Test.14 : Int1 = GetTagId Test.12;
dec Test.12;
let Test.15 : Int1 = lowlevel Eq Test.13 Test.14;
if Test.15 then
let Test.8 : I64 = 1i64;
ret Test.8;
else
let Test.9 : I64 = 0i64;
ret Test.9;
else
dec Test.3;
let Test.10 : I64 = 0i64;
ret Test.10;

41
crates/compiler/test_mono/generated/quicksort_help.txt Normal file
View file

@ -0,0 +1,41 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.274;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Test.1 (Test.24, Test.25, Test.26):
joinpoint Test.12 Test.2 Test.3 Test.4:
let Test.14 : Int1 = CallByName Num.22 Test.3 Test.4;
if Test.14 then
dec Test.2;
let Test.23 : List [] = Array [];
let Test.22 : I64 = 0i64;
let Test.21 : {I64, List []} = Struct {Test.22, Test.23};
let Test.5 : I64 = StructAtIndex 0 Test.21;
let Test.6 : List [] = StructAtIndex 1 Test.21;
inc Test.6;
dec Test.21;
let Test.20 : I64 = 1i64;
let Test.19 : I64 = CallByName Num.20 Test.5 Test.20;
let Test.16 : List I64 = CallByName Test.1 Test.6 Test.3 Test.19;
let Test.18 : I64 = 1i64;
let Test.17 : I64 = CallByName Num.19 Test.5 Test.18;
jump Test.12 Test.16 Test.17 Test.4;
else
ret Test.2;
in
jump Test.12 Test.24 Test.25 Test.26;
procedure Test.0 ():
let Test.9 : List I64 = Array [];
let Test.10 : I64 = 0i64;
let Test.11 : I64 = 0i64;
let Test.8 : List I64 = CallByName Test.1 Test.9 Test.10 Test.11;
ret Test.8;

69
crates/compiler/test_mono/generated/quicksort_swap.txt Normal file
View file

@ -0,0 +1,69 @@
procedure List.2 (#Attr.2, #Attr.3):
let List.169 : U64 = lowlevel ListLen #Attr.2;
let List.166 : Int1 = lowlevel NumLt #Attr.3 List.169;
if List.166 then
let List.168 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.167 : [C {}, C I64] = Ok List.168;
ret List.167;
else
let List.165 : {} = Struct {};
let List.164 : [C {}, C I64] = Err List.165;
ret List.164;
procedure List.3 (List.65, List.66, List.67):
let List.156 : {List I64, I64} = CallByName List.57 List.65 List.66 List.67;
let List.155 : List I64 = StructAtIndex 0 List.156;
inc List.155;
dec List.156;
ret List.155;
procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
let List.173 : U64 = lowlevel ListLen #Attr.2;
let List.171 : Int1 = lowlevel NumLt #Attr.3 List.173;
if List.171 then
let List.172 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.172;
else
let List.170 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret List.170;
procedure Test.1 (Test.2):
let Test.28 : U64 = 0i64;
let Test.26 : [C {}, C I64] = CallByName List.2 Test.2 Test.28;
let Test.27 : U64 = 0i64;
let Test.25 : [C {}, C I64] = CallByName List.2 Test.2 Test.27;
let Test.8 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.25, Test.26};
joinpoint Test.22:
let Test.13 : List I64 = Array [];
ret Test.13;
in
let Test.19 : [C {}, C I64] = StructAtIndex 1 Test.8;
let Test.20 : U8 = 1i64;
let Test.21 : U8 = GetTagId Test.19;
let Test.24 : Int1 = lowlevel Eq Test.20 Test.21;
if Test.24 then
let Test.16 : [C {}, C I64] = StructAtIndex 0 Test.8;
let Test.17 : U8 = 1i64;
let Test.18 : U8 = GetTagId Test.16;
let Test.23 : Int1 = lowlevel Eq Test.17 Test.18;
if Test.23 then
let Test.15 : [C {}, C I64] = StructAtIndex 0 Test.8;
let Test.4 : I64 = UnionAtIndex (Id 1) (Index 0) Test.15;
let Test.14 : [C {}, C I64] = StructAtIndex 1 Test.8;
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) Test.14;
let Test.12 : U64 = 0i64;
let Test.10 : List I64 = CallByName List.3 Test.2 Test.12 Test.5;
let Test.11 : U64 = 0i64;
let Test.9 : List I64 = CallByName List.3 Test.10 Test.11 Test.4;
ret Test.9;
else
dec Test.2;
jump Test.22;
else
dec Test.2;
jump Test.22;
procedure Test.0 ():
let Test.7 : List I64 = Array [1i64, 2i64];
let Test.6 : List I64 = CallByName Test.1 Test.7;
ret Test.6;

16
crates/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt Normal file
View file

@ -0,0 +1,16 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.4):
let Test.2 : I64 = StructAtIndex 0 Test.4;
let Test.3 : I64 = StructAtIndex 1 Test.4;
let Test.7 : I64 = CallByName Num.19 Test.2 Test.3;
ret Test.7;
procedure Test.0 ():
let Test.8 : I64 = 4i64;
let Test.9 : I64 = 9i64;
let Test.6 : {I64, I64} = Struct {Test.8, Test.9};
let Test.5 : I64 = CallByName Test.1 Test.6;
ret Test.5;

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

@ -0,0 +1,13 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.4):
let Test.2 : I64 = 10i64;
let Test.7 : I64 = CallByName Num.19 Test.2 Test.4;
ret Test.7;
procedure Test.0 ():
let Test.8 : I64 = 9i64;
let Test.5 : I64 = CallByName Test.1 Test.8;
ret Test.5;

16
crates/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt Normal file
View file

@ -0,0 +1,16 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.2):
let Test.3 : I64 = StructAtIndex 0 Test.2;
let Test.4 : I64 = StructAtIndex 1 Test.2;
let Test.7 : I64 = CallByName Num.19 Test.3 Test.4;
ret Test.7;
procedure Test.0 ():
let Test.8 : I64 = 4i64;
let Test.9 : I64 = 9i64;
let Test.6 : {I64, I64} = Struct {Test.8, Test.9};
let Test.5 : I64 = CallByName Test.1 Test.6;
ret Test.5;

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

@ -0,0 +1,13 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.2):
let Test.3 : I64 = 10i64;
let Test.7 : I64 = CallByName Num.19 Test.3 Test.2;
ret Test.7;
procedure Test.0 ():
let Test.8 : I64 = 9i64;
let Test.5 : I64 = CallByName Test.1 Test.8;
ret Test.5;

67
crates/compiler/test_mono/generated/rigids.txt Normal file
View file

@ -0,0 +1,67 @@
procedure List.2 (#Attr.2, #Attr.3):
let List.169 : U64 = lowlevel ListLen #Attr.2;
let List.166 : Int1 = lowlevel NumLt #Attr.3 List.169;
if List.166 then
let List.168 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
let List.167 : [C {}, C I64] = Ok List.168;
ret List.167;
else
let List.165 : {} = Struct {};
let List.164 : [C {}, C I64] = Err List.165;
ret List.164;
procedure List.3 (List.65, List.66, List.67):
let List.156 : {List I64, I64} = CallByName List.57 List.65 List.66 List.67;
let List.155 : List I64 = StructAtIndex 0 List.156;
inc List.155;
dec List.156;
ret List.155;
procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
let List.173 : U64 = lowlevel ListLen #Attr.2;
let List.171 : Int1 = lowlevel NumLt #Attr.3 List.173;
if List.171 then
let List.172 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.172;
else
let List.170 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
ret List.170;
procedure Test.1 (Test.2, Test.3, Test.4):
let Test.29 : [C {}, C I64] = CallByName List.2 Test.4 Test.3;
let Test.28 : [C {}, C I64] = CallByName List.2 Test.4 Test.2;
let Test.13 : {[C {}, C I64], [C {}, C I64]} = Struct {Test.28, Test.29};
joinpoint Test.25:
let Test.16 : List I64 = Array [];
ret Test.16;
in
let Test.22 : [C {}, C I64] = StructAtIndex 1 Test.13;
let Test.23 : U8 = 1i64;
let Test.24 : U8 = GetTagId Test.22;
let Test.27 : Int1 = lowlevel Eq Test.23 Test.24;
if Test.27 then
let Test.19 : [C {}, C I64] = StructAtIndex 0 Test.13;
let Test.20 : U8 = 1i64;
let Test.21 : U8 = GetTagId Test.19;
let Test.26 : Int1 = lowlevel Eq Test.20 Test.21;
if Test.26 then
let Test.18 : [C {}, C I64] = StructAtIndex 0 Test.13;
let Test.6 : I64 = UnionAtIndex (Id 1) (Index 0) Test.18;
let Test.17 : [C {}, C I64] = StructAtIndex 1 Test.13;
let Test.8 : I64 = UnionAtIndex (Id 1) (Index 0) Test.17;
let Test.15 : List I64 = CallByName List.3 Test.4 Test.2 Test.8;
let Test.14 : List I64 = CallByName List.3 Test.15 Test.3 Test.6;
ret Test.14;
else
dec Test.4;
jump Test.25;
else
dec Test.4;
jump Test.25;
procedure Test.0 ():
let Test.10 : U64 = 0i64;
let Test.11 : U64 = 0i64;
let Test.12 : List I64 = Array [1i64];
let Test.9 : List I64 = CallByName Test.1 Test.10 Test.11 Test.12;
ret Test.9;

8
crates/compiler/test_mono/generated/simple_if.txt Normal file
View file

@ -0,0 +1,8 @@
procedure Test.0 ():
let Test.3 : Int1 = true;
if Test.3 then
let Test.4 : I64 = 1i64;
ret Test.4;
else
let Test.2 : I64 = 2i64;
ret Test.2;

53
crates/compiler/test_mono/generated/somehow_drops_definitions.txt Normal file
View file

@ -0,0 +1,53 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 ():
let Test.26 : I64 = 1i64;
ret Test.26;
procedure Test.2 ():
let Test.22 : I64 = 2i64;
ret Test.22;
procedure Test.3 (Test.6):
let Test.25 : I64 = CallByName Test.1;
let Test.24 : I64 = CallByName Num.19 Test.6 Test.25;
ret Test.24;
procedure Test.4 (Test.7):
let Test.21 : I64 = CallByName Test.2;
let Test.20 : I64 = CallByName Num.21 Test.7 Test.21;
ret Test.20;
procedure Test.5 (Test.8, Test.9):
joinpoint Test.15 Test.14:
ret Test.14;
in
switch Test.8:
case 0:
let Test.16 : I64 = CallByName Test.3 Test.9;
jump Test.15 Test.16;
default:
let Test.17 : I64 = CallByName Test.4 Test.9;
jump Test.15 Test.17;
procedure Test.0 ():
joinpoint Test.19 Test.12:
let Test.13 : I64 = 42i64;
let Test.11 : I64 = CallByName Test.5 Test.12 Test.13;
ret Test.11;
in
let Test.23 : Int1 = true;
if Test.23 then
let Test.3 : Int1 = false;
jump Test.19 Test.3;
else
let Test.4 : Int1 = true;
jump Test.19 Test.4;

7
crates/compiler/test_mono/generated/specialize_ability_call.txt Normal file
View file

@ -0,0 +1,7 @@
procedure Test.7 (Test.9):
ret Test.9;
procedure Test.0 ():
let Test.11 : U64 = 1234i64;
let Test.10 : U64 = CallByName Test.7 Test.11;
ret Test.10;

53
crates/compiler/test_mono/generated/specialize_closures.txt Normal file
View file

@ -0,0 +1,53 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.2, Test.3):
let Test.17 : U8 = GetTagId Test.2;
joinpoint Test.18 Test.16:
ret Test.16;
in
switch Test.17:
case 0:
let Test.19 : I64 = CallByName Test.7 Test.3 Test.2;
jump Test.18 Test.19;
default:
let Test.20 : I64 = CallByName Test.8 Test.3 Test.2;
jump Test.18 Test.20;
procedure Test.7 (Test.10, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.26 : I64 = CallByName Num.19 Test.10 Test.4;
ret Test.26;
procedure Test.8 (Test.11, #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.24 : I64 = CallByName Num.21 Test.11 Test.5;
ret Test.24;
else
ret Test.11;
procedure Test.0 ():
let Test.4 : I64 = 1i64;
let Test.5 : I64 = 2i64;
let Test.6 : Int1 = true;
joinpoint Test.22 Test.14:
let Test.15 : I64 = 42i64;
let Test.13 : I64 = CallByName Test.1 Test.14 Test.15;
ret Test.13;
in
let Test.25 : Int1 = true;
if Test.25 then
let Test.7 : [C I64, C I64 Int1] = ClosureTag(Test.7) Test.4;
jump Test.22 Test.7;
else
let Test.8 : [C I64, C I64 Int1] = ClosureTag(Test.8) Test.5 Test.6;
jump Test.22 Test.8;

44
crates/compiler/test_mono/generated/specialize_lowlevel.txt Normal file
View file

@ -0,0 +1,44 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
procedure Test.6 (Test.8, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.22 : I64 = CallByName Num.19 Test.8 Test.4;
ret Test.22;
procedure Test.7 (Test.9, #Attr.12):
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.20 : I64 = CallByName Num.21 Test.9 Test.5;
ret Test.20;
procedure Test.0 ():
let Test.4 : I64 = 1i64;
let Test.5 : I64 = 2i64;
let Test.12 : I64 = 42i64;
joinpoint Test.19 Test.13:
let Test.14 : U8 = GetTagId Test.13;
joinpoint Test.15 Test.11:
ret Test.11;
in
switch Test.14:
case 0:
let Test.16 : I64 = CallByName Test.6 Test.12 Test.13;
jump Test.15 Test.16;
default:
let Test.17 : I64 = CallByName Test.7 Test.12 Test.13;
jump Test.15 Test.17;
in
let Test.21 : Int1 = true;
if Test.21 then
let Test.6 : [C I64, C I64] = ClosureTag(Test.6) Test.4;
jump Test.19 Test.6;
else
let Test.7 : [C I64, C I64] = ClosureTag(Test.7) Test.5;
jump Test.19 Test.7;

27
crates/compiler/test_mono/generated/tail_call_elimination.txt Normal file
View file

@ -0,0 +1,27 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.274;
procedure Test.1 (Test.15, Test.16):
joinpoint Test.7 Test.2 Test.3:
let Test.13 : I64 = 0i64;
let Test.14 : Int1 = lowlevel Eq Test.13 Test.2;
if Test.14 then
ret Test.3;
else
let Test.12 : I64 = 1i64;
let Test.10 : I64 = CallByName Num.20 Test.2 Test.12;
let Test.11 : I64 = CallByName Num.19 Test.2 Test.3;
jump Test.7 Test.10 Test.11;
in
jump Test.7 Test.15 Test.16;
procedure Test.0 ():
let Test.5 : I64 = 1000000i64;
let Test.6 : I64 = 0i64;
let Test.4 : I64 = CallByName Test.1 Test.5 Test.6;
ret Test.4;

43
crates/compiler/test_mono/generated/tail_call_with_different_layout.txt Normal file
View file

@ -0,0 +1,43 @@
procedure Test.1 (Test.2, Test.3):
let Test.12 : {U8, {}} = Struct {Test.2, Test.3};
ret Test.12;
procedure Test.1 (Test.2, Test.3):
let Test.21 : {U16, {}} = Struct {Test.2, Test.3};
ret Test.21;
procedure Test.4 (Test.13, #Attr.12):
let Test.3 : {} = StructAtIndex 1 #Attr.12;
let Test.2 : U16 = StructAtIndex 0 #Attr.12;
let Test.5 : {} = CallByName Test.7 Test.2;
let Test.25 : {} = Struct {};
let Test.24 : Str = CallByName Test.8 Test.25;
ret Test.24;
procedure Test.4 (Test.13, #Attr.12):
let Test.3 : {} = StructAtIndex 1 #Attr.12;
let Test.2 : U8 = StructAtIndex 0 #Attr.12;
let Test.5 : {U16, {}} = CallByName Test.6 Test.2;
let Test.16 : {} = Struct {};
let Test.15 : Str = CallByName Test.4 Test.16 Test.5;
ret Test.15;
procedure Test.6 (Test.17):
let Test.19 : U16 = 1i64;
let Test.20 : {} = Struct {};
let Test.18 : {U16, {}} = CallByName Test.1 Test.19 Test.20;
ret Test.18;
procedure Test.7 (Test.26):
let Test.27 : {} = Struct {};
ret Test.27;
procedure Test.8 (Test.28):
let Test.29 : Str = "";
ret Test.29;
procedure Test.0 ():
let Test.10 : U8 = 1i64;
let Test.11 : {} = Struct {};
let Test.9 : {U8, {}} = CallByName Test.1 Test.10 Test.11;
ret Test.9;

43
crates/compiler/test_mono/generated/tail_call_with_same_layout_different_lambda_sets.txt Normal file
View file

@ -0,0 +1,43 @@
procedure Test.1 (Test.2, Test.3):
let Test.12 : {U8, {}} = Struct {Test.2, Test.3};
ret Test.12;
procedure Test.1 (Test.2, Test.3):
let Test.21 : {U8, {}} = Struct {Test.2, Test.3};
ret Test.21;
procedure Test.4 (Test.13, #Attr.12):
let Test.3 : {} = StructAtIndex 1 #Attr.12;
let Test.2 : U8 = StructAtIndex 0 #Attr.12;
let Test.5 : {U8, {}} = CallByName Test.6 Test.2;
let Test.16 : {} = Struct {};
let Test.15 : Str = CallByName Test.4 Test.16 Test.5;
ret Test.15;
procedure Test.4 (Test.13, #Attr.12):
let Test.3 : {} = StructAtIndex 1 #Attr.12;
let Test.2 : U8 = StructAtIndex 0 #Attr.12;
let Test.5 : {} = CallByName Test.7 Test.2;
let Test.25 : {} = Struct {};
let Test.24 : Str = CallByName Test.8 Test.25;
ret Test.24;
procedure Test.6 (Test.17):
let Test.19 : U8 = 1i64;
let Test.20 : {} = Struct {};
let Test.18 : {U8, {}} = CallByName Test.1 Test.19 Test.20;
ret Test.18;
procedure Test.7 (Test.26):
let Test.27 : {} = Struct {};
ret Test.27;
procedure Test.8 (Test.28):
let Test.29 : Str = "";
ret Test.29;
procedure Test.0 ():
let Test.10 : U8 = 1i64;
let Test.11 : {} = Struct {};
let Test.9 : {U8, {}} = CallByName Test.1 Test.10 Test.11;
ret Test.9;

23
crates/compiler/test_mono/generated/when_joinpoint.txt Normal file
View file

@ -0,0 +1,23 @@
procedure Test.1 (Test.5):
let Test.2 : U8 = 0u8;
joinpoint Test.9 Test.3:
ret Test.3;
in
switch Test.2:
case 1:
let Test.10 : I64 = 1i64;
jump Test.9 Test.10;
case 2:
let Test.11 : I64 = 2i64;
jump Test.9 Test.11;
default:
let Test.12 : I64 = 3i64;
jump Test.9 Test.12;
procedure Test.0 ():
let Test.7 : {} = Struct {};
let Test.6 : I64 = CallByName Test.1 Test.7;
ret Test.6;

30
crates/compiler/test_mono/generated/when_nested_maybe.txt Normal file
View file

@ -0,0 +1,30 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.19 : I64 = 41i64;
let Test.18 : [C I64, C ] = Just Test.19;
let Test.2 : [C [C I64, C ], C ] = Just Test.18;
joinpoint Test.15:
let Test.8 : I64 = 1i64;
ret Test.8;
in
let Test.13 : U8 = 0i64;
let Test.14 : U8 = GetTagId Test.2;
let Test.17 : Int1 = lowlevel Eq Test.13 Test.14;
if Test.17 then
let Test.10 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.11 : U8 = 0i64;
let Test.12 : U8 = GetTagId Test.10;
let Test.16 : Int1 = lowlevel Eq Test.11 Test.12;
if Test.16 then
let Test.9 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.2;
let Test.5 : I64 = UnionAtIndex (Id 0) (Index 0) Test.9;
let Test.7 : I64 = 1i64;
let Test.6 : I64 = CallByName Num.19 Test.5 Test.7;
ret Test.6;
else
jump Test.15;
else
jump Test.15;

9
crates/compiler/test_mono/generated/when_on_record.txt Normal file
View file

@ -0,0 +1,9 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.5 : I64 = 2i64;
let Test.4 : I64 = 3i64;
let Test.3 : I64 = CallByName Num.19 Test.5 Test.4;
ret Test.3;

27
crates/compiler/test_mono/generated/when_on_result.txt Normal file
View file

@ -0,0 +1,27 @@
procedure Test.1 (Test.5):
let Test.19 : I64 = 2i64;
let Test.2 : [C I64, C I64] = Ok Test.19;
joinpoint Test.9 Test.3:
ret Test.3;
in
let Test.16 : U8 = 1i64;
let Test.17 : U8 = GetTagId Test.2;
let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
if Test.18 then
let Test.13 : I64 = UnionAtIndex (Id 1) (Index 0) Test.2;
let Test.14 : I64 = 3i64;
let Test.15 : Int1 = lowlevel Eq Test.14 Test.13;
if Test.15 then
let Test.10 : I64 = 1i64;
jump Test.9 Test.10;
else
let Test.11 : I64 = 2i64;
jump Test.9 Test.11;
else
let Test.12 : I64 = 3i64;
jump Test.9 Test.12;
procedure Test.0 ():
let Test.7 : {} = Struct {};
let Test.6 : I64 = CallByName Test.1 Test.7;
ret Test.6;

28
crates/compiler/test_mono/generated/when_on_two_values.txt Normal file
View file

@ -0,0 +1,28 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.15 : I64 = 3i64;
let Test.14 : I64 = 2i64;
let Test.4 : {I64, I64} = Struct {Test.14, Test.15};
joinpoint Test.11:
let Test.2 : I64 = StructAtIndex 0 Test.4;
let Test.3 : I64 = StructAtIndex 1 Test.4;
let Test.6 : I64 = CallByName Num.19 Test.2 Test.3;
ret Test.6;
in
let Test.9 : I64 = StructAtIndex 1 Test.4;
let Test.10 : I64 = 3i64;
let Test.13 : Int1 = lowlevel Eq Test.10 Test.9;
if Test.13 then
let Test.7 : I64 = StructAtIndex 0 Test.4;
let Test.8 : I64 = 4i64;
let Test.12 : Int1 = lowlevel Eq Test.8 Test.7;
if Test.12 then
let Test.5 : I64 = 9i64;
ret Test.5;
else
jump Test.11;
else
jump Test.11;