roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-09-20 23:37:56 +03:00
Code Issues Packages Projects Releases Wiki Activity

Rename multimorphic tests to capture niche

Browse Source
This commit is contained in:
Ayaz Hafiz 2022-07-01 15:56:06 -04:00 committed by ayazhafiz
parent 019ebd93f7
commit d08aecf55f
No known key found for this signature in database
GPG Key ID: B443F7A3030C9AED
43 changed files with 889 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt Normal file
View File

@ -0,0 +1,65 @@
procedure List.2 (List.71, List.72):
let List.228 : U64 = CallByName List.6 List.71;
let List.224 : Int1 = CallByName Num.22 List.72 List.228;
if List.224 then
let List.226 : I64 = CallByName List.60 List.71 List.72;
let List.225 : [C {}, C I64] = Ok List.226;
ret List.225;
else
let List.223 : {} = Struct {};
let List.222 : [C {}, C I64] = Err List.223;
ret List.222;
procedure List.6 (#Attr.2):
let List.229 : U64 = lowlevel ListLen #Attr.2;
ret List.229;
procedure List.60 (#Attr.2, #Attr.3):
let List.227 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.227;
procedure List.9 (List.147):
let List.220 : U64 = 0i64;
let List.213 : [C {}, C I64] = CallByName List.2 List.147 List.220;
let List.217 : U8 = 1i64;
let List.218 : U8 = GetTagId List.213;
let List.219 : Int1 = lowlevel Eq List.217 List.218;
if List.219 then
let List.148 : I64 = UnionAtIndex (Id 1) (Index 0) List.213;
let List.214 : [C Int1, C I64] = Ok List.148;
ret List.214;
else
let List.216 : Int1 = true;
let List.215 : [C Int1, C I64] = Err List.216;
ret List.215;
procedure Num.22 (#Attr.2, #Attr.3):
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.41 : U8 = StructAtIndex 1 #Attr.3;
let Str.42 : U8 = 0i64;
let Str.38 : Int1 = lowlevel NumGt Str.41 Str.42;
if Str.38 then
let Str.40 : Int1 = false;
let Str.39 : [C Int1, C I64] = Err Str.40;
ret Str.39;
else
let Str.37 : I64 = StructAtIndex 0 #Attr.3;
let Str.36 : [C Int1, C I64] = Ok Str.37;
ret Str.36;
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;

35
compiler/test_mono/generated/list_get.txt Normal file
View File

@ -0,0 +1,35 @@
procedure List.2 (List.71, List.72):
let List.219 : U64 = CallByName List.6 List.71;
let List.215 : Int1 = CallByName Num.22 List.72 List.219;
if List.215 then
let List.217 : I64 = CallByName List.60 List.71 List.72;
let List.216 : [C {}, C I64] = Ok List.217;
ret List.216;
else
let List.214 : {} = Struct {};
let List.213 : [C {}, C I64] = Err List.214;
ret List.213;
procedure List.6 (#Attr.2):
let List.222 : U64 = lowlevel ListLen #Attr.2;
ret List.222;
procedure List.60 (#Attr.2, #Attr.3):
let List.221 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.221;
procedure Num.22 (#Attr.2, #Attr.3):
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];
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;

39
compiler/test_mono/generated/list_pass_to_function.txt Normal file
View File

@ -0,0 +1,39 @@
procedure List.3 (List.79, List.80, List.81):
let List.214 : {List I64, I64} = CallByName List.57 List.79 List.80 List.81;
let List.213 : List I64 = StructAtIndex 0 List.214;
inc List.213;
dec List.214;
ret List.213;
procedure List.57 (List.76, List.77, List.78):
let List.220 : U64 = CallByName List.6 List.76;
let List.217 : Int1 = CallByName Num.22 List.77 List.220;
if List.217 then
let List.218 : {List I64, I64} = CallByName List.61 List.76 List.77 List.78;
ret List.218;
else
let List.216 : {List I64, I64} = Struct {List.76, List.78};
ret List.216;
procedure List.6 (#Attr.2):
let List.221 : U64 = lowlevel ListLen #Attr.2;
ret List.221;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.219 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.219;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
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;

10
crates/compiler/test_mono/generated/closure_in_list.txt
View File

@ -1,6 +1,16 @@
procedure List.6 (#Attr.2):
<<<<<<< HEAD
let List.284 : U64 = lowlevel ListLen #Attr.2;
ret List.284;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/closure_in_list.txt
let List.259 : U64 = lowlevel ListLen #Attr.2;
ret List.259;
=======
let List.213 : U64 = lowlevel ListLen #Attr.2;
ret List.213;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/closure_in_list.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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;

41
crates/compiler/test_mono/generated/empty_list_of_function_type.txt
View File

@ -1,3 +1,4 @@
<<<<<<< HEAD
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;
@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76):
let List.288 : {} = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C {}] = Ok List.288;
ret List.287;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/empty_list_of_function_type.txt
procedure List.2 (List.73, List.74):
let List.265 : U64 = CallByName List.6 List.73;
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
if List.261 then
let List.263 : {} = CallByName List.60 List.73 List.74;
let List.262 : [C {}, C {}] = Ok List.263;
ret List.262;
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
else
let List.285 : {} = Struct {};
let List.284 : [C {}, C {}] = Err List.285;
@ -15,12 +26,38 @@ procedure List.6 (#Attr.2):
ret List.293;
procedure List.60 (#Attr.2, #Attr.3):
<<<<<<< HEAD
let List.292 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.292;
=======
let List.267 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.267;
=======
procedure List.2 (List.71, List.72):
let List.219 : U64 = CallByName List.6 List.71;
let List.215 : Int1 = CallByName Num.22 List.72 List.219;
if List.215 then
let List.217 : {} = CallByName List.60 List.71 List.72;
let List.216 : [C {}, C {}] = Ok List.217;
ret List.216;
else
let List.214 : {} = Struct {};
let List.213 : [C {}, C {}] = Err List.214;
ret List.213;
procedure List.6 (#Attr.2):
let List.222 : U64 = lowlevel ListLen #Attr.2;
ret List.222;
procedure List.60 (#Attr.2, #Attr.3):
let List.221 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.221;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/empty_list_of_function_type.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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";

10
crates/compiler/test_mono/generated/encode.txt
View File

@ -1,6 +1,16 @@
procedure List.4 (#Attr.2, #Attr.3):
<<<<<<< HEAD
let List.284 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.284;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/encode.txt
let List.259 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.259;
=======
let List.213 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.213;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/encode.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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;

14
crates/compiler/test_mono/generated/ir_int_add.txt
View File

@ -1,10 +1,20 @@
procedure List.6 (#Attr.2):
<<<<<<< HEAD
let List.284 : U64 = lowlevel ListLen #Attr.2;
ret List.284;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/ir_int_add.txt
let List.259 : U64 = lowlevel ListLen #Attr.2;
ret List.259;
=======
let List.213 : U64 = lowlevel ListLen #Attr.2;
ret List.213;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/ir_int_add.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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] = Ok 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] = Err Num.189;
ret Num.188;
procedure Test.0 ():
let Test.8 : I64 = 1000i64;

4
crates/compiler/test_mono/generated/ir_when_just.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.10 : I64 = 41i64;

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] = ClosureTag(Test.5) Test.4;
ret Test.16;
procedure Test.1 (Test.4):
let Test.22 : [C U8, C U64] = ClosureTag(Test.5) 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 {} {}] = ClosureTag(Test.9) Test.7 Test.8;
ret Test.9;
procedure Test.2 (Test.7, Test.8):
let Test.9 : [C {} {}, C {} {}] = ClosureTag(Test.9) 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 {}] = ClosureTag(Test.6) Test.5;
ret Test.19;
procedure Test.1 (Test.5):
let Test.27 : [C , C U64, C {}] = ClosureTag(Test.6) 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 {}] = ClosureTag(Test.2) ;
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] = ClosureTag(Test.6) Test.5;
ret Test.20;
procedure Test.1 (Test.5):
let Test.32 : [C U64, C {}, C Str] = ClosureTag(Test.6) Test.5;
ret Test.32;
procedure Test.2 (Test.7):
let Test.26 : [C U64, C {}, C Str] = ClosureTag(Test.8) 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;

10
crates/compiler/test_mono/generated/list_append.txt
View File

@ -1,6 +1,16 @@
procedure List.4 (#Attr.2, #Attr.3):
<<<<<<< HEAD
let List.284 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.284;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_append.txt
let List.259 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.259;
=======
let List.213 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.213;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_append.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
procedure Test.0 ():
let Test.2 : List I64 = Array [1i64];

10
crates/compiler/test_mono/generated/list_append_closure.txt
View File

@ -1,6 +1,16 @@
procedure List.4 (#Attr.2, #Attr.3):
<<<<<<< HEAD
let List.284 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.284;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_append_closure.txt
let List.259 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.259;
=======
let List.213 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.213;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_append_closure.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
procedure Test.1 (Test.2):
let Test.6 : I64 = 42i64;

56
crates/compiler/test_mono/generated/list_cannot_update_inplace.txt
View File

@ -1,3 +1,4 @@
<<<<<<< HEAD
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;
@ -11,6 +12,22 @@ procedure List.57 (List.81, List.82, List.83):
if List.290 then
let List.291 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
ret List.291;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_cannot_update_inplace.txt
procedure List.3 (List.82, List.83, List.84):
let List.262 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
let List.261 : List I64 = StructAtIndex 0 List.262;
inc List.261;
dec List.262;
ret List.261;
procedure List.57 (List.79, List.80, List.81):
let List.268 : U64 = CallByName List.6 List.79;
let List.265 : Int1 = CallByName Num.22 List.80 List.268;
if List.265 then
let List.266 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
ret List.266;
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
else
let List.289 : {List I64, I64} = Struct {List.81, List.83};
ret List.289;
@ -20,16 +37,47 @@ procedure List.6 (#Attr.2):
ret List.285;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
<<<<<<< HEAD
let List.292 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.292;
=======
let List.267 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.267;
=======
procedure List.3 (List.79, List.80, List.81):
let List.216 : {List I64, I64} = CallByName List.57 List.79 List.80 List.81;
let List.215 : List I64 = StructAtIndex 0 List.216;
inc List.215;
dec List.216;
ret List.215;
procedure List.57 (List.76, List.77, List.78):
let List.222 : U64 = CallByName List.6 List.76;
let List.219 : Int1 = CallByName Num.22 List.77 List.222;
if List.219 then
let List.220 : {List I64, I64} = CallByName List.61 List.76 List.77 List.78;
ret List.220;
else
let List.218 : {List I64, I64} = Struct {List.76, List.78};
ret List.218;
procedure List.6 (#Attr.2):
let List.214 : U64 = lowlevel ListLen #Attr.2;
ret List.214;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.221 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.221;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_cannot_update_inplace.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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];

22
crates/compiler/test_mono/generated/list_len.txt
View File

@ -1,14 +1,32 @@
procedure List.6 (#Attr.2):
<<<<<<< HEAD
let List.284 : U64 = lowlevel ListLen #Attr.2;
ret List.284;
procedure List.6 (#Attr.2):
let List.285 : U64 = lowlevel ListLen #Attr.2;
ret List.285;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_len.txt
let List.259 : U64 = lowlevel ListLen #Attr.2;
ret List.259;
procedure List.6 (#Attr.2):
let List.260 : U64 = lowlevel ListLen #Attr.2;
ret List.260;
=======
let List.213 : U64 = lowlevel ListLen #Attr.2;
ret List.213;
procedure List.6 (#Attr.2):
let List.214 : U64 = lowlevel ListLen #Attr.2;
ret List.214;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_len.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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];

54
crates/compiler/test_mono/generated/list_map_closure_borrows.txt
View File

@ -1,3 +1,4 @@
<<<<<<< HEAD
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;
@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76):
let List.288 : Str = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C Str] = Ok List.288;
ret List.287;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_map_closure_borrows.txt
procedure List.2 (List.73, List.74):
let List.265 : U64 = CallByName List.6 List.73;
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
if List.261 then
let List.263 : Str = CallByName List.60 List.73 List.74;
let List.262 : [C {}, C Str] = Ok List.263;
ret List.262;
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
else
let List.285 : {} = Struct {};
let List.284 : [C {}, C Str] = Err List.285;
@ -19,20 +30,59 @@ procedure List.6 (#Attr.2):
ret List.294;
procedure List.60 (#Attr.2, #Attr.3):
<<<<<<< HEAD
let List.293 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.293;
=======
let List.268 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.268;
=======
procedure List.2 (List.71, List.72):
let List.219 : U64 = CallByName List.6 List.71;
let List.215 : Int1 = CallByName Num.22 List.72 List.219;
if List.215 then
let List.217 : Str = CallByName List.60 List.71 List.72;
let List.216 : [C {}, C Str] = Ok List.217;
ret List.216;
else
let List.214 : {} = Struct {};
let List.213 : [C {}, C Str] = Err List.214;
ret List.213;
procedure List.5 (#Attr.2, #Attr.3):
let List.221 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
ret List.221;
procedure List.6 (#Attr.2):
let List.223 : U64 = lowlevel ListLen #Attr.2;
ret List.223;
procedure List.60 (#Attr.2, #Attr.3):
let List.222 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.222;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_map_closure_borrows.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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):
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_map_closure_borrows.txt
let Str.67 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.67;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.68 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.68;
=======
let Str.36 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.36;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.37 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.37;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_map_closure_borrows.txt
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

52
crates/compiler/test_mono/generated/list_map_closure_owns.txt
View File

@ -1,3 +1,4 @@
<<<<<<< HEAD
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;
@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76):
let List.288 : Str = CallByName List.60 List.75 List.76;
let List.287 : [C {}, C Str] = Ok List.288;
ret List.287;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_map_closure_owns.txt
procedure List.2 (List.73, List.74):
let List.265 : U64 = CallByName List.6 List.73;
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
if List.261 then
let List.263 : Str = CallByName List.60 List.73 List.74;
let List.262 : [C {}, C Str] = Ok List.263;
ret List.262;
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
else
let List.285 : {} = Struct {};
let List.284 : [C {}, C Str] = Err List.285;
@ -21,16 +32,53 @@ procedure List.6 (#Attr.2):
ret List.294;
procedure List.60 (#Attr.2, #Attr.3):
<<<<<<< HEAD
let List.293 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.293;
=======
let List.268 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.268;
=======
procedure List.2 (List.71, List.72):
let List.219 : U64 = CallByName List.6 List.71;
let List.215 : Int1 = CallByName Num.22 List.72 List.219;
if List.215 then
let List.217 : Str = CallByName List.60 List.71 List.72;
let List.216 : [C {}, C Str] = Ok List.217;
ret List.216;
else
let List.214 : {} = Struct {};
let List.213 : [C {}, C Str] = Err List.214;
ret List.213;
procedure List.5 (#Attr.2, #Attr.3):
inc #Attr.2;
let List.221 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
decref #Attr.2;
ret List.221;
procedure List.6 (#Attr.2):
let List.223 : U64 = lowlevel ListLen #Attr.2;
ret List.223;
procedure List.60 (#Attr.2, #Attr.3):
let List.222 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.222;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_map_closure_owns.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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):
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_map_closure_owns.txt
let Str.68 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.68;
=======
let Str.37 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.37;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_map_closure_owns.txt
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

30
crates/compiler/test_mono/generated/list_sort_asc.txt
View File

@ -1,5 +1,10 @@
procedure List.28 (#Attr.2, #Attr.3):
<<<<<<< HEAD
let List.287 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_sort_asc.txt
let List.262 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
let Bool.14 : Int1 = lowlevel ListIsUnique #Attr.2;
if Bool.14 then
ret List.287;
@ -7,14 +12,35 @@ procedure List.28 (#Attr.2, #Attr.3):
decref #Attr.2;
ret List.287;
<<<<<<< HEAD
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.178):
let List.260 : {} = Struct {};
let List.259 : List I64 = CallByName List.28 List.178 List.260;
ret List.259;
=======
let List.216 : 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.216;
else
decref #Attr.2;
ret List.216;
procedure List.54 (List.142):
let List.214 : {} = Struct {};
let List.213 : List I64 = CallByName List.28 List.142 List.214;
ret List.213;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_sort_asc.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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];

8
crates/compiler/test_mono/generated/multimorphic_lambda_set_capture.txt
View File

@ -1,10 +1,10 @@
procedure Num.94 (#Attr.2):
let Num.273 : Str = lowlevel NumToStr #Attr.2;
ret Num.273;
let Num.188 : Str = lowlevel NumToStr #Attr.2;
ret Num.188;
procedure Num.94 (#Attr.2):
let Num.274 : Str = lowlevel NumToStr #Attr.2;
ret Num.274;
let Num.189 : Str = lowlevel NumToStr #Attr.2;
ret Num.189;
procedure Test.1 (Test.4):
let Test.16 : [C U8, C U64] = ClosureTag(Test.5) Test.4;

4
crates/compiler/test_mono/generated/nested_pattern_match.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.19 : I64 = 41i64;

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;

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:

62
crates/compiler/test_mono/generated/quicksort_swap.txt
View File

@ -1,3 +1,4 @@
<<<<<<< HEAD
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;
@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76):
let List.302 : I64 = CallByName List.60 List.75 List.76;
let List.301 : [C {}, C I64] = Ok List.302;
ret List.301;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/quicksort_swap.txt
procedure List.2 (List.73, List.74):
let List.279 : U64 = CallByName List.6 List.73;
let List.275 : Int1 = CallByName Num.22 List.74 List.279;
if List.275 then
let List.277 : I64 = CallByName List.60 List.73 List.74;
let List.276 : [C {}, C I64] = Ok List.277;
ret List.276;
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
else
let List.299 : {} = Struct {};
let List.298 : [C {}, C I64] = Err List.299;
@ -36,12 +47,59 @@ procedure List.60 (#Attr.2, #Attr.3):
ret List.312;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
<<<<<<< HEAD
let List.309 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.309;
=======
let List.284 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.284;
=======
procedure List.2 (List.71, List.72):
let List.233 : U64 = CallByName List.6 List.71;
let List.229 : Int1 = CallByName Num.22 List.72 List.233;
if List.229 then
let List.231 : I64 = CallByName List.60 List.71 List.72;
let List.230 : [C {}, C I64] = Ok List.231;
ret List.230;
else
let List.228 : {} = Struct {};
let List.227 : [C {}, C I64] = Err List.228;
ret List.227;
procedure List.3 (List.79, List.80, List.81):
let List.217 : {List I64, I64} = CallByName List.57 List.79 List.80 List.81;
let List.216 : List I64 = StructAtIndex 0 List.217;
inc List.216;
dec List.217;
ret List.216;
procedure List.57 (List.76, List.77, List.78):
let List.239 : U64 = CallByName List.6 List.76;
let List.236 : Int1 = CallByName Num.22 List.77 List.239;
if List.236 then
let List.237 : {List I64, I64} = CallByName List.61 List.76 List.77 List.78;
ret List.237;
else
let List.235 : {List I64, I64} = Struct {List.76, List.78};
ret List.235;
procedure List.6 (#Attr.2):
let List.240 : U64 = lowlevel ListLen #Attr.2;
ret List.240;
procedure List.60 (#Attr.2, #Attr.3):
let List.241 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.241;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.238 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.238;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/quicksort_swap.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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;

62
crates/compiler/test_mono/generated/rigids.txt
View File

@ -1,3 +1,4 @@
<<<<<<< HEAD
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;
@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76):
let List.302 : I64 = CallByName List.60 List.75 List.76;
let List.301 : [C {}, C I64] = Ok List.302;
ret List.301;
=======
<<<<<<< HEAD:crates/compiler/test_mono/generated/rigids.txt
procedure List.2 (List.73, List.74):
let List.279 : U64 = CallByName List.6 List.73;
let List.275 : Int1 = CallByName Num.22 List.74 List.279;
if List.275 then
let List.277 : I64 = CallByName List.60 List.73 List.74;
let List.276 : [C {}, C I64] = Ok List.277;
ret List.276;
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
else
let List.299 : {} = Struct {};
let List.298 : [C {}, C I64] = Err List.299;
@ -36,12 +47,59 @@ procedure List.60 (#Attr.2, #Attr.3):
ret List.312;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
<<<<<<< HEAD
let List.309 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.309;
=======
let List.284 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.284;
=======
procedure List.2 (List.71, List.72):
let List.233 : U64 = CallByName List.6 List.71;
let List.229 : Int1 = CallByName Num.22 List.72 List.233;
if List.229 then
let List.231 : I64 = CallByName List.60 List.71 List.72;
let List.230 : [C {}, C I64] = Ok List.231;
ret List.230;
else
let List.228 : {} = Struct {};
let List.227 : [C {}, C I64] = Err List.228;
ret List.227;
procedure List.3 (List.79, List.80, List.81):
let List.217 : {List I64, I64} = CallByName List.57 List.79 List.80 List.81;
let List.216 : List I64 = StructAtIndex 0 List.217;
inc List.216;
dec List.217;
ret List.216;
procedure List.57 (List.76, List.77, List.78):
let List.239 : U64 = CallByName List.6 List.76;
let List.236 : Int1 = CallByName Num.22 List.77 List.239;
if List.236 then
let List.237 : {List I64, I64} = CallByName List.61 List.76 List.77 List.78;
ret List.237;
else
let List.235 : {List I64, I64} = Struct {List.76, List.78};
ret List.235;
procedure List.6 (#Attr.2):
let List.240 : U64 = lowlevel ListLen #Attr.2;
ret List.240;
procedure List.60 (#Attr.2, #Attr.3):
let List.241 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.241;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.238 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.238;
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/rigids.txt
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
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;

8
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;

8
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;

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:

4
crates/compiler/test_mono/generated/when_nested_maybe.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.19 : I64 = 41i64;

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;

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;

8
crates/compiler/test_mono/src/tests.rs
View File

@ -1527,7 +1527,7 @@ fn tail_call_with_different_layout() {
}
#[mono_test]
fn multimorphic_lambda_set_capture() {
fn lambda_capture_niche_u8_vs_u64() {
indoc!(
r#"
capture : _ -> ({} -> Str)
@ -1549,7 +1549,7 @@ fn multimorphic_lambda_set_capture() {
}
#[mono_test]
fn multimorphic_lambdas_with_other_lambda_capture() {
fn lambda_capture_niches_with_other_lambda_capture() {
indoc!(
r#"
capture : a -> ({} -> Str)
@ -1575,7 +1575,7 @@ fn multimorphic_lambdas_with_other_lambda_capture() {
}
#[mono_test]
fn multimorphic_lambdas_with_non_capturing_function() {
fn lambda_capture_niches_with_non_capturing_function() {
indoc!(
r#"
capture : a -> ({} -> Str)
@ -1601,7 +1601,7 @@ fn multimorphic_lambdas_with_non_capturing_function() {
}
#[mono_test]
fn multimorphic_lambdas_have_captured_function_in_closure() {
fn lambda_capture_niches_have_captured_function_in_closure() {
indoc!(
r#"
Lazy a : {} -> a