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

update mono tests

Browse source
This commit is contained in:
Folkert 2022-07-08 15:28:46 +02:00
parent c3914883be
commit 9f9c514fc6
No known key found for this signature in database
GPG key ID: 1F17F6FFD112B97C
41 changed files with 375 additions and 325 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,7 +1,7 @@
procedure List.5 (#Attr.2, #Attr.3):
let List.279 : List {} = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
let List.292 : List {} = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.2 #Attr.3;
decref #Attr.2;
ret List.279;
ret List.292;
procedure Test.2 (Test.3):
let Test.7 : {} = Struct {};

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.189 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.189;
let Num.258 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Test.0 ():
let Test.6 : I128 = 18446744073709551616i64;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.188 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.2 : U128 = 170141183460469231731687303715884105728u128;

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

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

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

@ -1,6 +1,6 @@
procedure List.6 (#Attr.2):
let List.279 : U64 = lowlevel ListLen #Attr.2;
ret List.279;
let List.292 : U64 = lowlevel ListLen #Attr.2;
ret List.292;
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.16 : Dict [] [] = lowlevel DictEmpty ;
ret Dict.16;
let Dict.25 : Dict [] [] = lowlevel DictEmpty ;
ret Dict.25;
procedure Dict.7 (#Attr.2):
let Dict.15 : U64 = lowlevel DictSize #Attr.2;
let Dict.24 : U64 = lowlevel DictSize #Attr.2;
dec #Attr.2;
ret Dict.15;
ret Dict.24;
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.285 : U64 = CallByName List.6 List.75;
let List.281 : Int1 = CallByName Num.22 List.76 List.285;
if List.281 then
let List.283 : {} = CallByName List.60 List.75 List.76;
let List.282 : [C {}, C {}] = TagId(1) List.283;
ret List.282;
procedure List.2 (List.77, List.78):
let List.298 : U64 = CallByName List.6 List.77;
let List.294 : Int1 = CallByName Num.22 List.78 List.298;
if List.294 then
let List.296 : {} = CallByName List.60 List.77 List.78;
let List.295 : [C {}, C {}] = TagId(1) List.296;
ret List.295;
else
let List.280 : {} = Struct {};
let List.279 : [C {}, C {}] = TagId(0) List.280;
ret List.279;
let List.293 : {} = Struct {};
let List.292 : [C {}, C {}] = TagId(0) List.293;
ret List.292;
procedure List.6 (#Attr.2):
let List.288 : U64 = lowlevel ListLen #Attr.2;
ret List.288;
let List.301 : U64 = lowlevel ListLen #Attr.2;
ret List.301;
procedure List.60 (#Attr.2, #Attr.3):
let List.287 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.287;
let List.300 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.300;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Test.2 (Test.6):
let Test.18 : Str = "bar";

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

@ -1,6 +1,16 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.279 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.279;
procedure List.4 (List.88, List.89):
let List.295 : U64 = 1i64;
let List.293 : List U8 = CallByName List.65 List.88 List.295;
let List.292 : List U8 = CallByName List.66 List.293 List.89;
ret List.292;
procedure List.65 (#Attr.2, #Attr.3):
let List.298 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
ret List.298;
procedure List.66 (#Attr.2, #Attr.3):
let List.297 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.297;
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.189 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.189;
let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.258;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.188 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.257;
procedure Test.1 (Test.15, Test.16):
joinpoint Test.7 Test.2 Test.3:

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

@ -1,10 +1,10 @@
procedure List.6 (#Attr.2):
let List.279 : U64 = lowlevel ListLen #Attr.2;
ret List.279;
let List.292 : U64 = lowlevel ListLen #Attr.2;
ret List.292;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.190 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.190;
let Num.259 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.259;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
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.188 : I64 = lowlevel NumRound #Attr.2;
ret Num.188;
let Num.257 : I64 = lowlevel NumRound #Attr.2;
ret Num.257;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.1 : I64 = 3i64;

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

@ -1,14 +1,22 @@
procedure Num.40 (#Attr.2, #Attr.3):
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;
procedure Bool.7 (#Attr.2, #Attr.3):
let Bool.9 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.9;
procedure Num.39 (#Attr.2, #Attr.3):
let Num.264 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
ret Num.264;
procedure Num.40 (Num.229, Num.230):
let Num.263 : I64 = 0i64;
let Num.260 : Int1 = CallByName Bool.7 Num.230 Num.263;
if Num.260 then
let Num.262 : {} = Struct {};
let Num.261 : [C {}, C I64] = TagId(0) Num.262;
ret Num.261;
else
let Num.189 : {} = Struct {};
let Num.188 : [C {}, C I64] = TagId(0) Num.189;
ret Num.188;
let Num.258 : I64 = CallByName Num.39 Num.229 Num.230;
let Num.257 : [C {}, C I64] = TagId(1) Num.258;
ret Num.257;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.10 : I64 = 41i64;

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

@ -1,55 +1,67 @@
procedure List.2 (List.75, List.76):
let List.294 : U64 = CallByName List.6 List.75;
let List.290 : Int1 = CallByName Num.22 List.76 List.294;
if List.290 then
let List.292 : I64 = CallByName List.60 List.75 List.76;
let List.291 : [C {}, C I64] = TagId(1) List.292;
ret List.291;
procedure Bool.7 (#Attr.2, #Attr.3):
let Bool.9 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.9;
procedure List.2 (List.77, List.78):
let List.307 : U64 = CallByName List.6 List.77;
let List.303 : Int1 = CallByName Num.22 List.78 List.307;
if List.303 then
let List.305 : I64 = CallByName List.60 List.77 List.78;
let List.304 : [C {}, C I64] = TagId(1) List.305;
ret List.304;
else
let List.289 : {} = Struct {};
let List.288 : [C {}, C I64] = TagId(0) List.289;
ret List.288;
let List.302 : {} = Struct {};
let List.301 : [C {}, C I64] = TagId(0) List.302;
ret List.301;
procedure List.6 (#Attr.2):
let List.295 : U64 = lowlevel ListLen #Attr.2;
ret List.295;
let List.308 : U64 = lowlevel ListLen #Attr.2;
ret List.308;
procedure List.60 (#Attr.2, #Attr.3):
let List.293 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.293;
let List.306 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.306;
procedure List.9 (List.201):
let List.286 : U64 = 0i64;
let List.279 : [C {}, C I64] = CallByName List.2 List.201 List.286;
let List.283 : U8 = 1i64;
let List.284 : U8 = GetTagId List.279;
let List.285 : Int1 = lowlevel Eq List.283 List.284;
if List.285 then
let List.202 : I64 = UnionAtIndex (Id 1) (Index 0) List.279;
let List.280 : [C Int1, C I64] = TagId(1) List.202;
ret List.280;
procedure List.9 (List.205):
let List.299 : U64 = 0i64;
let List.292 : [C {}, C I64] = CallByName List.2 List.205 List.299;
let List.296 : U8 = 1i64;
let List.297 : U8 = GetTagId List.292;
let List.298 : Int1 = lowlevel Eq List.296 List.297;
if List.298 then
let List.206 : I64 = UnionAtIndex (Id 1) (Index 0) List.292;
let List.293 : [C Int1, C I64] = TagId(1) List.206;
ret List.293;
else
let List.282 : Int1 = true;
let List.281 : [C Int1, C I64] = TagId(0) List.282;
ret List.281;
let List.295 : Int1 = true;
let List.294 : [C Int1, C I64] = TagId(0) List.295;
ret List.294;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Str.27 (#Attr.2):
let #Attr.3 : {I64, U8} = lowlevel StrToNum #Attr.2;
let Str.159 : U8 = StructAtIndex 1 #Attr.3;
let Str.160 : U8 = 0i64;
let Str.156 : Int1 = lowlevel NumGt Str.159 Str.160;
if Str.156 then
let Str.158 : Int1 = false;
let Str.157 : [C Int1, C I64] = TagId(0) Str.158;
ret Str.157;
procedure Str.27 (Str.88):
let Str.194 : [C Int1, C I64] = CallByName Str.67 Str.88;
ret Str.194;
procedure Str.47 (#Attr.2):
let Str.203 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.203;
procedure Str.67 (Str.189):
let Str.190 : {I64, U8} = CallByName Str.47 Str.189;
let Str.201 : U8 = StructAtIndex 1 Str.190;
let Str.202 : U8 = 0i64;
let Str.198 : Int1 = CallByName Bool.7 Str.201 Str.202;
if Str.198 then
let Str.200 : I64 = StructAtIndex 0 Str.190;
let Str.199 : [C Int1, C I64] = TagId(1) Str.200;
ret Str.199;
else
let Str.155 : I64 = StructAtIndex 0 #Attr.3;
let Str.154 : [C Int1, C I64] = TagId(1) Str.155;
ret Str.154;
let Str.197 : Int1 = false;
let Str.196 : [C Int1, C I64] = TagId(0) Str.197;
ret Str.196;
procedure Test.0 ():
let Test.4 : Int1 = true;

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

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

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

@ -1,6 +1,16 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.279 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.279;
procedure List.4 (List.88, List.89):
let List.295 : U64 = 1i64;
let List.293 : List I64 = CallByName List.65 List.88 List.295;
let List.292 : List I64 = CallByName List.66 List.293 List.89;
ret List.292;
procedure List.65 (#Attr.2, #Attr.3):
let List.298 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
ret List.298;
procedure List.66 (#Attr.2, #Attr.3):
let List.297 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.297;
procedure Test.0 ():
let Test.2 : List I64 = Array [1i64];

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

@ -1,6 +1,16 @@
procedure List.4 (#Attr.2, #Attr.3):
let List.279 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
ret List.279;
procedure List.4 (List.88, List.89):
let List.295 : U64 = 1i64;
let List.293 : List I64 = CallByName List.65 List.88 List.295;
let List.292 : List I64 = CallByName List.66 List.293 List.89;
ret List.292;
procedure List.65 (#Attr.2, #Attr.3):
let List.298 : List I64 = lowlevel ListReserve #Attr.2 #Attr.3;
ret List.298;
procedure List.66 (#Attr.2, #Attr.3):
let List.297 : List I64 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.297;
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.83, List.84, List.85):
let List.282 : {List I64, I64} = CallByName List.57 List.83 List.84 List.85;
let List.281 : List I64 = StructAtIndex 0 List.282;
inc List.281;
dec List.282;
ret List.281;
procedure List.3 (List.85, List.86, List.87):
let List.295 : {List I64, I64} = CallByName List.57 List.85 List.86 List.87;
let List.294 : List I64 = StructAtIndex 0 List.295;
inc List.294;
dec List.295;
ret List.294;
procedure List.57 (List.80, List.81, List.82):
let List.288 : U64 = CallByName List.6 List.80;
let List.285 : Int1 = CallByName Num.22 List.81 List.288;
if List.285 then
let List.286 : {List I64, I64} = CallByName List.61 List.80 List.81 List.82;
ret List.286;
procedure List.57 (List.82, List.83, List.84):
let List.301 : U64 = CallByName List.6 List.82;
let List.298 : Int1 = CallByName Num.22 List.83 List.301;
if List.298 then
let List.299 : {List I64, I64} = CallByName List.61 List.82 List.83 List.84;
ret List.299;
else
let List.284 : {List I64, I64} = Struct {List.80, List.82};
ret List.284;
let List.297 : {List I64, I64} = Struct {List.82, List.84};
ret List.297;
procedure List.6 (#Attr.2):
let List.280 : U64 = lowlevel ListLen #Attr.2;
ret List.280;
let List.293 : U64 = lowlevel ListLen #Attr.2;
ret List.293;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.287 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.287;
let List.300 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.300;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.189 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.189;
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
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.285 : U64 = CallByName List.6 List.75;
let List.281 : Int1 = CallByName Num.22 List.76 List.285;
if List.281 then
let List.283 : I64 = CallByName List.60 List.75 List.76;
let List.282 : [C {}, C I64] = TagId(1) List.283;
ret List.282;
procedure List.2 (List.77, List.78):
let List.298 : U64 = CallByName List.6 List.77;
let List.294 : Int1 = CallByName Num.22 List.78 List.298;
if List.294 then
let List.296 : I64 = CallByName List.60 List.77 List.78;
let List.295 : [C {}, C I64] = TagId(1) List.296;
ret List.295;
else
let List.280 : {} = Struct {};
let List.279 : [C {}, C I64] = TagId(0) List.280;
ret List.279;
let List.293 : {} = Struct {};
let List.292 : [C {}, C I64] = TagId(0) List.293;
ret List.292;
procedure List.6 (#Attr.2):
let List.288 : U64 = lowlevel ListLen #Attr.2;
ret List.288;
let List.301 : U64 = lowlevel ListLen #Attr.2;
ret List.301;
procedure List.60 (#Attr.2, #Attr.3):
let List.287 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.287;
let List.300 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.300;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
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.279 : U64 = lowlevel ListLen #Attr.2;
ret List.279;
let List.292 : U64 = lowlevel ListLen #Attr.2;
ret List.292;
procedure List.6 (#Attr.2):
let List.280 : U64 = lowlevel ListLen #Attr.2;
ret List.280;
let List.293 : U64 = lowlevel ListLen #Attr.2;
ret List.293;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
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.285 : U64 = CallByName List.6 List.75;
let List.281 : Int1 = CallByName Num.22 List.76 List.285;
if List.281 then
let List.283 : Str = CallByName List.60 List.75 List.76;
let List.282 : [C {}, C Str] = TagId(1) List.283;
ret List.282;
procedure List.2 (List.77, List.78):
let List.298 : U64 = CallByName List.6 List.77;
let List.294 : Int1 = CallByName Num.22 List.78 List.298;
if List.294 then
let List.296 : Str = CallByName List.60 List.77 List.78;
let List.295 : [C {}, C Str] = TagId(1) List.296;
ret List.295;
else
let List.280 : {} = Struct {};
let List.279 : [C {}, C Str] = TagId(0) List.280;
ret List.279;
let List.293 : {} = Struct {};
let List.292 : [C {}, C Str] = TagId(0) List.293;
ret List.292;
procedure List.5 (#Attr.2, #Attr.3):
let List.287 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
ret List.287;
let List.300 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
ret List.300;
procedure List.6 (#Attr.2):
let List.289 : U64 = lowlevel ListLen #Attr.2;
ret List.289;
let List.302 : U64 = lowlevel ListLen #Attr.2;
ret List.302;
procedure List.60 (#Attr.2, #Attr.3):
let List.288 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.288;
let List.301 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.301;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.154 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.154;
let Str.194 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.194;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.155 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.155;
let Str.195 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.195;
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.285 : U64 = CallByName List.6 List.75;
let List.281 : Int1 = CallByName Num.22 List.76 List.285;
if List.281 then
let List.283 : Str = CallByName List.60 List.75 List.76;
let List.282 : [C {}, C Str] = TagId(1) List.283;
ret List.282;
procedure List.2 (List.77, List.78):
let List.298 : U64 = CallByName List.6 List.77;
let List.294 : Int1 = CallByName Num.22 List.78 List.298;
if List.294 then
let List.296 : Str = CallByName List.60 List.77 List.78;
let List.295 : [C {}, C Str] = TagId(1) List.296;
ret List.295;
else
let List.280 : {} = Struct {};
let List.279 : [C {}, C Str] = TagId(0) List.280;
ret List.279;
let List.293 : {} = Struct {};
let List.292 : [C {}, C Str] = TagId(0) List.293;
ret List.292;
procedure List.5 (#Attr.2, #Attr.3):
inc #Attr.2;
let List.287 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
let List.300 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
decref #Attr.2;
ret List.287;
ret List.300;
procedure List.6 (#Attr.2):
let List.289 : U64 = lowlevel ListLen #Attr.2;
ret List.289;
let List.302 : U64 = lowlevel ListLen #Attr.2;
ret List.302;
procedure List.60 (#Attr.2, #Attr.3):
let List.288 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.288;
let List.301 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.301;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.155 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.155;
let Str.195 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.195;
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.83, List.84, List.85):
let List.280 : {List I64, I64} = CallByName List.57 List.83 List.84 List.85;
let List.279 : List I64 = StructAtIndex 0 List.280;
inc List.279;
dec List.280;
ret List.279;
procedure List.3 (List.85, List.86, List.87):
let List.293 : {List I64, I64} = CallByName List.57 List.85 List.86 List.87;
let List.292 : List I64 = StructAtIndex 0 List.293;
inc List.292;
dec List.293;
ret List.292;
procedure List.57 (List.80, List.81, List.82):
let List.286 : U64 = CallByName List.6 List.80;
let List.283 : Int1 = CallByName Num.22 List.81 List.286;
if List.283 then
let List.284 : {List I64, I64} = CallByName List.61 List.80 List.81 List.82;
ret List.284;
procedure List.57 (List.82, List.83, List.84):
let List.299 : U64 = CallByName List.6 List.82;
let List.296 : Int1 = CallByName Num.22 List.83 List.299;
if List.296 then
let List.297 : {List I64, I64} = CallByName List.61 List.82 List.83 List.84;
ret List.297;
else
let List.282 : {List I64, I64} = Struct {List.80, List.82};
ret List.282;
let List.295 : {List I64, I64} = Struct {List.82, List.84};
ret List.295;
procedure List.6 (#Attr.2):
let List.287 : U64 = lowlevel ListLen #Attr.2;
ret List.287;
let List.300 : U64 = lowlevel ListLen #Attr.2;
ret List.300;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.285 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.285;
let List.298 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.298;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
procedure Test.2 (Test.3):
let Test.6 : U64 = 0i64;

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

@ -1,20 +1,20 @@
procedure List.28 (#Attr.2, #Attr.3):
let List.282 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
let List.295 : 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.282;
ret List.295;
else
decref #Attr.2;
ret List.282;
ret List.295;
procedure List.54 (List.196):
let List.280 : {} = Struct {};
let List.279 : List I64 = CallByName List.28 List.196 List.280;
ret List.279;
procedure List.54 (List.200):
let List.293 : {} = Struct {};
let List.292 : List I64 = CallByName List.28 List.200 List.293;
ret List.292;
procedure Num.46 (#Attr.2, #Attr.3):
let Num.188 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.2 : List I64 = Array [4i64, 3i64, 2i64, 1i64];

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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
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.190 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.190;
let Num.259 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.259;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.189 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.189;
let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.258;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.190;
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.259;
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.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] = TagId(1) List.297;
ret List.296;
procedure List.2 (List.77, List.78):
let List.312 : U64 = CallByName List.6 List.77;
let List.308 : Int1 = CallByName Num.22 List.78 List.312;
if List.308 then
let List.310 : I64 = CallByName List.60 List.77 List.78;
let List.309 : [C {}, C I64] = TagId(1) List.310;
ret List.309;
else
let List.294 : {} = Struct {};
let List.293 : [C {}, C I64] = TagId(0) List.294;
ret List.293;
let List.307 : {} = Struct {};
let List.306 : [C {}, C I64] = TagId(0) List.307;
ret List.306;
procedure List.3 (List.83, List.84, List.85):
let List.283 : {List I64, I64} = CallByName List.57 List.83 List.84 List.85;
let List.282 : List I64 = StructAtIndex 0 List.283;
inc List.282;
dec List.283;
ret List.282;
procedure List.3 (List.85, List.86, List.87):
let List.296 : {List I64, I64} = CallByName List.57 List.85 List.86 List.87;
let List.295 : List I64 = StructAtIndex 0 List.296;
inc List.295;
dec List.296;
ret List.295;
procedure List.57 (List.80, List.81, List.82):
let List.305 : U64 = CallByName List.6 List.80;
let List.302 : Int1 = CallByName Num.22 List.81 List.305;
if List.302 then
let List.303 : {List I64, I64} = CallByName List.61 List.80 List.81 List.82;
ret List.303;
procedure List.57 (List.82, List.83, List.84):
let List.318 : U64 = CallByName List.6 List.82;
let List.315 : Int1 = CallByName Num.22 List.83 List.318;
if List.315 then
let List.316 : {List I64, I64} = CallByName List.61 List.82 List.83 List.84;
ret List.316;
else
let List.301 : {List I64, I64} = Struct {List.80, List.82};
ret List.301;
let List.314 : {List I64, I64} = Struct {List.82, List.84};
ret List.314;
procedure List.6 (#Attr.2):
let List.306 : U64 = lowlevel ListLen #Attr.2;
ret List.306;
let List.319 : U64 = lowlevel ListLen #Attr.2;
ret List.319;
procedure List.60 (#Attr.2, #Attr.3):
let List.307 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.307;
let List.320 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.320;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.304 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.304;
let List.317 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.317;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.190;
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.259;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
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.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] = TagId(1) List.297;
ret List.296;
procedure List.2 (List.77, List.78):
let List.312 : U64 = CallByName List.6 List.77;
let List.308 : Int1 = CallByName Num.22 List.78 List.312;
if List.308 then
let List.310 : I64 = CallByName List.60 List.77 List.78;
let List.309 : [C {}, C I64] = TagId(1) List.310;
ret List.309;
else
let List.294 : {} = Struct {};
let List.293 : [C {}, C I64] = TagId(0) List.294;
ret List.293;
let List.307 : {} = Struct {};
let List.306 : [C {}, C I64] = TagId(0) List.307;
ret List.306;
procedure List.3 (List.83, List.84, List.85):
let List.283 : {List I64, I64} = CallByName List.57 List.83 List.84 List.85;
let List.282 : List I64 = StructAtIndex 0 List.283;
inc List.282;
dec List.283;
ret List.282;
procedure List.3 (List.85, List.86, List.87):
let List.296 : {List I64, I64} = CallByName List.57 List.85 List.86 List.87;
let List.295 : List I64 = StructAtIndex 0 List.296;
inc List.295;
dec List.296;
ret List.295;
procedure List.57 (List.80, List.81, List.82):
let List.305 : U64 = CallByName List.6 List.80;
let List.302 : Int1 = CallByName Num.22 List.81 List.305;
if List.302 then
let List.303 : {List I64, I64} = CallByName List.61 List.80 List.81 List.82;
ret List.303;
procedure List.57 (List.82, List.83, List.84):
let List.318 : U64 = CallByName List.6 List.82;
let List.315 : Int1 = CallByName Num.22 List.83 List.318;
if List.315 then
let List.316 : {List I64, I64} = CallByName List.61 List.82 List.83 List.84;
ret List.316;
else
let List.301 : {List I64, I64} = Struct {List.80, List.82};
ret List.301;
let List.314 : {List I64, I64} = Struct {List.82, List.84};
ret List.314;
procedure List.6 (#Attr.2):
let List.306 : U64 = lowlevel ListLen #Attr.2;
ret List.306;
let List.319 : U64 = lowlevel ListLen #Attr.2;
ret List.319;
procedure List.60 (#Attr.2, #Attr.3):
let List.307 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.307;
let List.320 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.320;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.304 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.304;
let List.317 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.317;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.190;
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.259;
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.189 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.189;
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.188 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.257;
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.189 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.189;
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.188 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.257;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.189 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.189;
let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.258;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
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.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.188;
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.0 ():
let Test.15 : I64 = 3i64;