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

Merge remote-tracking branch 'origin/trunk' into str-walk

Browse source
This commit is contained in:
Folkert 2022-07-04 16:30:07 +02:00
commit 1de9270ecf
No known key found for this signature in database
GPG key ID: 1F17F6FFD112B97C
107 changed files with 10287 additions and 9870 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,6 +1,6 @@
procedure List.6 (#Attr.2):
let List.284 : U64 = lowlevel ListLen #Attr.2;
ret List.284;
let List.266 : U64 = lowlevel ListLen #Attr.2;
ret List.266;
procedure Test.1 (Test.5):
let Test.2 : I64 = 41i64;

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

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

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

@ -1,26 +1,26 @@
procedure List.2 (List.75, List.76):
let List.290 : U64 = CallByName List.6 List.75;
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
if List.286 then
let List.288 : {} = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C {}] = Ok List.288;
ret List.287;
procedure List.2 (List.74, List.75):
let List.272 : U64 = CallByName List.6 List.74;
let List.268 : Int1 = CallByName Num.22 List.75 List.272;
if List.268 then
let List.270 : {} = CallByName List.60 List.74 List.75;
let List.269 : [C {}, C {}] = TagId(1) List.270;
ret List.269;
else
let List.285 : {} = Struct {};
let List.284 : [C {}, C {}] = Err List.285;
ret List.284;
let List.267 : {} = Struct {};
let List.266 : [C {}, C {}] = TagId(0) List.267;
ret List.266;
procedure List.6 (#Attr.2):
let List.293 : U64 = lowlevel ListLen #Attr.2;
ret List.293;
let List.275 : U64 = lowlevel ListLen #Attr.2;
ret List.275;
procedure List.60 (#Attr.2, #Attr.3):
let List.292 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.292;
let List.274 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.274;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
procedure Test.2 (Test.6):
let Test.18 : Str = "bar";

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

@ -1,6 +1,6 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.284 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.284;
let List.266 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.266;
procedure Test.20 (Test.22):
let Test.34 : {U8} = Struct {Test.22};

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

@ -1,10 +1,10 @@
procedure Num.20 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.274;
let Num.189 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.189;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.188;
procedure Test.1 (Test.15, Test.16):
joinpoint Test.7 Test.2 Test.3:

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

@ -1,6 +1,6 @@
procedure Bool.7 (#Attr.2, #Attr.3):
let Bool.14 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.14;
let Bool.9 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.9;
procedure Test.1 (Test.3):
let Test.6 : I64 = 10i64;

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

@ -1,10 +1,10 @@
procedure List.6 (#Attr.2):
let List.284 : U64 = lowlevel ListLen #Attr.2;
ret List.284;
let List.266 : U64 = lowlevel ListLen #Attr.2;
ret List.266;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
let Num.190 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.190;
procedure Test.0 ():
let Test.1 : List I64 = Array [1i64, 2i64];

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

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

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

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

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

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

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

@ -1,14 +1,14 @@
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;
let Num.193 : I64 = 0i64;
let Num.190 : Int1 = lowlevel NotEq #Attr.3 Num.193;
if Num.190 then
let Num.192 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
let Num.191 : [C {}, C I64] = TagId(1) Num.192;
ret Num.191;
else
let Num.274 : {} = Struct {};
let Num.273 : [C {}, C I64] = Err Num.274;
ret Num.273;
let Num.189 : {} = Struct {};
let Num.188 : [C {}, C I64] = TagId(0) Num.189;
ret Num.188;
procedure Test.0 ():
let Test.8 : I64 = 1000i64;

6
crates/compiler/test_mono/generated/ir_when_just.txt
View file

@ -1,10 +1,10 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
procedure Test.0 ():
let Test.10 : I64 = 41i64;
let Test.1 : [C I64, C ] = Just Test.10;
let Test.1 : [C I64, C ] = TagId(0) Test.10;
let Test.7 : U8 = 0i64;
let Test.8 : U8 = GetTagId Test.1;
let Test.9 : Int1 = lowlevel Eq Test.7 Test.8;

2
crates/compiler/test_mono/generated/ir_when_maybe.txt
View file

@ -1,6 +1,6 @@
procedure Test.0 ():
let Test.9 : I64 = 3i64;
let Test.3 : [C I64, C ] = Just Test.9;
let Test.3 : [C I64, C ] = TagId(0) Test.9;
let Test.6 : U8 = 0i64;
let Test.7 : U8 = GetTagId Test.3;
let Test.8 : Int1 = lowlevel Eq Test.6 Test.7;

2
crates/compiler/test_mono/generated/ir_when_these.txt
View file

@ -1,7 +1,7 @@
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.5 : [C I64, C I64 I64, C I64] = TagId(1) Test.10 Test.11;
let Test.9 : U8 = GetTagId Test.5;
switch Test.9:
case 2:

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

@ -11,8 +11,8 @@ procedure Test.3 (Test.4):
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.17 : [<rnu><null>, C I64 *self] = TagId(1) ;
let Test.10 : [<rnu><null>, C I64 *self] = TagId(0) Test.16 Test.17;
let Test.9 : Int1 = CallByName Test.3 Test.10;
dec Test.10;
ret Test.9;

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

@ -1,55 +1,55 @@
procedure List.2 (List.75, List.76):
let List.299 : U64 = CallByName List.6 List.75;
let List.295 : Int1 = CallByName Num.22 List.76 List.299;
if List.295 then
let List.297 : I64 = CallByName List.60 List.75 List.76;
let List.296 : [C {}, C I64] = Ok List.297;
ret List.296;
procedure List.2 (List.74, List.75):
let List.281 : U64 = CallByName List.6 List.74;
let List.277 : Int1 = CallByName Num.22 List.75 List.281;
if List.277 then
let List.279 : I64 = CallByName List.60 List.74 List.75;
let List.278 : [C {}, C I64] = TagId(1) List.279;
ret List.278;
else
let List.294 : {} = Struct {};
let List.293 : [C {}, C I64] = Err List.294;
ret List.293;
let List.276 : {} = Struct {};
let List.275 : [C {}, C I64] = TagId(0) List.276;
ret List.275;
procedure List.6 (#Attr.2):
let List.300 : U64 = lowlevel ListLen #Attr.2;
ret List.300;
let List.282 : U64 = lowlevel ListLen #Attr.2;
ret List.282;
procedure List.60 (#Attr.2, #Attr.3):
let List.298 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.298;
let List.280 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.280;
procedure List.9 (List.202):
let List.291 : U64 = 0i64;
let List.284 : [C {}, C I64] = CallByName List.2 List.202 List.291;
let List.288 : U8 = 1i64;
let List.289 : U8 = GetTagId List.284;
let List.290 : Int1 = lowlevel Eq List.288 List.289;
if List.290 then
let List.203 : I64 = UnionAtIndex (Id 1) (Index 0) List.284;
let List.285 : [C Int1, C I64] = Ok List.203;
ret List.285;
procedure List.9 (List.188):
let List.273 : U64 = 0i64;
let List.266 : [C {}, C I64] = CallByName List.2 List.188 List.273;
let List.270 : U8 = 1i64;
let List.271 : U8 = GetTagId List.266;
let List.272 : Int1 = lowlevel Eq List.270 List.271;
if List.272 then
let List.189 : I64 = UnionAtIndex (Id 1) (Index 0) List.266;
let List.267 : [C Int1, C I64] = TagId(1) List.189;
ret List.267;
else
let List.287 : Int1 = true;
let List.286 : [C Int1, C I64] = Err List.287;
ret List.286;
let List.269 : Int1 = true;
let List.268 : [C Int1, C I64] = TagId(0) List.269;
ret List.268;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
procedure Str.27 (#Attr.2):
let #Attr.3 : {I64, U8} = lowlevel StrToNum #Attr.2;
let Str.154 : U8 = StructAtIndex 1 #Attr.3;
let Str.155 : U8 = 0i64;
let Str.151 : Int1 = lowlevel NumGt Str.154 Str.155;
if Str.151 then
let Str.153 : Int1 = false;
let Str.152 : [C Int1, C I64] = Err Str.153;
ret Str.152;
let Str.131 : U8 = StructAtIndex 1 #Attr.3;
let Str.132 : U8 = 0i64;
let Str.128 : Int1 = lowlevel NumGt Str.131 Str.132;
if Str.128 then
let Str.130 : Int1 = false;
let Str.129 : [C Int1, C I64] = TagId(0) Str.130;
ret Str.129;
else
let Str.150 : I64 = StructAtIndex 0 #Attr.3;
let Str.149 : [C Int1, C I64] = Ok Str.150;
ret Str.149;
let Str.127 : I64 = StructAtIndex 0 #Attr.3;
let Str.126 : [C Int1, C I64] = TagId(1) Str.127;
ret Str.126;
procedure Test.0 ():
let Test.4 : Int1 = true;

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

@ -1,6 +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;
let Test.19 : [C [<rnnu>C [C *self, C ]], C ] = TagId(1) ;
let Test.17 : [<rnnu>C [C *self, C ]] = TagId(0) Test.19;
let Test.16 : [C [<rnnu>C [C *self, C ]], C ] = TagId(0) Test.17;
let Test.7 : [<rnnu>C [C *self, C ]] = TagId(0) Test.16;
ret Test.7;

54
crates/compiler/test_mono/generated/lambda_capture_niche_u8_vs_u64.txt Normal file
View file

@ -0,0 +1,54 @@
procedure Num.94 (#Attr.2):
let Num.188 : Str = lowlevel NumToStr #Attr.2;
ret Num.188;
procedure Num.94 (#Attr.2):
let Num.189 : Str = lowlevel NumToStr #Attr.2;
ret Num.189;
procedure Test.1 (Test.4):
let Test.16 : [C U8, C U64] = TagId(1) Test.4;
ret Test.16;
procedure Test.1 (Test.4):
let Test.22 : [C U8, C U64] = TagId(0) Test.4;
ret Test.22;
procedure Test.5 (Test.17, #Attr.12):
let Test.4 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.19 : Str = CallByName Num.94 Test.4;
ret Test.19;
procedure Test.5 (Test.17, #Attr.12):
let Test.4 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.25 : Str = CallByName Num.94 Test.4;
ret Test.25;
procedure Test.0 ():
let Test.2 : Int1 = true;
joinpoint Test.13 Test.3:
let Test.8 : {} = Struct {};
let Test.9 : U8 = GetTagId Test.3;
joinpoint Test.10 Test.7:
ret Test.7;
in
switch Test.9:
case 0:
let Test.11 : Str = CallByName Test.5 Test.8 Test.3;
jump Test.10 Test.11;
default:
let Test.12 : Str = CallByName Test.5 Test.8 Test.3;
jump Test.10 Test.12;
in
let Test.26 : Int1 = true;
let Test.27 : Int1 = lowlevel Eq Test.26 Test.2;
if Test.27 then
let Test.15 : U64 = 123i64;
let Test.14 : [C U8, C U64] = CallByName Test.1 Test.15;
jump Test.13 Test.14;
else
let Test.21 : U8 = 18i64;
let Test.20 : [C U8, C U64] = CallByName Test.1 Test.21;
jump Test.13 Test.20;

85
crates/compiler/test_mono/generated/lambda_capture_niches_have_captured_function_in_closure.txt Normal file
View file

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

59
crates/compiler/test_mono/generated/lambda_capture_niches_with_non_capturing_function.txt Normal file
View file

@ -0,0 +1,59 @@
procedure Test.1 (Test.5):
let Test.19 : [C , C U64, C {}] = TagId(2) Test.5;
ret Test.19;
procedure Test.1 (Test.5):
let Test.27 : [C , C U64, C {}] = TagId(1) Test.5;
ret Test.27;
procedure Test.2 (Test.8):
let Test.24 : Str = "";
ret Test.24;
procedure Test.6 (Test.20, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.30 : Str = "";
ret Test.30;
procedure Test.6 (Test.20, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 2) (Index 0) #Attr.12;
let Test.22 : Str = "";
ret Test.22;
procedure Test.0 ():
let Test.3 : U8 = 0u8;
joinpoint Test.16 Test.4:
let Test.10 : {} = Struct {};
let Test.11 : U8 = GetTagId Test.4;
joinpoint Test.12 Test.9:
ret Test.9;
in
switch Test.11:
case 0:
let Test.13 : Str = CallByName Test.2 Test.10;
jump Test.12 Test.13;
case 1:
let Test.14 : Str = CallByName Test.6 Test.10 Test.4;
jump Test.12 Test.14;
default:
let Test.15 : Str = CallByName Test.6 Test.10 Test.4;
jump Test.12 Test.15;
in
switch Test.3:
case 0:
let Test.18 : {} = Struct {};
let Test.17 : [C , C U64, C {}] = CallByName Test.1 Test.18;
jump Test.16 Test.17;
case 1:
let Test.2 : [C , C U64, C {}] = TagId(0) ;
jump Test.16 Test.2;
default:
let Test.26 : U64 = 1i64;
let Test.25 : [C , C U64, C {}] = CallByName Test.1 Test.26;
jump Test.16 Test.25;

68
crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt Normal file
View file

@ -0,0 +1,68 @@
procedure Test.1 (Test.5):
let Test.20 : [C U64, C {}, C Str] = TagId(1) Test.5;
ret Test.20;
procedure Test.1 (Test.5):
let Test.32 : [C U64, C {}, C Str] = TagId(0) Test.5;
ret Test.32;
procedure Test.2 (Test.7):
let Test.26 : [C U64, C {}, C Str] = TagId(2) Test.7;
ret Test.26;
procedure Test.6 (Test.21, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
dec #Attr.12;
let Test.35 : Str = "";
ret Test.35;
procedure Test.6 (Test.21, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
dec #Attr.12;
let Test.23 : Str = "";
ret Test.23;
procedure Test.8 (Test.27, #Attr.12):
let Test.7 : Str = UnionAtIndex (Id 2) (Index 0) #Attr.12;
inc Test.7;
dec #Attr.12;
ret Test.7;
procedure Test.0 ():
let Test.3 : U8 = 0u8;
joinpoint Test.17 Test.4:
let Test.11 : {} = Struct {};
let Test.12 : U8 = GetTagId Test.4;
joinpoint Test.13 Test.10:
ret Test.10;
in
switch Test.12:
case 0:
let Test.14 : Str = CallByName Test.6 Test.11 Test.4;
jump Test.13 Test.14;
case 1:
let Test.15 : Str = CallByName Test.6 Test.11 Test.4;
jump Test.13 Test.15;
default:
let Test.16 : Str = CallByName Test.8 Test.11 Test.4;
jump Test.13 Test.16;
in
switch Test.3:
case 0:
let Test.19 : {} = Struct {};
let Test.18 : [C U64, C {}, C Str] = CallByName Test.1 Test.19;
jump Test.17 Test.18;
case 1:
let Test.25 : Str = "foo";
let Test.24 : [C U64, C {}, C Str] = CallByName Test.2 Test.25;
jump Test.17 Test.24;
default:
let Test.31 : U64 = 1i64;
let Test.30 : [C U64, C {}, C Str] = CallByName Test.1 Test.31;
jump Test.17 Test.30;

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

@ -0,0 +1,26 @@
procedure Test.1 (Test.4):
let Test.5 : {Str} = Struct {Test.4};
ret Test.5;
procedure Test.5 (Test.12, #Attr.12):
let Test.4 : Str = StructAtIndex 0 #Attr.12;
inc Test.4;
dec #Attr.12;
let Test.14 : Str = "";
ret Test.14;
procedure Test.0 ():
let Test.2 : Int1 = true;
joinpoint Test.9 Test.3:
ret Test.3;
in
let Test.19 : Int1 = true;
let Test.20 : Int1 = lowlevel Eq Test.19 Test.2;
if Test.20 then
let Test.15 : Str = "";
let Test.10 : {Str} = CallByName Test.1 Test.15;
jump Test.9 Test.10;
else
let Test.18 : Str = "";
let Test.16 : {Str} = CallByName Test.1 Test.18;
jump Test.9 Test.16;

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

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

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

@ -1,6 +1,6 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.284 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.284;
let List.266 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.266;
procedure Test.1 (Test.2):
let Test.6 : I64 = 42i64;

44
crates/compiler/test_mono/generated/list_cannot_update_inplace.txt
View file

@ -1,35 +1,35 @@
procedure List.3 (List.84, List.85, List.86):
let List.287 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
let List.286 : List I64 = StructAtIndex 0 List.287;
inc List.286;
dec List.287;
ret List.286;
procedure List.3 (List.82, List.83, List.84):
let List.269 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
let List.268 : List I64 = StructAtIndex 0 List.269;
inc List.268;
dec List.269;
ret List.268;
procedure List.57 (List.81, List.82, List.83):
let List.293 : U64 = CallByName List.6 List.81;
let List.290 : Int1 = CallByName Num.22 List.82 List.293;
if List.290 then
let List.291 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
ret List.291;
procedure List.57 (List.79, List.80, List.81):
let List.275 : U64 = CallByName List.6 List.79;
let List.272 : Int1 = CallByName Num.22 List.80 List.275;
if List.272 then
let List.273 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
ret List.273;
else
let List.289 : {List I64, I64} = Struct {List.81, List.83};
ret List.289;
let List.271 : {List I64, I64} = Struct {List.79, List.81};
ret List.271;
procedure List.6 (#Attr.2):
let List.285 : U64 = lowlevel ListLen #Attr.2;
ret List.285;
let List.267 : U64 = lowlevel ListLen #Attr.2;
ret List.267;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.292 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.292;
let List.274 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.274;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.274;
let Num.189 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.189;
procedure Test.1 ():
let Test.8 : List I64 = Array [1i64, 2i64, 3i64];

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

@ -1,26 +1,26 @@
procedure List.2 (List.75, List.76):
let List.290 : U64 = CallByName List.6 List.75;
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
if List.286 then
let List.288 : I64 = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C I64] = Ok List.288;
ret List.287;
procedure List.2 (List.74, List.75):
let List.272 : U64 = CallByName List.6 List.74;
let List.268 : Int1 = CallByName Num.22 List.75 List.272;
if List.268 then
let List.270 : I64 = CallByName List.60 List.74 List.75;
let List.269 : [C {}, C I64] = TagId(1) List.270;
ret List.269;
else
let List.285 : {} = Struct {};
let List.284 : [C {}, C I64] = Err List.285;
ret List.284;
let List.267 : {} = Struct {};
let List.266 : [C {}, C I64] = TagId(0) List.267;
ret List.266;
procedure List.6 (#Attr.2):
let List.293 : U64 = lowlevel ListLen #Attr.2;
ret List.293;
let List.275 : U64 = lowlevel ListLen #Attr.2;
ret List.275;
procedure List.60 (#Attr.2, #Attr.3):
let List.292 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.292;
let List.274 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.274;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
procedure Test.1 (Test.2):
let Test.6 : List I64 = Array [1i64, 2i64, 3i64];

12
crates/compiler/test_mono/generated/list_len.txt
View file

@ -1,14 +1,14 @@
procedure List.6 (#Attr.2):
let List.284 : U64 = lowlevel ListLen #Attr.2;
ret List.284;
let List.266 : U64 = lowlevel ListLen #Attr.2;
ret List.266;
procedure List.6 (#Attr.2):
let List.285 : U64 = lowlevel ListLen #Attr.2;
ret List.285;
let List.267 : U64 = lowlevel ListLen #Attr.2;
ret List.267;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
procedure Test.0 ():
let Test.1 : List I64 = Array [1i64, 2i64, 3i64];

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

@ -1,38 +1,38 @@
procedure List.2 (List.75, List.76):
let List.290 : U64 = CallByName List.6 List.75;
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
if List.286 then
let List.288 : Str = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C Str] = Ok List.288;
ret List.287;
procedure List.2 (List.74, List.75):
let List.272 : U64 = CallByName List.6 List.74;
let List.268 : Int1 = CallByName Num.22 List.75 List.272;
if List.268 then
let List.270 : Str = CallByName List.60 List.74 List.75;
let List.269 : [C {}, C Str] = TagId(1) List.270;
ret List.269;
else
let List.285 : {} = Struct {};
let List.284 : [C {}, C Str] = Err List.285;
ret List.284;
let List.267 : {} = Struct {};
let List.266 : [C {}, C Str] = TagId(0) List.267;
ret List.266;
procedure List.5 (#Attr.2, #Attr.3):
let List.292 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
ret List.292;
let List.274 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
ret List.274;
procedure List.6 (#Attr.2):
let List.294 : U64 = lowlevel ListLen #Attr.2;
ret List.294;
let List.276 : U64 = lowlevel ListLen #Attr.2;
ret List.276;
procedure List.60 (#Attr.2, #Attr.3):
let List.293 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.293;
let List.275 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.275;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.149 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.149;
let Str.126 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.126;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.150 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.150;
let Str.127 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.127;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -1,36 +1,36 @@
procedure List.2 (List.75, List.76):
let List.290 : U64 = CallByName List.6 List.75;
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
if List.286 then
let List.288 : Str = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C Str] = Ok List.288;
ret List.287;
procedure List.2 (List.74, List.75):
let List.272 : U64 = CallByName List.6 List.74;
let List.268 : Int1 = CallByName Num.22 List.75 List.272;
if List.268 then
let List.270 : Str = CallByName List.60 List.74 List.75;
let List.269 : [C {}, C Str] = TagId(1) List.270;
ret List.269;
else
let List.285 : {} = Struct {};
let List.284 : [C {}, C Str] = Err List.285;
ret List.284;
let List.267 : {} = Struct {};
let List.266 : [C {}, C Str] = TagId(0) List.267;
ret List.266;
procedure List.5 (#Attr.2, #Attr.3):
inc #Attr.2;
let List.292 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
let List.274 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
decref #Attr.2;
ret List.292;
ret List.274;
procedure List.6 (#Attr.2):
let List.294 : U64 = lowlevel ListLen #Attr.2;
ret List.294;
let List.276 : U64 = lowlevel ListLen #Attr.2;
ret List.276;
procedure List.60 (#Attr.2, #Attr.3):
let List.293 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.293;
let List.275 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.275;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.150 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.150;
let Str.127 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.127;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

40
crates/compiler/test_mono/generated/list_pass_to_function.txt
View file

@ -1,31 +1,31 @@
procedure List.3 (List.84, List.85, List.86):
let List.285 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
let List.284 : List I64 = StructAtIndex 0 List.285;
inc List.284;
dec List.285;
ret List.284;
procedure List.3 (List.82, List.83, List.84):
let List.267 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
let List.266 : List I64 = StructAtIndex 0 List.267;
inc List.266;
dec List.267;
ret List.266;
procedure List.57 (List.81, List.82, List.83):
let List.291 : U64 = CallByName List.6 List.81;
let List.288 : Int1 = CallByName Num.22 List.82 List.291;
if List.288 then
let List.289 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
ret List.289;
procedure List.57 (List.79, List.80, List.81):
let List.273 : U64 = CallByName List.6 List.79;
let List.270 : Int1 = CallByName Num.22 List.80 List.273;
if List.270 then
let List.271 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
ret List.271;
else
let List.287 : {List I64, I64} = Struct {List.81, List.83};
ret List.287;
let List.269 : {List I64, I64} = Struct {List.79, List.81};
ret List.269;
procedure List.6 (#Attr.2):
let List.292 : U64 = lowlevel ListLen #Attr.2;
ret List.292;
let List.274 : U64 = lowlevel ListLen #Attr.2;
ret List.274;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.290 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.290;
let List.272 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.272;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
procedure Test.2 (Test.3):
let Test.6 : U64 = 0i64;

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

@ -1,20 +1,20 @@
procedure List.28 (#Attr.2, #Attr.3):
let List.287 : 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.287;
let List.269 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
let Bool.9 : Int1 = lowlevel ListIsUnique #Attr.2;
if Bool.9 then
ret List.269;
else
decref #Attr.2;
ret List.287;
ret List.269;
procedure List.54 (List.196):
let List.285 : {} = Struct {};
let List.284 : List I64 = CallByName List.28 List.196 List.285;
ret List.284;
procedure List.54 (List.183):
let List.267 : {} = Struct {};
let List.266 : List I64 = CallByName List.28 List.183 List.267;
ret List.266;
procedure Num.46 (#Attr.2, #Attr.3):
let Num.273 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
ret Num.188;
procedure Test.0 ():
let Test.2 : List I64 = Array [4i64, 3i64, 2i64, 1i64];

2
crates/compiler/test_mono/generated/monomorphized_applied_tag.txt
View file

@ -15,6 +15,6 @@ procedure Test.2 (Test.4):
procedure Test.0 ():
let Test.13 : Str = "A";
let Test.1 : [C Str, C Str] = A Test.13;
let Test.1 : [C Str, C Str] = TagId(0) Test.13;
let Test.7 : Str = CallByName Test.2 Test.1;
ret Test.7;

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

@ -1,11 +1,11 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
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;
let Test.18 : [C I64, C ] = TagId(0) Test.19;
let Test.2 : [C [C I64, C ], C ] = TagId(0) Test.18;
joinpoint Test.15:
let Test.8 : I64 = 1i64;
ret Test.8;

2
crates/compiler/test_mono/generated/opaque_assign_to_symbol.txt
View file

@ -1,5 +1,5 @@
procedure Test.3 (Test.4):
let Test.8 : [C {}, C U8] = Ok Test.4;
let Test.8 : [C {}, C U8] = TagId(1) Test.4;
ret Test.8;
procedure Test.0 ():

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

@ -1,6 +1,6 @@
procedure Num.21 (#Attr.2, #Attr.3):
let Num.275 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.275;
let Num.190 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.190;
procedure Test.1 (Test.6):
let Test.21 : Int1 = false;

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

@ -1,6 +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;
let Test.11 : [<rnu><null>, C *self] = TagId(1) ;
let Test.10 : [<rnu><null>, C *self] = TagId(0) Test.11;
let Test.9 : [<rnu><null>, C *self] = TagId(0) Test.10;
let Test.3 : [<rnu><null>, C *self] = TagId(0) Test.9;
ret Test.3;

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

@ -1,8 +1,8 @@
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.15 : [<rnu><null>, C *self] = TagId(1) ;
let Test.14 : [<rnu><null>, C *self] = TagId(0) Test.15;
let Test.13 : [<rnu><null>, C *self] = TagId(0) Test.14;
let Test.3 : [<rnu><null>, C *self] = TagId(0) Test.13;
let Test.10 : Int1 = 1i64;
let Test.11 : Int1 = GetTagId Test.3;
dec Test.3;

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

@ -1,8 +1,8 @@
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.21 : [<rnu><null>, C *self] = TagId(1) ;
let Test.20 : [<rnu><null>, C *self] = TagId(0) Test.21;
let Test.19 : [<rnu><null>, C *self] = TagId(0) Test.20;
let Test.3 : [<rnu><null>, C *self] = TagId(0) Test.19;
let Test.16 : Int1 = 0i64;
let Test.17 : Int1 = GetTagId Test.3;
let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;

12
crates/compiler/test_mono/generated/quicksort_help.txt
View file

@ -1,14 +1,14 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.274;
let Num.189 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.189;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.190;
procedure Test.1 (Test.24, Test.25, Test.26):
joinpoint Test.12 Test.2 Test.3 Test.4:

64
crates/compiler/test_mono/generated/quicksort_swap.txt
View file

@ -1,47 +1,47 @@
procedure List.2 (List.75, List.76):
let List.304 : U64 = CallByName List.6 List.75;
let List.300 : Int1 = CallByName Num.22 List.76 List.304;
if List.300 then
let List.302 : I64 = CallByName List.60 List.75 List.76;
let List.301 : [C {}, C I64] = Ok List.302;
ret List.301;
procedure List.2 (List.74, List.75):
let List.286 : U64 = CallByName List.6 List.74;
let List.282 : Int1 = CallByName Num.22 List.75 List.286;
if List.282 then
let List.284 : I64 = CallByName List.60 List.74 List.75;
let List.283 : [C {}, C I64] = TagId(1) List.284;
ret List.283;
else
let List.299 : {} = Struct {};
let List.298 : [C {}, C I64] = Err List.299;
ret List.298;
let List.281 : {} = Struct {};
let List.280 : [C {}, C I64] = TagId(0) List.281;
ret List.280;
procedure List.3 (List.84, List.85, List.86):
let List.288 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
let List.287 : List I64 = StructAtIndex 0 List.288;
inc List.287;
dec List.288;
ret List.287;
procedure List.3 (List.82, List.83, List.84):
let List.270 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
let List.269 : List I64 = StructAtIndex 0 List.270;
inc List.269;
dec List.270;
ret List.269;
procedure List.57 (List.81, List.82, List.83):
let List.310 : U64 = CallByName List.6 List.81;
let List.307 : Int1 = CallByName Num.22 List.82 List.310;
if List.307 then
let List.308 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
ret List.308;
procedure List.57 (List.79, List.80, List.81):
let List.292 : U64 = CallByName List.6 List.79;
let List.289 : Int1 = CallByName Num.22 List.80 List.292;
if List.289 then
let List.290 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
ret List.290;
else
let List.306 : {List I64, I64} = Struct {List.81, List.83};
ret List.306;
let List.288 : {List I64, I64} = Struct {List.79, List.81};
ret List.288;
procedure List.6 (#Attr.2):
let List.311 : U64 = lowlevel ListLen #Attr.2;
ret List.311;
let List.293 : U64 = lowlevel ListLen #Attr.2;
ret List.293;
procedure List.60 (#Attr.2, #Attr.3):
let List.312 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.312;
let List.294 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.294;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.309 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.309;
let List.291 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.291;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.190;
procedure Test.1 (Test.2):
let Test.28 : U64 = 0i64;

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

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

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

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

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

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

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

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

64
crates/compiler/test_mono/generated/rigids.txt
View file

@ -1,47 +1,47 @@
procedure List.2 (List.75, List.76):
let List.304 : U64 = CallByName List.6 List.75;
let List.300 : Int1 = CallByName Num.22 List.76 List.304;
if List.300 then
let List.302 : I64 = CallByName List.60 List.75 List.76;
let List.301 : [C {}, C I64] = Ok List.302;
ret List.301;
procedure List.2 (List.74, List.75):
let List.286 : U64 = CallByName List.6 List.74;
let List.282 : Int1 = CallByName Num.22 List.75 List.286;
if List.282 then
let List.284 : I64 = CallByName List.60 List.74 List.75;
let List.283 : [C {}, C I64] = TagId(1) List.284;
ret List.283;
else
let List.299 : {} = Struct {};
let List.298 : [C {}, C I64] = Err List.299;
ret List.298;
let List.281 : {} = Struct {};
let List.280 : [C {}, C I64] = TagId(0) List.281;
ret List.280;
procedure List.3 (List.84, List.85, List.86):
let List.288 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
let List.287 : List I64 = StructAtIndex 0 List.288;
inc List.287;
dec List.288;
ret List.287;
procedure List.3 (List.82, List.83, List.84):
let List.270 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
let List.269 : List I64 = StructAtIndex 0 List.270;
inc List.269;
dec List.270;
ret List.269;
procedure List.57 (List.81, List.82, List.83):
let List.310 : U64 = CallByName List.6 List.81;
let List.307 : Int1 = CallByName Num.22 List.82 List.310;
if List.307 then
let List.308 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
ret List.308;
procedure List.57 (List.79, List.80, List.81):
let List.292 : U64 = CallByName List.6 List.79;
let List.289 : Int1 = CallByName Num.22 List.80 List.292;
if List.289 then
let List.290 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
ret List.290;
else
let List.306 : {List I64, I64} = Struct {List.81, List.83};
ret List.306;
let List.288 : {List I64, I64} = Struct {List.79, List.81};
ret List.288;
procedure List.6 (#Attr.2):
let List.311 : U64 = lowlevel ListLen #Attr.2;
ret List.311;
let List.293 : U64 = lowlevel ListLen #Attr.2;
ret List.293;
procedure List.60 (#Attr.2, #Attr.3):
let List.312 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.312;
let List.294 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.294;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.309 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.309;
let List.291 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.291;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.190;
procedure Test.1 (Test.2, Test.3, Test.4):
let Test.29 : [C {}, C I64] = CallByName List.2 Test.4 Test.3;

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

@ -1,10 +1,10 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
let Num.189 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.189;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.188;
procedure Test.1 (Test.2, Test.3):
let Test.17 : U8 = GetTagId Test.2;
@ -46,8 +46,8 @@ procedure Test.0 ():
in
let Test.25 : Int1 = true;
if Test.25 then
let Test.7 : [C I64, C I64 Int1] = ClosureTag(Test.7) Test.4;
let Test.7 : [C I64, C I64 Int1] = TagId(0) Test.4;
jump Test.22 Test.7;
else
let Test.8 : [C I64, C I64 Int1] = ClosureTag(Test.8) Test.5 Test.6;
let Test.8 : [C I64, C I64 Int1] = TagId(1) Test.5 Test.6;
jump Test.22 Test.8;

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

@ -1,10 +1,10 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
let Num.189 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.189;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.188;
procedure Test.6 (Test.8, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
@ -37,8 +37,8 @@ procedure Test.0 ():
in
let Test.21 : Int1 = true;
if Test.21 then
let Test.6 : [C I64, C I64] = ClosureTag(Test.6) Test.4;
let Test.6 : [C I64, C I64] = TagId(0) Test.4;
jump Test.19 Test.6;
else
let Test.7 : [C I64, C I64] = ClosureTag(Test.7) Test.5;
let Test.7 : [C I64, C I64] = TagId(1) Test.5;
jump Test.19 Test.7;

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

@ -1,10 +1,10 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.274;
let Num.189 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.189;
procedure Test.1 (Test.15, Test.16):
joinpoint Test.7 Test.2 Test.3:

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

@ -1,11 +1,11 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
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;
let Test.18 : [C I64, C ] = TagId(0) Test.19;
let Test.2 : [C [C I64, C ], C ] = TagId(0) Test.18;
joinpoint Test.15:
let Test.8 : I64 = 1i64;
ret Test.8;

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

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

2
crates/compiler/test_mono/generated/when_on_result.txt
View file

@ -1,6 +1,6 @@
procedure Test.1 (Test.5):
let Test.19 : I64 = 2i64;
let Test.2 : [C I64, C I64] = Ok Test.19;
let Test.2 : [C I64, C I64] = TagId(1) Test.19;
joinpoint Test.9 Test.3:
ret Test.3;
in

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

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