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

Merge remote-tracking branch 'origin/main' into glue-getters-rtfeldman

Browse source
This commit is contained in:
Folkert 2023-03-14 01:01:26 +01:00
commit fdf1489df6
No known key found for this signature in database
GPG key ID: 1F17F6FFD112B97C
159 changed files with 4458 additions and 6232 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -84,16 +84,16 @@ procedure List.91 (List.429, List.430, List.431):
ret List.514;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.277;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.259;
let Num.278 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.278;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.257 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.276;
procedure Test.1 (Test.2):
let Test.13 : U64 = 0i64;

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

@ -45,8 +45,8 @@ procedure List.9 (List.286):
ret List.495;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.256 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Result.5 (Result.12, Result.13):
let Result.39 : U8 = 1i64;

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.257 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.276;
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.256 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
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.256 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.0 ():
let Test.2 : U64 = 9999999999999999999i64;

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

@ -74,12 +74,12 @@ procedure List.81 (List.525, List.526, List.527):
jump List.507 List.525 List.526 List.527;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.257 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.276;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.259 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.259;
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.278;
procedure Test.0 ():
let Test.3 : {} = Struct {};

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

@ -23,8 +23,8 @@ procedure List.66 (#Attr.2, #Attr.3):
ret List.498;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.256 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Test.2 (Test.5):
let Test.17 : Str = "bar";

280
crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt
View file

@ -44,7 +44,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.112 Encode.94 Encode.96 Encode.102;
let Encode.113 : List U8 = CallByName Json.115 Encode.94 Encode.96 Encode.102;
ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
@ -52,11 +52,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.115;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.125 : List U8 = CallByName Json.112 Encode.94 Encode.96 Encode.102;
let Encode.125 : List U8 = CallByName Json.115 Encode.94 Encode.96 Encode.102;
ret Encode.125;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.128 : List U8 = CallByName Json.96 Encode.94 Encode.96 Encode.102;
let Encode.128 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102;
ret Encode.128;
procedure Encode.25 (Encode.100, Encode.101):
@ -66,150 +66,150 @@ procedure Encode.25 (Encode.100, Encode.101):
ret Encode.103;
procedure Json.1 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.112 (Json.113, Json.399, Json.111):
let Json.432 : I64 = 123i64;
let Json.431 : U8 = CallByName Num.125 Json.432;
let Json.115 : List U8 = CallByName List.4 Json.113 Json.431;
let Json.430 : U64 = CallByName List.6 Json.111;
let Json.407 : {List U8, U64} = Struct {Json.115, Json.430};
let Json.408 : {} = Struct {};
let Json.406 : {List U8, U64} = CallByName List.18 Json.111 Json.407 Json.408;
dec Json.111;
let Json.117 : List U8 = StructAtIndex 0 Json.406;
inc Json.117;
dec Json.406;
let Json.405 : I64 = 125i64;
let Json.404 : U8 = CallByName Num.125 Json.405;
let Json.403 : List U8 = CallByName List.4 Json.117 Json.404;
ret Json.403;
procedure Json.115 (Json.116, Json.428, Json.114):
let Json.461 : I64 = 123i64;
let Json.460 : U8 = CallByName Num.127 Json.461;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.460;
let Json.459 : U64 = CallByName List.6 Json.114;
let Json.436 : {List U8, U64} = Struct {Json.118, Json.459};
let Json.437 : {} = Struct {};
let Json.435 : {List U8, U64} = CallByName List.18 Json.114 Json.436 Json.437;
dec Json.114;
let Json.120 : List U8 = StructAtIndex 0 Json.435;
inc Json.120;
dec Json.435;
let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.432 : List U8 = CallByName List.4 Json.120 Json.433;
ret Json.432;
procedure Json.112 (Json.113, Json.399, Json.111):
let Json.472 : I64 = 123i64;
let Json.471 : U8 = CallByName Num.125 Json.472;
let Json.115 : List U8 = CallByName List.4 Json.113 Json.471;
let Json.470 : U64 = CallByName List.6 Json.111;
let Json.447 : {List U8, U64} = Struct {Json.115, Json.470};
procedure Json.115 (Json.116, Json.428, Json.114):
let Json.501 : I64 = 123i64;
let Json.500 : U8 = CallByName Num.127 Json.501;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.500;
let Json.499 : U64 = CallByName List.6 Json.114;
let Json.476 : {List U8, U64} = Struct {Json.118, Json.499};
let Json.477 : {} = Struct {};
let Json.475 : {List U8, U64} = CallByName List.18 Json.114 Json.476 Json.477;
dec Json.114;
let Json.120 : List U8 = StructAtIndex 0 Json.475;
inc Json.120;
dec Json.475;
let Json.474 : I64 = 125i64;
let Json.473 : U8 = CallByName Num.127 Json.474;
let Json.472 : List U8 = CallByName List.4 Json.120 Json.473;
ret Json.472;
procedure Json.117 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431;
inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430;
inc Json.121;
let Json.122 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.458 : I64 = 34i64;
let Json.457 : U8 = CallByName Num.127 Json.458;
let Json.455 : List U8 = CallByName List.4 Json.121 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.123;
let Json.452 : List U8 = CallByName List.8 Json.455 Json.456;
let Json.454 : I64 = 34i64;
let Json.453 : U8 = CallByName Num.127 Json.454;
let Json.449 : List U8 = CallByName List.4 Json.452 Json.453;
let Json.451 : I64 = 58i64;
let Json.450 : U8 = CallByName Num.127 Json.451;
let Json.447 : List U8 = CallByName List.4 Json.449 Json.450;
let Json.448 : {} = Struct {};
let Json.446 : {List U8, U64} = CallByName List.18 Json.111 Json.447 Json.448;
dec Json.111;
let Json.117 : List U8 = StructAtIndex 0 Json.446;
inc Json.117;
dec Json.446;
let Json.445 : I64 = 125i64;
let Json.444 : U8 = CallByName Num.125 Json.445;
let Json.443 : List U8 = CallByName List.4 Json.117 Json.444;
ret Json.443;
procedure Json.114 (Json.401, Json.402):
let Json.120 : Str = StructAtIndex 0 Json.402;
inc Json.120;
let Json.121 : Str = StructAtIndex 1 Json.402;
inc Json.121;
dec Json.402;
let Json.118 : List U8 = StructAtIndex 0 Json.401;
inc Json.118;
let Json.119 : U64 = StructAtIndex 1 Json.401;
dec Json.401;
let Json.429 : I64 = 34i64;
let Json.428 : U8 = CallByName Num.125 Json.429;
let Json.426 : List U8 = CallByName List.4 Json.118 Json.428;
let Json.427 : List U8 = CallByName Str.12 Json.120;
let Json.423 : List U8 = CallByName List.8 Json.426 Json.427;
let Json.425 : I64 = 34i64;
let Json.424 : U8 = CallByName Num.125 Json.425;
let Json.420 : List U8 = CallByName List.4 Json.423 Json.424;
let Json.422 : I64 = 58i64;
let Json.421 : U8 = CallByName Num.125 Json.422;
let Json.418 : List U8 = CallByName List.4 Json.420 Json.421;
let Json.419 : {} = Struct {};
let Json.122 : List U8 = CallByName Encode.23 Json.418 Json.121 Json.419;
joinpoint Json.413 Json.123:
let Json.411 : U64 = 1i64;
let Json.410 : U64 = CallByName Num.20 Json.119 Json.411;
let Json.409 : {List U8, U64} = Struct {Json.123, Json.410};
ret Json.409;
let Json.125 : List U8 = CallByName Encode.23 Json.447 Json.124 Json.448;
joinpoint Json.442 Json.126:
let Json.440 : U64 = 1i64;
let Json.439 : U64 = CallByName Num.20 Json.122 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.126, Json.439};
ret Json.438;
in
let Json.417 : U64 = 1i64;
let Json.414 : Int1 = CallByName Num.24 Json.119 Json.417;
if Json.414 then
let Json.416 : I64 = 44i64;
let Json.415 : U8 = CallByName Num.125 Json.416;
let Json.412 : List U8 = CallByName List.4 Json.122 Json.415;
jump Json.413 Json.412;
let Json.446 : U64 = 1i64;
let Json.443 : Int1 = CallByName Num.24 Json.122 Json.446;
if Json.443 then
let Json.445 : I64 = 44i64;
let Json.444 : U8 = CallByName Num.127 Json.445;
let Json.441 : List U8 = CallByName List.4 Json.125 Json.444;
jump Json.442 Json.441;
else
jump Json.413 Json.122;
jump Json.442 Json.125;
procedure Json.114 (Json.401, Json.402):
let Json.120 : Str = StructAtIndex 0 Json.402;
inc Json.120;
let Json.121 : Str = StructAtIndex 1 Json.402;
procedure Json.117 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431;
inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430;
inc Json.121;
dec Json.402;
let Json.118 : List U8 = StructAtIndex 0 Json.401;
inc Json.118;
let Json.119 : U64 = StructAtIndex 1 Json.401;
dec Json.401;
let Json.469 : I64 = 34i64;
let Json.468 : U8 = CallByName Num.125 Json.469;
let Json.466 : List U8 = CallByName List.4 Json.118 Json.468;
let Json.467 : List U8 = CallByName Str.12 Json.120;
let Json.463 : List U8 = CallByName List.8 Json.466 Json.467;
let Json.465 : I64 = 34i64;
let Json.464 : U8 = CallByName Num.125 Json.465;
let Json.460 : List U8 = CallByName List.4 Json.463 Json.464;
let Json.462 : I64 = 58i64;
let Json.461 : U8 = CallByName Num.125 Json.462;
let Json.458 : List U8 = CallByName List.4 Json.460 Json.461;
let Json.459 : {} = Struct {};
let Json.122 : List U8 = CallByName Encode.23 Json.458 Json.121 Json.459;
joinpoint Json.453 Json.123:
let Json.451 : U64 = 1i64;
let Json.450 : U64 = CallByName Num.20 Json.119 Json.451;
let Json.449 : {List U8, U64} = Struct {Json.123, Json.450};
ret Json.449;
let Json.122 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.498 : I64 = 34i64;
let Json.497 : U8 = CallByName Num.127 Json.498;
let Json.495 : List U8 = CallByName List.4 Json.121 Json.497;
let Json.496 : List U8 = CallByName Str.12 Json.123;
let Json.492 : List U8 = CallByName List.8 Json.495 Json.496;
let Json.494 : I64 = 34i64;
let Json.493 : U8 = CallByName Num.127 Json.494;
let Json.489 : List U8 = CallByName List.4 Json.492 Json.493;
let Json.491 : I64 = 58i64;
let Json.490 : U8 = CallByName Num.127 Json.491;
let Json.487 : List U8 = CallByName List.4 Json.489 Json.490;
let Json.488 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.487 Json.124 Json.488;
joinpoint Json.482 Json.126:
let Json.480 : U64 = 1i64;
let Json.479 : U64 = CallByName Num.20 Json.122 Json.480;
let Json.478 : {List U8, U64} = Struct {Json.126, Json.479};
ret Json.478;
in
let Json.457 : U64 = 1i64;
let Json.454 : Int1 = CallByName Num.24 Json.119 Json.457;
if Json.454 then
let Json.456 : I64 = 44i64;
let Json.455 : U8 = CallByName Num.125 Json.456;
let Json.452 : List U8 = CallByName List.4 Json.122 Json.455;
jump Json.453 Json.452;
let Json.486 : U64 = 1i64;
let Json.483 : Int1 = CallByName Num.24 Json.122 Json.486;
if Json.483 then
let Json.485 : I64 = 44i64;
let Json.484 : U8 = CallByName Num.127 Json.485;
let Json.481 : List U8 = CallByName List.4 Json.125 Json.484;
jump Json.482 Json.481;
else
jump Json.453 Json.122;
jump Json.482 Json.125;
procedure Json.18 (Json.95):
let Json.473 : Str = CallByName Encode.22 Json.95;
ret Json.473;
procedure Json.18 (Json.98):
let Json.502 : Str = CallByName Encode.22 Json.98;
ret Json.502;
procedure Json.20 (Json.111):
let Json.397 : List {Str, Str} = CallByName Encode.22 Json.111;
ret Json.397;
procedure Json.20 (Json.114):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.114;
ret Json.426;
procedure Json.20 (Json.111):
let Json.439 : List {Str, Str} = CallByName Encode.22 Json.111;
ret Json.439;
procedure Json.20 (Json.114):
let Json.468 : List {Str, Str} = CallByName Encode.22 Json.114;
ret Json.468;
procedure Json.96 (Json.97, Json.475, Json.95):
let Json.484 : I64 = 34i64;
let Json.483 : U8 = CallByName Num.125 Json.484;
let Json.481 : List U8 = CallByName List.4 Json.97 Json.483;
let Json.482 : List U8 = CallByName Str.12 Json.95;
let Json.478 : List U8 = CallByName List.8 Json.481 Json.482;
let Json.480 : I64 = 34i64;
let Json.479 : U8 = CallByName Num.125 Json.480;
let Json.477 : List U8 = CallByName List.4 Json.478 Json.479;
ret Json.477;
procedure Json.99 (Json.100, Json.504, Json.98):
let Json.513 : I64 = 34i64;
let Json.512 : U8 = CallByName Num.127 Json.513;
let Json.510 : List U8 = CallByName List.4 Json.100 Json.512;
let Json.511 : List U8 = CallByName Str.12 Json.98;
let Json.507 : List U8 = CallByName List.8 Json.510 Json.511;
let Json.509 : I64 = 34i64;
let Json.508 : U8 = CallByName Num.127 Json.509;
let Json.506 : List U8 = CallByName List.4 Json.507 Json.508;
ret Json.506;
procedure List.138 (List.139, List.140, List.137):
let List.534 : {List U8, U64} = CallByName Json.114 List.139 List.140;
let List.534 : {List U8, U64} = CallByName Json.117 List.139 List.140;
ret List.534;
procedure List.138 (List.139, List.140, List.137):
let List.607 : {List U8, U64} = CallByName Json.114 List.139 List.140;
let List.607 : {List U8, U64} = CallByName Json.117 List.139 List.140;
ret List.607;
procedure List.18 (List.135, List.136, List.137):
@ -298,25 +298,25 @@ procedure List.91 (List.429, List.430, List.431):
let List.591 : {List U8, U64} = CallByName List.80 List.429 List.430 List.431 List.592 List.593;
ret List.591;
procedure Num.125 (#Attr.2):
let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.282;
procedure Num.127 (#Attr.2):
let Num.301 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.301;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.285 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.285;
let Num.304 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.304;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.283 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.283;
let Num.302 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.302;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.286;
let Num.305 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.305;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.284 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.284;
let Num.303 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.303;
procedure Str.12 (#Attr.2):
let Str.282 : List U8 = lowlevel StrToUtf8 #Attr.2;

166
crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt
View file

@ -25,11 +25,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.112 Encode.94 Encode.96 Encode.102;
let Encode.113 : List U8 = CallByName Json.115 Encode.94 Encode.96 Encode.102;
ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.116 : List U8 = CallByName Json.96 Encode.94 Encode.96 Encode.102;
let Encode.116 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102;
ret Encode.116;
procedure Encode.25 (Encode.100, Encode.101):
@ -39,86 +39,86 @@ procedure Encode.25 (Encode.100, Encode.101):
ret Encode.103;
procedure Json.1 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.112 (Json.113, Json.399, Json.111):
let Json.432 : I64 = 123i64;
let Json.431 : U8 = CallByName Num.125 Json.432;
let Json.115 : List U8 = CallByName List.4 Json.113 Json.431;
let Json.430 : U64 = CallByName List.6 Json.111;
let Json.407 : {List U8, U64} = Struct {Json.115, Json.430};
let Json.408 : {} = Struct {};
let Json.406 : {List U8, U64} = CallByName List.18 Json.111 Json.407 Json.408;
dec Json.111;
let Json.117 : List U8 = StructAtIndex 0 Json.406;
inc Json.117;
dec Json.406;
let Json.405 : I64 = 125i64;
let Json.404 : U8 = CallByName Num.125 Json.405;
let Json.403 : List U8 = CallByName List.4 Json.117 Json.404;
ret Json.403;
procedure Json.114 (Json.401, Json.402):
let Json.120 : Str = StructAtIndex 0 Json.402;
procedure Json.115 (Json.116, Json.428, Json.114):
let Json.461 : I64 = 123i64;
let Json.460 : U8 = CallByName Num.127 Json.461;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.460;
let Json.459 : U64 = CallByName List.6 Json.114;
let Json.436 : {List U8, U64} = Struct {Json.118, Json.459};
let Json.437 : {} = Struct {};
let Json.435 : {List U8, U64} = CallByName List.18 Json.114 Json.436 Json.437;
dec Json.114;
let Json.120 : List U8 = StructAtIndex 0 Json.435;
inc Json.120;
let Json.121 : Str = StructAtIndex 1 Json.402;
dec Json.435;
let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.432 : List U8 = CallByName List.4 Json.120 Json.433;
ret Json.432;
procedure Json.117 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431;
inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430;
inc Json.121;
dec Json.402;
let Json.118 : List U8 = StructAtIndex 0 Json.401;
inc Json.118;
let Json.119 : U64 = StructAtIndex 1 Json.401;
dec Json.401;
let Json.429 : I64 = 34i64;
let Json.428 : U8 = CallByName Num.125 Json.429;
let Json.426 : List U8 = CallByName List.4 Json.118 Json.428;
let Json.427 : List U8 = CallByName Str.12 Json.120;
let Json.423 : List U8 = CallByName List.8 Json.426 Json.427;
let Json.425 : I64 = 34i64;
let Json.424 : U8 = CallByName Num.125 Json.425;
let Json.420 : List U8 = CallByName List.4 Json.423 Json.424;
let Json.422 : I64 = 58i64;
let Json.421 : U8 = CallByName Num.125 Json.422;
let Json.418 : List U8 = CallByName List.4 Json.420 Json.421;
let Json.419 : {} = Struct {};
let Json.122 : List U8 = CallByName Encode.23 Json.418 Json.121 Json.419;
joinpoint Json.413 Json.123:
let Json.411 : U64 = 1i64;
let Json.410 : U64 = CallByName Num.20 Json.119 Json.411;
let Json.409 : {List U8, U64} = Struct {Json.123, Json.410};
ret Json.409;
let Json.122 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.458 : I64 = 34i64;
let Json.457 : U8 = CallByName Num.127 Json.458;
let Json.455 : List U8 = CallByName List.4 Json.121 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.123;
let Json.452 : List U8 = CallByName List.8 Json.455 Json.456;
let Json.454 : I64 = 34i64;
let Json.453 : U8 = CallByName Num.127 Json.454;
let Json.449 : List U8 = CallByName List.4 Json.452 Json.453;
let Json.451 : I64 = 58i64;
let Json.450 : U8 = CallByName Num.127 Json.451;
let Json.447 : List U8 = CallByName List.4 Json.449 Json.450;
let Json.448 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.447 Json.124 Json.448;
joinpoint Json.442 Json.126:
let Json.440 : U64 = 1i64;
let Json.439 : U64 = CallByName Num.20 Json.122 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.126, Json.439};
ret Json.438;
in
let Json.417 : U64 = 1i64;
let Json.414 : Int1 = CallByName Num.24 Json.119 Json.417;
if Json.414 then
let Json.416 : I64 = 44i64;
let Json.415 : U8 = CallByName Num.125 Json.416;
let Json.412 : List U8 = CallByName List.4 Json.122 Json.415;
jump Json.413 Json.412;
let Json.446 : U64 = 1i64;
let Json.443 : Int1 = CallByName Num.24 Json.122 Json.446;
if Json.443 then
let Json.445 : I64 = 44i64;
let Json.444 : U8 = CallByName Num.127 Json.445;
let Json.441 : List U8 = CallByName List.4 Json.125 Json.444;
jump Json.442 Json.441;
else
jump Json.413 Json.122;
jump Json.442 Json.125;
procedure Json.18 (Json.95):
let Json.433 : Str = CallByName Encode.22 Json.95;
ret Json.433;
procedure Json.18 (Json.98):
let Json.462 : Str = CallByName Encode.22 Json.98;
ret Json.462;
procedure Json.20 (Json.111):
let Json.397 : List {Str, Str} = CallByName Encode.22 Json.111;
ret Json.397;
procedure Json.20 (Json.114):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.114;
ret Json.426;
procedure Json.96 (Json.97, Json.435, Json.95):
let Json.444 : I64 = 34i64;
let Json.443 : U8 = CallByName Num.125 Json.444;
let Json.441 : List U8 = CallByName List.4 Json.97 Json.443;
let Json.442 : List U8 = CallByName Str.12 Json.95;
let Json.438 : List U8 = CallByName List.8 Json.441 Json.442;
let Json.440 : I64 = 34i64;
let Json.439 : U8 = CallByName Num.125 Json.440;
let Json.437 : List U8 = CallByName List.4 Json.438 Json.439;
ret Json.437;
procedure Json.99 (Json.100, Json.464, Json.98):
let Json.473 : I64 = 34i64;
let Json.472 : U8 = CallByName Num.127 Json.473;
let Json.470 : List U8 = CallByName List.4 Json.100 Json.472;
let Json.471 : List U8 = CallByName Str.12 Json.98;
let Json.467 : List U8 = CallByName List.8 Json.470 Json.471;
let Json.469 : I64 = 34i64;
let Json.468 : U8 = CallByName Num.127 Json.469;
let Json.466 : List U8 = CallByName List.4 Json.467 Json.468;
ret Json.466;
procedure List.138 (List.139, List.140, List.137):
let List.540 : {List U8, U64} = CallByName Json.114 List.139 List.140;
let List.540 : {List U8, U64} = CallByName Json.117 List.139 List.140;
ret List.540;
procedure List.18 (List.135, List.136, List.137):
@ -175,25 +175,25 @@ procedure List.91 (List.429, List.430, List.431):
let List.524 : {List U8, U64} = CallByName List.80 List.429 List.430 List.431 List.525 List.526;
ret List.524;
procedure Num.125 (#Attr.2):
let Num.263 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.263;
procedure Num.127 (#Attr.2):
let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.282;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.266 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.266;
let Num.285 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.285;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.264 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.264;
let Num.283 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.283;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.267;
let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.286;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.265 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.265;
let Num.284 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.284;
procedure Str.12 (#Attr.2):
let Str.280 : List U8 = lowlevel StrToUtf8 #Attr.2;

166
crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt
View file

@ -33,11 +33,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.112 Encode.94 Encode.96 Encode.102;
let Encode.113 : List U8 = CallByName Json.115 Encode.94 Encode.96 Encode.102;
ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.117 : List U8 = CallByName Json.96 Encode.94 Encode.96 Encode.102;
let Encode.117 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102;
ret Encode.117;
procedure Encode.25 (Encode.100, Encode.101):
@ -47,86 +47,86 @@ procedure Encode.25 (Encode.100, Encode.101):
ret Encode.103;
procedure Json.1 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.112 (Json.113, Json.399, Json.111):
let Json.432 : I64 = 123i64;
let Json.431 : U8 = CallByName Num.125 Json.432;
let Json.115 : List U8 = CallByName List.4 Json.113 Json.431;
let Json.430 : U64 = CallByName List.6 Json.111;
let Json.407 : {List U8, U64} = Struct {Json.115, Json.430};
let Json.408 : {} = Struct {};
let Json.406 : {List U8, U64} = CallByName List.18 Json.111 Json.407 Json.408;
dec Json.111;
let Json.117 : List U8 = StructAtIndex 0 Json.406;
inc Json.117;
dec Json.406;
let Json.405 : I64 = 125i64;
let Json.404 : U8 = CallByName Num.125 Json.405;
let Json.403 : List U8 = CallByName List.4 Json.117 Json.404;
ret Json.403;
procedure Json.114 (Json.401, Json.402):
let Json.120 : Str = StructAtIndex 0 Json.402;
procedure Json.115 (Json.116, Json.428, Json.114):
let Json.461 : I64 = 123i64;
let Json.460 : U8 = CallByName Num.127 Json.461;
let Json.118 : List U8 = CallByName List.4 Json.116 Json.460;
let Json.459 : U64 = CallByName List.6 Json.114;
let Json.436 : {List U8, U64} = Struct {Json.118, Json.459};
let Json.437 : {} = Struct {};
let Json.435 : {List U8, U64} = CallByName List.18 Json.114 Json.436 Json.437;
dec Json.114;
let Json.120 : List U8 = StructAtIndex 0 Json.435;
inc Json.120;
let Json.121 : Str = StructAtIndex 1 Json.402;
dec Json.435;
let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.432 : List U8 = CallByName List.4 Json.120 Json.433;
ret Json.432;
procedure Json.117 (Json.430, Json.431):
let Json.123 : Str = StructAtIndex 0 Json.431;
inc Json.123;
let Json.124 : Str = StructAtIndex 1 Json.431;
inc Json.124;
dec Json.431;
let Json.121 : List U8 = StructAtIndex 0 Json.430;
inc Json.121;
dec Json.402;
let Json.118 : List U8 = StructAtIndex 0 Json.401;
inc Json.118;
let Json.119 : U64 = StructAtIndex 1 Json.401;
dec Json.401;
let Json.429 : I64 = 34i64;
let Json.428 : U8 = CallByName Num.125 Json.429;
let Json.426 : List U8 = CallByName List.4 Json.118 Json.428;
let Json.427 : List U8 = CallByName Str.12 Json.120;
let Json.423 : List U8 = CallByName List.8 Json.426 Json.427;
let Json.425 : I64 = 34i64;
let Json.424 : U8 = CallByName Num.125 Json.425;
let Json.420 : List U8 = CallByName List.4 Json.423 Json.424;
let Json.422 : I64 = 58i64;
let Json.421 : U8 = CallByName Num.125 Json.422;
let Json.418 : List U8 = CallByName List.4 Json.420 Json.421;
let Json.419 : {} = Struct {};
let Json.122 : List U8 = CallByName Encode.23 Json.418 Json.121 Json.419;
joinpoint Json.413 Json.123:
let Json.411 : U64 = 1i64;
let Json.410 : U64 = CallByName Num.20 Json.119 Json.411;
let Json.409 : {List U8, U64} = Struct {Json.123, Json.410};
ret Json.409;
let Json.122 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.458 : I64 = 34i64;
let Json.457 : U8 = CallByName Num.127 Json.458;
let Json.455 : List U8 = CallByName List.4 Json.121 Json.457;
let Json.456 : List U8 = CallByName Str.12 Json.123;
let Json.452 : List U8 = CallByName List.8 Json.455 Json.456;
let Json.454 : I64 = 34i64;
let Json.453 : U8 = CallByName Num.127 Json.454;
let Json.449 : List U8 = CallByName List.4 Json.452 Json.453;
let Json.451 : I64 = 58i64;
let Json.450 : U8 = CallByName Num.127 Json.451;
let Json.447 : List U8 = CallByName List.4 Json.449 Json.450;
let Json.448 : {} = Struct {};
let Json.125 : List U8 = CallByName Encode.23 Json.447 Json.124 Json.448;
joinpoint Json.442 Json.126:
let Json.440 : U64 = 1i64;
let Json.439 : U64 = CallByName Num.20 Json.122 Json.440;
let Json.438 : {List U8, U64} = Struct {Json.126, Json.439};
ret Json.438;
in
let Json.417 : U64 = 1i64;
let Json.414 : Int1 = CallByName Num.24 Json.119 Json.417;
if Json.414 then
let Json.416 : I64 = 44i64;
let Json.415 : U8 = CallByName Num.125 Json.416;
let Json.412 : List U8 = CallByName List.4 Json.122 Json.415;
jump Json.413 Json.412;
let Json.446 : U64 = 1i64;
let Json.443 : Int1 = CallByName Num.24 Json.122 Json.446;
if Json.443 then
let Json.445 : I64 = 44i64;
let Json.444 : U8 = CallByName Num.127 Json.445;
let Json.441 : List U8 = CallByName List.4 Json.125 Json.444;
jump Json.442 Json.441;
else
jump Json.413 Json.122;
jump Json.442 Json.125;
procedure Json.18 (Json.95):
let Json.445 : Str = CallByName Encode.22 Json.95;
ret Json.445;
procedure Json.18 (Json.98):
let Json.474 : Str = CallByName Encode.22 Json.98;
ret Json.474;
procedure Json.20 (Json.111):
let Json.397 : List {Str, Str} = CallByName Encode.22 Json.111;
ret Json.397;
procedure Json.20 (Json.114):
let Json.426 : List {Str, Str} = CallByName Encode.22 Json.114;
ret Json.426;
procedure Json.96 (Json.97, Json.435, Json.95):
let Json.444 : I64 = 34i64;
let Json.443 : U8 = CallByName Num.125 Json.444;
let Json.441 : List U8 = CallByName List.4 Json.97 Json.443;
let Json.442 : List U8 = CallByName Str.12 Json.95;
let Json.438 : List U8 = CallByName List.8 Json.441 Json.442;
let Json.440 : I64 = 34i64;
let Json.439 : U8 = CallByName Num.125 Json.440;
let Json.437 : List U8 = CallByName List.4 Json.438 Json.439;
ret Json.437;
procedure Json.99 (Json.100, Json.464, Json.98):
let Json.473 : I64 = 34i64;
let Json.472 : U8 = CallByName Num.127 Json.473;
let Json.470 : List U8 = CallByName List.4 Json.100 Json.472;
let Json.471 : List U8 = CallByName Str.12 Json.98;
let Json.467 : List U8 = CallByName List.8 Json.470 Json.471;
let Json.469 : I64 = 34i64;
let Json.468 : U8 = CallByName Num.127 Json.469;
let Json.466 : List U8 = CallByName List.4 Json.467 Json.468;
ret Json.466;
procedure List.138 (List.139, List.140, List.137):
let List.540 : {List U8, U64} = CallByName Json.114 List.139 List.140;
let List.540 : {List U8, U64} = CallByName Json.117 List.139 List.140;
ret List.540;
procedure List.18 (List.135, List.136, List.137):
@ -183,25 +183,25 @@ procedure List.91 (List.429, List.430, List.431):
let List.524 : {List U8, U64} = CallByName List.80 List.429 List.430 List.431 List.525 List.526;
ret List.524;
procedure Num.125 (#Attr.2):
let Num.263 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.263;
procedure Num.127 (#Attr.2):
let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.282;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.266 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.266;
let Num.285 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.285;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.264 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.264;
let Num.283 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.283;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.267;
let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.286;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.265 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.265;
let Num.284 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.284;
procedure Str.12 (#Attr.2):
let Str.280 : List U8 = lowlevel StrToUtf8 #Attr.2;

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

@ -2,7 +2,7 @@ procedure Encode.22 (Encode.93):
ret Encode.93;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.106 : List U8 = CallByName Json.96 Encode.94 Encode.96 Encode.102;
let Encode.106 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102;
ret Encode.106;
procedure Encode.25 (Encode.100, Encode.101):
@ -12,23 +12,23 @@ procedure Encode.25 (Encode.100, Encode.101):
ret Encode.103;
procedure Json.1 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.18 (Json.95):
let Json.397 : Str = CallByName Encode.22 Json.95;
ret Json.397;
procedure Json.18 (Json.98):
let Json.426 : Str = CallByName Encode.22 Json.98;
ret Json.426;
procedure Json.96 (Json.97, Json.399, Json.95):
let Json.408 : I64 = 34i64;
let Json.407 : U8 = CallByName Num.125 Json.408;
let Json.405 : List U8 = CallByName List.4 Json.97 Json.407;
let Json.406 : List U8 = CallByName Str.12 Json.95;
let Json.402 : List U8 = CallByName List.8 Json.405 Json.406;
let Json.404 : I64 = 34i64;
let Json.403 : U8 = CallByName Num.125 Json.404;
let Json.401 : List U8 = CallByName List.4 Json.402 Json.403;
ret Json.401;
procedure Json.99 (Json.100, Json.428, Json.98):
let Json.437 : I64 = 34i64;
let Json.436 : U8 = CallByName Num.127 Json.437;
let Json.434 : List U8 = CallByName List.4 Json.100 Json.436;
let Json.435 : List U8 = CallByName Str.12 Json.98;
let Json.431 : List U8 = CallByName List.8 Json.434 Json.435;
let Json.433 : I64 = 34i64;
let Json.432 : U8 = CallByName Num.127 Json.433;
let Json.430 : List U8 = CallByName List.4 Json.431 Json.432;
ret Json.430;
procedure List.4 (List.106, List.107):
let List.502 : U64 = 1i64;
@ -52,9 +52,9 @@ procedure List.8 (#Attr.2, #Attr.3):
let List.503 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
ret List.503;
procedure Num.125 (#Attr.2):
let Num.257 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.257;
procedure Num.127 (#Attr.2):
let Num.276 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.276;
procedure Str.12 (#Attr.2):
let Str.279 : List U8 = lowlevel StrToUtf8 #Attr.2;

180
crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt
View file

@ -27,11 +27,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.126 Encode.94 Encode.96 Encode.102;
let Encode.113 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102;
ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.116 : List U8 = CallByName Json.96 Encode.94 Encode.96 Encode.102;
let Encode.116 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102;
ret Encode.116;
procedure Encode.25 (Encode.100, Encode.101):
@ -41,93 +41,93 @@ procedure Encode.25 (Encode.100, Encode.101):
ret Encode.103;
procedure Json.1 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.126 (Json.127, Json.399, #Attr.12):
let Json.125 : List Str = StructAtIndex 1 #Attr.12;
inc Json.125;
let Json.124 : Str = StructAtIndex 0 #Attr.12;
inc Json.124;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List Str = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127;
dec #Attr.12;
let Json.437 : I64 = 123i64;
let Json.436 : U8 = CallByName Num.125 Json.437;
let Json.433 : List U8 = CallByName List.4 Json.127 Json.436;
let Json.435 : I64 = 34i64;
let Json.434 : U8 = CallByName Num.125 Json.435;
let Json.431 : List U8 = CallByName List.4 Json.433 Json.434;
let Json.432 : List U8 = CallByName Str.12 Json.124;
let Json.428 : List U8 = CallByName List.8 Json.431 Json.432;
let Json.430 : I64 = 34i64;
let Json.429 : U8 = CallByName Num.125 Json.430;
let Json.425 : List U8 = CallByName List.4 Json.428 Json.429;
let Json.427 : I64 = 58i64;
let Json.426 : U8 = CallByName Num.125 Json.427;
let Json.422 : List U8 = CallByName List.4 Json.425 Json.426;
let Json.424 : I64 = 91i64;
let Json.423 : U8 = CallByName Num.125 Json.424;
let Json.129 : List U8 = CallByName List.4 Json.422 Json.423;
let Json.421 : U64 = CallByName List.6 Json.125;
let Json.409 : {List U8, U64} = Struct {Json.129, Json.421};
let Json.410 : {} = Struct {};
let Json.408 : {List U8, U64} = CallByName List.18 Json.125 Json.409 Json.410;
dec Json.125;
let Json.131 : List U8 = StructAtIndex 0 Json.408;
inc Json.131;
dec Json.408;
let Json.407 : I64 = 93i64;
let Json.406 : U8 = CallByName Num.125 Json.407;
let Json.403 : List U8 = CallByName List.4 Json.131 Json.406;
let Json.405 : I64 = 125i64;
let Json.404 : U8 = CallByName Num.125 Json.405;
let Json.402 : List U8 = CallByName List.4 Json.403 Json.404;
ret Json.402;
let Json.466 : I64 = 123i64;
let Json.465 : U8 = CallByName Num.127 Json.466;
let Json.462 : List U8 = CallByName List.4 Json.130 Json.465;
let Json.464 : I64 = 34i64;
let Json.463 : U8 = CallByName Num.127 Json.464;
let Json.460 : List U8 = CallByName List.4 Json.462 Json.463;
let Json.461 : List U8 = CallByName Str.12 Json.127;
let Json.457 : List U8 = CallByName List.8 Json.460 Json.461;
let Json.459 : I64 = 34i64;
let Json.458 : U8 = CallByName Num.127 Json.459;
let Json.454 : List U8 = CallByName List.4 Json.457 Json.458;
let Json.456 : I64 = 58i64;
let Json.455 : U8 = CallByName Num.127 Json.456;
let Json.451 : List U8 = CallByName List.4 Json.454 Json.455;
let Json.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450};
let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.437;
inc Json.134;
dec Json.437;
let Json.436 : I64 = 93i64;
let Json.435 : U8 = CallByName Num.127 Json.436;
let Json.432 : List U8 = CallByName List.4 Json.134 Json.435;
let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431;
procedure Json.128 (Json.401, Json.134):
let Json.132 : List U8 = StructAtIndex 0 Json.401;
inc Json.132;
let Json.133 : U64 = StructAtIndex 1 Json.401;
dec Json.401;
let Json.420 : {} = Struct {};
let Json.135 : List U8 = CallByName Encode.23 Json.132 Json.134 Json.420;
joinpoint Json.415 Json.136:
let Json.413 : U64 = 1i64;
let Json.412 : U64 = CallByName Num.20 Json.133 Json.413;
let Json.411 : {List U8, U64} = Struct {Json.136, Json.412};
ret Json.411;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449;
joinpoint Json.444 Json.139:
let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441};
ret Json.440;
in
let Json.419 : U64 = 1i64;
let Json.416 : Int1 = CallByName Num.24 Json.133 Json.419;
if Json.416 then
let Json.418 : I64 = 44i64;
let Json.417 : U8 = CallByName Num.125 Json.418;
let Json.414 : List U8 = CallByName List.4 Json.135 Json.417;
jump Json.415 Json.414;
let Json.448 : U64 = 1i64;
let Json.445 : Int1 = CallByName Num.24 Json.136 Json.448;
if Json.445 then
let Json.447 : I64 = 44i64;
let Json.446 : U8 = CallByName Num.127 Json.447;
let Json.443 : List U8 = CallByName List.4 Json.138 Json.446;
jump Json.444 Json.443;
else
jump Json.415 Json.135;
jump Json.444 Json.138;
procedure Json.18 (Json.95):
let Json.438 : Str = CallByName Encode.22 Json.95;
ret Json.438;
procedure Json.18 (Json.98):
let Json.467 : Str = CallByName Encode.22 Json.98;
ret Json.467;
procedure Json.21 (Json.124, Json.125):
let Json.398 : {Str, List Str} = Struct {Json.124, Json.125};
let Json.397 : {Str, List Str} = CallByName Encode.22 Json.398;
ret Json.397;
procedure Json.21 (Json.127, Json.128):
let Json.427 : {Str, List Str} = Struct {Json.127, Json.128};
let Json.426 : {Str, List Str} = CallByName Encode.22 Json.427;
ret Json.426;
procedure Json.96 (Json.97, Json.440, Json.95):
let Json.449 : I64 = 34i64;
let Json.448 : U8 = CallByName Num.125 Json.449;
let Json.446 : List U8 = CallByName List.4 Json.97 Json.448;
let Json.447 : List U8 = CallByName Str.12 Json.95;
let Json.443 : List U8 = CallByName List.8 Json.446 Json.447;
let Json.445 : I64 = 34i64;
let Json.444 : U8 = CallByName Num.125 Json.445;
let Json.442 : List U8 = CallByName List.4 Json.443 Json.444;
ret Json.442;
procedure Json.99 (Json.100, Json.469, Json.98):
let Json.478 : I64 = 34i64;
let Json.477 : U8 = CallByName Num.127 Json.478;
let Json.475 : List U8 = CallByName List.4 Json.100 Json.477;
let Json.476 : List U8 = CallByName Str.12 Json.98;
let Json.472 : List U8 = CallByName List.8 Json.475 Json.476;
let Json.474 : I64 = 34i64;
let Json.473 : U8 = CallByName Num.127 Json.474;
let Json.471 : List U8 = CallByName List.4 Json.472 Json.473;
ret Json.471;
procedure List.138 (List.139, List.140, List.137):
let List.546 : {List U8, U64} = CallByName Json.128 List.139 List.140;
let List.546 : {List U8, U64} = CallByName Json.131 List.139 List.140;
ret List.546;
procedure List.18 (List.135, List.136, List.137):
@ -184,25 +184,25 @@ procedure List.91 (List.429, List.430, List.431):
let List.530 : {List U8, U64} = CallByName List.80 List.429 List.430 List.431 List.531 List.532;
ret List.530;
procedure Num.125 (#Attr.2):
let Num.265 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.265;
procedure Num.127 (#Attr.2):
let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.284;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.268;
let Num.287 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.287;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.266 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.266;
let Num.285 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.285;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.269;
let Num.288 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.288;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.267 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.267;
let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.286;
procedure Str.12 (#Attr.2):
let Str.280 : List U8 = lowlevel StrToUtf8 #Attr.2;

180
crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt
View file

@ -33,11 +33,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.126 Encode.94 Encode.96 Encode.102;
let Encode.113 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102;
ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.117 : List U8 = CallByName Json.96 Encode.94 Encode.96 Encode.102;
let Encode.117 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102;
ret Encode.117;
procedure Encode.25 (Encode.100, Encode.101):
@ -47,93 +47,93 @@ procedure Encode.25 (Encode.100, Encode.101):
ret Encode.103;
procedure Json.1 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.126 (Json.127, Json.399, #Attr.12):
let Json.125 : List Str = StructAtIndex 1 #Attr.12;
inc Json.125;
let Json.124 : Str = StructAtIndex 0 #Attr.12;
inc Json.124;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List Str = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127;
dec #Attr.12;
let Json.437 : I64 = 123i64;
let Json.436 : U8 = CallByName Num.125 Json.437;
let Json.433 : List U8 = CallByName List.4 Json.127 Json.436;
let Json.435 : I64 = 34i64;
let Json.434 : U8 = CallByName Num.125 Json.435;
let Json.431 : List U8 = CallByName List.4 Json.433 Json.434;
let Json.432 : List U8 = CallByName Str.12 Json.124;
let Json.428 : List U8 = CallByName List.8 Json.431 Json.432;
let Json.430 : I64 = 34i64;
let Json.429 : U8 = CallByName Num.125 Json.430;
let Json.425 : List U8 = CallByName List.4 Json.428 Json.429;
let Json.427 : I64 = 58i64;
let Json.426 : U8 = CallByName Num.125 Json.427;
let Json.422 : List U8 = CallByName List.4 Json.425 Json.426;
let Json.424 : I64 = 91i64;
let Json.423 : U8 = CallByName Num.125 Json.424;
let Json.129 : List U8 = CallByName List.4 Json.422 Json.423;
let Json.421 : U64 = CallByName List.6 Json.125;
let Json.409 : {List U8, U64} = Struct {Json.129, Json.421};
let Json.410 : {} = Struct {};
let Json.408 : {List U8, U64} = CallByName List.18 Json.125 Json.409 Json.410;
dec Json.125;
let Json.131 : List U8 = StructAtIndex 0 Json.408;
inc Json.131;
dec Json.408;
let Json.407 : I64 = 93i64;
let Json.406 : U8 = CallByName Num.125 Json.407;
let Json.403 : List U8 = CallByName List.4 Json.131 Json.406;
let Json.405 : I64 = 125i64;
let Json.404 : U8 = CallByName Num.125 Json.405;
let Json.402 : List U8 = CallByName List.4 Json.403 Json.404;
ret Json.402;
let Json.466 : I64 = 123i64;
let Json.465 : U8 = CallByName Num.127 Json.466;
let Json.462 : List U8 = CallByName List.4 Json.130 Json.465;
let Json.464 : I64 = 34i64;
let Json.463 : U8 = CallByName Num.127 Json.464;
let Json.460 : List U8 = CallByName List.4 Json.462 Json.463;
let Json.461 : List U8 = CallByName Str.12 Json.127;
let Json.457 : List U8 = CallByName List.8 Json.460 Json.461;
let Json.459 : I64 = 34i64;
let Json.458 : U8 = CallByName Num.127 Json.459;
let Json.454 : List U8 = CallByName List.4 Json.457 Json.458;
let Json.456 : I64 = 58i64;
let Json.455 : U8 = CallByName Num.127 Json.456;
let Json.451 : List U8 = CallByName List.4 Json.454 Json.455;
let Json.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450};
let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.437;
inc Json.134;
dec Json.437;
let Json.436 : I64 = 93i64;
let Json.435 : U8 = CallByName Num.127 Json.436;
let Json.432 : List U8 = CallByName List.4 Json.134 Json.435;
let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431;
procedure Json.128 (Json.401, Json.134):
let Json.132 : List U8 = StructAtIndex 0 Json.401;
inc Json.132;
let Json.133 : U64 = StructAtIndex 1 Json.401;
dec Json.401;
let Json.420 : {} = Struct {};
let Json.135 : List U8 = CallByName Encode.23 Json.132 Json.134 Json.420;
joinpoint Json.415 Json.136:
let Json.413 : U64 = 1i64;
let Json.412 : U64 = CallByName Num.20 Json.133 Json.413;
let Json.411 : {List U8, U64} = Struct {Json.136, Json.412};
ret Json.411;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449;
joinpoint Json.444 Json.139:
let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441};
ret Json.440;
in
let Json.419 : U64 = 1i64;
let Json.416 : Int1 = CallByName Num.24 Json.133 Json.419;
if Json.416 then
let Json.418 : I64 = 44i64;
let Json.417 : U8 = CallByName Num.125 Json.418;
let Json.414 : List U8 = CallByName List.4 Json.135 Json.417;
jump Json.415 Json.414;
let Json.448 : U64 = 1i64;
let Json.445 : Int1 = CallByName Num.24 Json.136 Json.448;
if Json.445 then
let Json.447 : I64 = 44i64;
let Json.446 : U8 = CallByName Num.127 Json.447;
let Json.443 : List U8 = CallByName List.4 Json.138 Json.446;
jump Json.444 Json.443;
else
jump Json.415 Json.135;
jump Json.444 Json.138;
procedure Json.18 (Json.95):
let Json.450 : Str = CallByName Encode.22 Json.95;
ret Json.450;
procedure Json.18 (Json.98):
let Json.479 : Str = CallByName Encode.22 Json.98;
ret Json.479;
procedure Json.21 (Json.124, Json.125):
let Json.398 : {Str, List Str} = Struct {Json.124, Json.125};
let Json.397 : {Str, List Str} = CallByName Encode.22 Json.398;
ret Json.397;
procedure Json.21 (Json.127, Json.128):
let Json.427 : {Str, List Str} = Struct {Json.127, Json.128};
let Json.426 : {Str, List Str} = CallByName Encode.22 Json.427;
ret Json.426;
procedure Json.96 (Json.97, Json.440, Json.95):
let Json.449 : I64 = 34i64;
let Json.448 : U8 = CallByName Num.125 Json.449;
let Json.446 : List U8 = CallByName List.4 Json.97 Json.448;
let Json.447 : List U8 = CallByName Str.12 Json.95;
let Json.443 : List U8 = CallByName List.8 Json.446 Json.447;
let Json.445 : I64 = 34i64;
let Json.444 : U8 = CallByName Num.125 Json.445;
let Json.442 : List U8 = CallByName List.4 Json.443 Json.444;
ret Json.442;
procedure Json.99 (Json.100, Json.469, Json.98):
let Json.478 : I64 = 34i64;
let Json.477 : U8 = CallByName Num.127 Json.478;
let Json.475 : List U8 = CallByName List.4 Json.100 Json.477;
let Json.476 : List U8 = CallByName Str.12 Json.98;
let Json.472 : List U8 = CallByName List.8 Json.475 Json.476;
let Json.474 : I64 = 34i64;
let Json.473 : U8 = CallByName Num.127 Json.474;
let Json.471 : List U8 = CallByName List.4 Json.472 Json.473;
ret Json.471;
procedure List.138 (List.139, List.140, List.137):
let List.546 : {List U8, U64} = CallByName Json.128 List.139 List.140;
let List.546 : {List U8, U64} = CallByName Json.131 List.139 List.140;
ret List.546;
procedure List.18 (List.135, List.136, List.137):
@ -190,25 +190,25 @@ procedure List.91 (List.429, List.430, List.431):
let List.530 : {List U8, U64} = CallByName List.80 List.429 List.430 List.431 List.531 List.532;
ret List.530;
procedure Num.125 (#Attr.2):
let Num.265 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.265;
procedure Num.127 (#Attr.2):
let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.284;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.268;
let Num.287 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.287;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.266 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.266;
let Num.285 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.285;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.269;
let Num.288 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.288;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.267 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.267;
let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.286;
procedure Str.12 (#Attr.2):
let Str.280 : List U8 = lowlevel StrToUtf8 #Attr.2;

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

@ -1,10 +1,10 @@
procedure Num.20 (#Attr.2, #Attr.3):
let Num.257 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.276;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.256 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.275;
procedure Test.1 (Test.15, Test.16):
joinpoint Test.7 Test.2 Test.3:

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

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

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.257 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.276;
procedure Test.1 (Test.9):
let Test.4 : U8 = 10i64;

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

@ -3,8 +3,8 @@ procedure Bool.1 ():
ret Bool.23;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.3 (Test.4):
ret Test.4;

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.277;
procedure Test.2 (Test.3):
switch Test.3:

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

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.276;
procedure Test.2 (Test.3, Test.1):
let Test.17 : Int1 = false;

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

@ -3,8 +3,8 @@ procedure List.6 (#Attr.2):
ret List.493;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.277;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
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.256 : I64 = lowlevel NumRound #Attr.2;
ret Num.256;
let Num.275 : I64 = lowlevel NumRound #Attr.2;
ret Num.275;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.0 ():
let Test.1 : I64 = 3i64;

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

@ -1,22 +1,22 @@
procedure Num.30 (#Attr.2):
let Num.263 : I64 = 0i64;
let Num.262 : Int1 = lowlevel Eq #Attr.2 Num.263;
ret Num.262;
let Num.282 : I64 = 0i64;
let Num.281 : Int1 = lowlevel Eq #Attr.2 Num.282;
ret Num.281;
procedure Num.39 (#Attr.2, #Attr.3):
let Num.258 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
ret Num.277;
procedure Num.40 (Num.228, Num.229):
let Num.259 : Int1 = CallByName Num.30 Num.229;
if Num.259 then
let Num.261 : {} = Struct {};
let Num.260 : [C {}, C I64] = TagId(0) Num.261;
ret Num.260;
procedure Num.40 (Num.247, Num.248):
let Num.278 : Int1 = CallByName Num.30 Num.248;
if Num.278 then
let Num.280 : {} = Struct {};
let Num.279 : [C {}, C I64] = TagId(0) Num.280;
ret Num.279;
else
let Num.257 : I64 = CallByName Num.39 Num.228 Num.229;
let Num.256 : [C {}, C I64] = TagId(1) Num.257;
ret Num.256;
let Num.276 : I64 = CallByName Num.39 Num.247 Num.248;
let Num.275 : [C {}, C I64] = TagId(1) Num.276;
ret Num.275;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.0 ():
let Test.10 : I64 = 41i64;

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

@ -42,8 +42,8 @@ procedure List.9 (List.286):
ret List.495;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.256 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Str.27 (Str.96):
let Str.265 : [C Int1, C I64] = CallByName Str.69 Str.96;

418
crates/compiler/test_mono/generated/issue_4749.txt
View file

@ -1,3 +1,7 @@
procedure Bool.1 ():
let Bool.36 : Int1 = false;
ret Bool.36;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
dec #Attr.3;
@ -5,30 +9,34 @@ procedure Bool.11 (#Attr.2, #Attr.3):
ret Bool.23;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.31 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.31;
let Bool.39 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.39;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.38 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.38;
let Bool.46 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.46;
procedure Bool.12 (#Attr.2, #Attr.3):
let Bool.30 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
ret Bool.30;
let Bool.38 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
ret Bool.38;
procedure Bool.2 ():
let Bool.35 : Int1 = true;
ret Bool.35;
procedure Bool.7 (Bool.19, Bool.20):
let Bool.29 : Int1 = CallByName Bool.12 Bool.19 Bool.20;
ret Bool.29;
let Bool.37 : Int1 = CallByName Bool.12 Bool.19 Bool.20;
ret Bool.37;
procedure Decode.23 (Decode.94):
ret Decode.94;
procedure Decode.24 (Decode.95, Decode.114, Decode.97):
let Decode.127 : {List U8, [C {}, C Str]} = CallByName Json.293 Decode.95 Decode.97;
let Decode.127 : {List U8, [C {}, C Str]} = CallByName Json.300 Decode.95 Decode.97;
ret Decode.127;
procedure Decode.25 (Decode.98, Decode.99):
let Decode.126 : {} = CallByName Json.41;
let Decode.126 : {} = CallByName Json.42;
let Decode.125 : {List U8, [C {}, C Str]} = CallByName Decode.24 Decode.98 Decode.126 Decode.99;
ret Decode.125;
@ -62,118 +70,187 @@ procedure Decode.26 (Decode.100, Decode.101):
let Decode.116 : [C [C List U8, C ], C Str] = TagId(0) Decode.117;
ret Decode.116;
procedure Json.139 (Json.452, Json.453):
joinpoint Json.421 Json.418 Json.138:
let Json.141 : List U8 = StructAtIndex 0 Json.418;
inc Json.141;
let Json.140 : List U8 = StructAtIndex 1 Json.418;
inc Json.140;
dec Json.418;
let Json.422 : [C {}, C U8] = CallByName List.9 Json.141;
let Json.436 : U8 = 1i64;
let Json.437 : U8 = GetTagId Json.422;
let Json.438 : Int1 = lowlevel Eq Json.436 Json.437;
if Json.438 then
let Json.142 : U8 = UnionAtIndex (Id 1) (Index 0) Json.422;
let Json.424 : Int1 = CallByName Json.283 Json.142;
if Json.424 then
let Json.434 : U64 = 1i64;
let Json.430 : {List U8, List U8} = CallByName List.52 Json.141 Json.434;
let Json.431 : {} = Struct {};
let Json.428 : List U8 = CallByName Json.143 Json.430;
let Json.429 : List U8 = CallByName List.4 Json.140 Json.142;
let Json.426 : {List U8, List U8} = Struct {Json.428, Json.429};
jump Json.421 Json.426 Json.138;
procedure Json.145 (Json.512, Json.513):
joinpoint Json.450 Json.447 Json.144:
let Json.147 : List U8 = StructAtIndex 0 Json.447;
inc Json.147;
let Json.146 : List U8 = StructAtIndex 1 Json.447;
inc Json.146;
dec Json.447;
joinpoint Json.490:
let Json.487 : {List U8, List U8} = Struct {Json.147, Json.146};
ret Json.487;
in
let Json.496 : U64 = lowlevel ListLen Json.147;
let Json.497 : U64 = 2i64;
let Json.498 : Int1 = lowlevel NumGte Json.496 Json.497;
if Json.498 then
let Json.489 : U64 = 0i64;
let Json.148 : U8 = lowlevel ListGetUnsafe Json.147 Json.489;
let Json.488 : U64 = 1i64;
let Json.149 : U8 = lowlevel ListGetUnsafe Json.147 Json.488;
let Json.458 : Int1 = CallByName Json.22 Json.148 Json.149;
if Json.458 then
let Json.465 : U64 = 2i64;
let Json.462 : List U8 = CallByName List.29 Json.147 Json.465;
let Json.464 : List U8 = CallByName List.4 Json.146 Json.148;
let Json.463 : List U8 = CallByName List.4 Json.464 Json.149;
let Json.460 : {List U8, List U8} = Struct {Json.462, Json.463};
jump Json.450 Json.460 Json.144;
else
let Json.423 : {List U8, List U8} = Struct {Json.141, Json.140};
ret Json.423;
let Json.452 : Int1 = CallByName Json.290 Json.148;
if Json.452 then
let Json.456 : List U8 = CallByName List.38 Json.147;
let Json.457 : List U8 = CallByName List.4 Json.146 Json.148;
let Json.454 : {List U8, List U8} = Struct {Json.456, Json.457};
jump Json.450 Json.454 Json.144;
else
let Json.451 : {List U8, List U8} = Struct {Json.147, Json.146};
ret Json.451;
else
let Json.435 : {List U8, List U8} = Struct {Json.141, Json.140};
ret Json.435;
let Json.493 : U64 = lowlevel ListLen Json.147;
let Json.494 : U64 = 1i64;
let Json.495 : Int1 = lowlevel NumGte Json.493 Json.494;
if Json.495 then
let Json.492 : U64 = 0i64;
let Json.150 : U8 = lowlevel ListGetUnsafe Json.147 Json.492;
joinpoint Json.485 Json.491:
if Json.491 then
let Json.483 : List U8 = CallByName List.38 Json.147;
let Json.484 : List U8 = CallByName List.4 Json.146 Json.150;
let Json.481 : {List U8, List U8} = Struct {Json.483, Json.484};
jump Json.450 Json.481 Json.144;
else
jump Json.490;
in
let Json.486 : Int1 = CallByName Json.290 Json.150;
jump Json.485 Json.486;
else
jump Json.490;
in
jump Json.421 Json.452 Json.453;
procedure Json.143 (Json.432):
let Json.433 : List U8 = StructAtIndex 1 Json.432;
inc Json.433;
dec Json.432;
ret Json.433;
jump Json.450 Json.512 Json.513;
procedure Json.2 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.22 (Json.137, Json.138):
let Json.440 : List U8 = Array [];
let Json.420 : {List U8, List U8} = Struct {Json.137, Json.440};
let Json.419 : {List U8, List U8} = CallByName Json.139 Json.420 Json.138;
ret Json.419;
procedure Json.283 (Json.284):
let Json.442 : U8 = 34i64;
let Json.441 : Int1 = CallByName Bool.7 Json.284 Json.442;
ret Json.441;
procedure Json.293 (Json.294, Json.399):
let Json.400 : {List U8, [C {}, C Str]} = CallByName Json.40 Json.294;
ret Json.400;
procedure Json.40 (Json.276):
let Json.446 : U64 = 1i64;
inc Json.276;
let Json.445 : {List U8, List U8} = CallByName List.52 Json.276 Json.446;
let Json.277 : List U8 = StructAtIndex 0 Json.445;
inc Json.277;
let Json.279 : List U8 = StructAtIndex 1 Json.445;
inc Json.279;
dec Json.445;
let Json.444 : U8 = 34i64;
let Json.443 : List U8 = Array [Json.444];
let Json.404 : Int1 = CallByName Bool.11 Json.277 Json.443;
dec Json.443;
dec Json.277;
if Json.404 then
dec Json.276;
let Json.417 : {} = Struct {};
let Json.416 : {List U8, List U8} = CallByName Json.22 Json.279 Json.417;
let Json.282 : List U8 = StructAtIndex 0 Json.416;
inc Json.282;
let Json.281 : List U8 = StructAtIndex 1 Json.416;
inc Json.281;
dec Json.416;
let Json.405 : [C {U64, U8}, C Str] = CallByName Str.9 Json.281;
let Json.413 : U8 = 1i64;
let Json.414 : U8 = GetTagId Json.405;
let Json.415 : Int1 = lowlevel Eq Json.413 Json.414;
if Json.415 then
let Json.285 : Str = UnionAtIndex (Id 1) (Index 0) Json.405;
inc Json.285;
dec Json.405;
let Json.409 : U64 = 1i64;
let Json.408 : {List U8, List U8} = CallByName List.52 Json.282 Json.409;
let Json.287 : List U8 = StructAtIndex 1 Json.408;
inc Json.287;
dec Json.408;
let Json.407 : [C {}, C Str] = TagId(1) Json.285;
let Json.406 : {List U8, [C {}, C Str]} = Struct {Json.287, Json.407};
ret Json.406;
else
dec Json.405;
let Json.412 : {} = Struct {};
let Json.411 : [C {}, C Str] = TagId(0) Json.412;
let Json.410 : {List U8, [C {}, C Str]} = Struct {Json.282, Json.411};
ret Json.410;
procedure Json.22 (Json.140, Json.141):
let Json.466 : {U8, U8} = Struct {Json.140, Json.141};
joinpoint Json.475:
let Json.474 : Int1 = CallByName Bool.1;
ret Json.474;
in
let Json.477 : U8 = StructAtIndex 0 Json.466;
let Json.478 : U8 = 92i64;
let Json.479 : Int1 = lowlevel Eq Json.478 Json.477;
if Json.479 then
let Json.476 : U8 = StructAtIndex 1 Json.466;
switch Json.476:
case 98:
let Json.467 : Int1 = CallByName Bool.2;
ret Json.467;
case 102:
let Json.468 : Int1 = CallByName Bool.2;
ret Json.468;
case 110:
let Json.469 : Int1 = CallByName Bool.2;
ret Json.469;
case 114:
let Json.470 : Int1 = CallByName Bool.2;
ret Json.470;
case 116:
let Json.471 : Int1 = CallByName Bool.2;
ret Json.471;
case 34:
let Json.472 : Int1 = CallByName Bool.2;
ret Json.472;
case 92:
let Json.473 : Int1 = CallByName Bool.2;
ret Json.473;
default:
jump Json.475;
else
dec Json.279;
let Json.403 : {} = Struct {};
let Json.402 : [C {}, C Str] = TagId(0) Json.403;
let Json.401 : {List U8, [C {}, C Str]} = Struct {Json.276, Json.402};
ret Json.401;
jump Json.475;
procedure Json.41 ():
let Json.398 : {} = Struct {};
let Json.397 : {} = CallByName Decode.23 Json.398;
ret Json.397;
procedure Json.23 (Json.143, Json.144):
let Json.500 : List U8 = Array [];
let Json.449 : {List U8, List U8} = Struct {Json.143, Json.500};
let Json.448 : {List U8, List U8} = CallByName Json.145 Json.449 Json.144;
ret Json.448;
procedure Json.290 (Json.291):
let Json.502 : U8 = 34i64;
let Json.501 : Int1 = CallByName Bool.7 Json.291 Json.502;
ret Json.501;
procedure Json.300 (Json.301, Json.428):
let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.301;
ret Json.429;
procedure Json.41 (Json.283):
let Json.506 : U64 = 1i64;
inc Json.283;
let Json.505 : {List U8, List U8} = CallByName List.52 Json.283 Json.506;
let Json.284 : List U8 = StructAtIndex 0 Json.505;
inc Json.284;
let Json.286 : List U8 = StructAtIndex 1 Json.505;
inc Json.286;
dec Json.505;
let Json.504 : U8 = 34i64;
let Json.503 : List U8 = Array [Json.504];
let Json.433 : Int1 = CallByName Bool.11 Json.284 Json.503;
dec Json.503;
dec Json.284;
if Json.433 then
dec Json.283;
let Json.446 : {} = Struct {};
let Json.445 : {List U8, List U8} = CallByName Json.23 Json.286 Json.446;
let Json.289 : List U8 = StructAtIndex 0 Json.445;
inc Json.289;
let Json.288 : List U8 = StructAtIndex 1 Json.445;
inc Json.288;
dec Json.445;
let Json.434 : [C {U64, U8}, C Str] = CallByName Str.9 Json.288;
let Json.442 : U8 = 1i64;
let Json.443 : U8 = GetTagId Json.434;
let Json.444 : Int1 = lowlevel Eq Json.442 Json.443;
if Json.444 then
let Json.292 : Str = UnionAtIndex (Id 1) (Index 0) Json.434;
inc Json.292;
dec Json.434;
let Json.438 : U64 = 1i64;
let Json.437 : {List U8, List U8} = CallByName List.52 Json.289 Json.438;
let Json.294 : List U8 = StructAtIndex 1 Json.437;
inc Json.294;
dec Json.437;
let Json.436 : [C {}, C Str] = TagId(1) Json.292;
let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.294, Json.436};
ret Json.435;
else
dec Json.434;
let Json.441 : {} = Struct {};
let Json.440 : [C {}, C Str] = TagId(0) Json.441;
let Json.439 : {List U8, [C {}, C Str]} = Struct {Json.289, Json.440};
ret Json.439;
else
dec Json.286;
let Json.432 : {} = Struct {};
let Json.431 : [C {}, C Str] = TagId(0) Json.432;
let Json.430 : {List U8, [C {}, C Str]} = Struct {Json.283, Json.431};
ret Json.430;
procedure Json.42 ():
let Json.427 : {} = Struct {};
let Json.426 : {} = CallByName Decode.23 Json.427;
ret Json.426;
procedure List.1 (List.94):
let List.494 : U64 = CallByName List.6 List.94;
@ -181,23 +258,33 @@ procedure List.1 (List.94):
let List.493 : Int1 = CallByName Bool.11 List.494 List.495;
ret List.493;
procedure List.2 (List.95, List.96):
let List.551 : U64 = CallByName List.6 List.95;
let List.547 : Int1 = CallByName Num.22 List.96 List.551;
if List.547 then
let List.549 : U8 = CallByName List.66 List.95 List.96;
let List.548 : [C {}, C U8] = TagId(1) List.549;
ret List.548;
else
let List.546 : {} = Struct {};
let List.545 : [C {}, C U8] = TagId(0) List.546;
ret List.545;
procedure List.29 (List.297, List.298):
let List.548 : U64 = CallByName List.6 List.297;
let List.299 : U64 = CallByName Num.77 List.548 List.298;
let List.543 : List U8 = CallByName List.43 List.297 List.299;
ret List.543;
procedure List.31 (#Attr.2, #Attr.3):
let List.540 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
ret List.540;
procedure List.38 (List.291):
let List.542 : U64 = 0i64;
let List.541 : List U8 = CallByName List.31 List.291 List.542;
ret List.541;
procedure List.4 (List.106, List.107):
let List.535 : U64 = 1i64;
let List.533 : List U8 = CallByName List.70 List.106 List.535;
let List.532 : List U8 = CallByName List.71 List.533 List.107;
ret List.532;
let List.537 : U64 = 1i64;
let List.536 : List U8 = CallByName List.70 List.106 List.537;
let List.535 : List U8 = CallByName List.71 List.536 List.107;
ret List.535;
procedure List.43 (List.295, List.296):
let List.547 : U64 = CallByName List.6 List.295;
let List.546 : U64 = CallByName Num.77 List.547 List.296;
let List.545 : {U64, U64} = Struct {List.296, List.546};
let List.544 : List U8 = CallByName List.49 List.295 List.545;
ret List.544;
procedure List.49 (List.369, List.370):
let List.507 : U64 = StructAtIndex 0 List.370;
@ -215,69 +302,50 @@ procedure List.49 (List.369, List.370):
procedure List.52 (List.384, List.385):
let List.386 : U64 = CallByName List.6 List.384;
joinpoint List.530 List.387:
let List.528 : U64 = 0i64;
let List.527 : {U64, U64} = Struct {List.387, List.528};
joinpoint List.522 List.387:
let List.520 : U64 = 0i64;
let List.519 : {U64, U64} = Struct {List.387, List.520};
inc List.384;
let List.388 : List U8 = CallByName List.49 List.384 List.527;
let List.526 : U64 = CallByName Num.20 List.386 List.387;
let List.525 : {U64, U64} = Struct {List.526, List.387};
let List.389 : List U8 = CallByName List.49 List.384 List.525;
let List.524 : {List U8, List U8} = Struct {List.388, List.389};
ret List.524;
let List.388 : List U8 = CallByName List.49 List.384 List.519;
let List.518 : U64 = CallByName Num.20 List.386 List.387;
let List.517 : {U64, U64} = Struct {List.518, List.387};
let List.389 : List U8 = CallByName List.49 List.384 List.517;
let List.516 : {List U8, List U8} = Struct {List.388, List.389};
ret List.516;
in
let List.531 : Int1 = CallByName Num.24 List.386 List.385;
if List.531 then
jump List.530 List.385;
let List.523 : Int1 = CallByName Num.24 List.386 List.385;
if List.523 then
jump List.522 List.385;
else
jump List.530 List.386;
jump List.522 List.386;
procedure List.6 (#Attr.2):
let List.571 : U64 = lowlevel ListLen #Attr.2;
ret List.571;
procedure List.66 (#Attr.2, #Attr.3):
let List.550 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.550;
let List.570 : U64 = lowlevel ListLen #Attr.2;
ret List.570;
procedure List.70 (#Attr.2, #Attr.3):
let List.536 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
ret List.536;
let List.528 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
ret List.528;
procedure List.71 (#Attr.2, #Attr.3):
let List.534 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.534;
let List.526 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.526;
procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
let List.504 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
ret List.504;
procedure List.9 (List.286):
let List.544 : U64 = 0i64;
let List.537 : [C {}, C U8] = CallByName List.2 List.286 List.544;
let List.541 : U8 = 1i64;
let List.542 : U8 = GetTagId List.537;
let List.543 : Int1 = lowlevel Eq List.541 List.542;
if List.543 then
let List.287 : U8 = UnionAtIndex (Id 1) (Index 0) List.537;
let List.538 : [C {}, C U8] = TagId(1) List.287;
ret List.538;
else
let List.540 : {} = Struct {};
let List.539 : [C {}, C U8] = TagId(0) List.540;
ret List.539;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.258 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.258;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.262 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.262;
let Num.276 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.276;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.261 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.261;
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.278;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.280 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.280;
procedure Str.48 (#Attr.2, #Attr.3, #Attr.4):
let Str.274 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;

410
crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt
View file

@ -1,3 +1,7 @@
procedure Bool.1 ():
let Bool.36 : Int1 = false;
ret Bool.36;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
dec #Attr.3;
@ -9,163 +13,246 @@ procedure Bool.11 (#Attr.2, #Attr.3):
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.31 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.31;
let Bool.39 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.39;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.38 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.38;
let Bool.46 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.46;
procedure Bool.12 (#Attr.2, #Attr.3):
let Bool.30 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
ret Bool.30;
let Bool.38 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
ret Bool.38;
procedure Bool.2 ():
let Bool.35 : Int1 = true;
ret Bool.35;
procedure Bool.7 (Bool.19, Bool.20):
let Bool.29 : Int1 = CallByName Bool.12 Bool.19 Bool.20;
ret Bool.29;
let Bool.37 : Int1 = CallByName Bool.12 Bool.19 Bool.20;
ret Bool.37;
procedure Decode.23 (Decode.94):
ret Decode.94;
procedure Decode.24 (Decode.95, Decode.114, Decode.97):
let Decode.117 : {List U8, [C {}, C Str]} = CallByName Json.293 Decode.95 Decode.97;
let Decode.117 : {List U8, [C {}, C Str]} = CallByName Json.300 Decode.95 Decode.97;
ret Decode.117;
procedure Decode.25 (Decode.98, Decode.99):
let Decode.116 : {} = CallByName Json.41;
let Decode.116 : {} = CallByName Json.42;
let Decode.115 : {List U8, [C {}, C Str]} = CallByName Decode.24 Decode.98 Decode.116 Decode.99;
ret Decode.115;
procedure Json.139 (Json.452, Json.453):
joinpoint Json.421 Json.418 Json.138:
let Json.141 : List U8 = StructAtIndex 0 Json.418;
inc Json.141;
let Json.140 : List U8 = StructAtIndex 1 Json.418;
inc Json.140;
dec Json.418;
let Json.422 : [C {}, C U8] = CallByName List.9 Json.141;
let Json.436 : U8 = 1i64;
let Json.437 : U8 = GetTagId Json.422;
let Json.438 : Int1 = lowlevel Eq Json.436 Json.437;
if Json.438 then
let Json.142 : U8 = UnionAtIndex (Id 1) (Index 0) Json.422;
let Json.424 : Int1 = CallByName Json.283 Json.142;
if Json.424 then
let Json.434 : U64 = 1i64;
let Json.430 : {List U8, List U8} = CallByName List.52 Json.141 Json.434;
let Json.431 : {} = Struct {};
let Json.428 : List U8 = CallByName Json.143 Json.430;
let Json.429 : List U8 = CallByName List.4 Json.140 Json.142;
let Json.426 : {List U8, List U8} = Struct {Json.428, Json.429};
jump Json.421 Json.426 Json.138;
procedure Json.145 (Json.512, Json.513):
joinpoint Json.450 Json.447 Json.144:
let Json.147 : List U8 = StructAtIndex 0 Json.447;
inc Json.147;
let Json.146 : List U8 = StructAtIndex 1 Json.447;
inc Json.146;
dec Json.447;
joinpoint Json.490:
let Json.487 : {List U8, List U8} = Struct {Json.147, Json.146};
ret Json.487;
in
let Json.496 : U64 = lowlevel ListLen Json.147;
let Json.497 : U64 = 2i64;
let Json.498 : Int1 = lowlevel NumGte Json.496 Json.497;
if Json.498 then
let Json.489 : U64 = 0i64;
let Json.148 : U8 = lowlevel ListGetUnsafe Json.147 Json.489;
let Json.488 : U64 = 1i64;
let Json.149 : U8 = lowlevel ListGetUnsafe Json.147 Json.488;
let Json.458 : Int1 = CallByName Json.22 Json.148 Json.149;
if Json.458 then
let Json.465 : U64 = 2i64;
let Json.462 : List U8 = CallByName List.29 Json.147 Json.465;
let Json.464 : List U8 = CallByName List.4 Json.146 Json.148;
let Json.463 : List U8 = CallByName List.4 Json.464 Json.149;
let Json.460 : {List U8, List U8} = Struct {Json.462, Json.463};
jump Json.450 Json.460 Json.144;
else
let Json.423 : {List U8, List U8} = Struct {Json.141, Json.140};
ret Json.423;
let Json.452 : Int1 = CallByName Json.290 Json.148;
if Json.452 then
let Json.456 : List U8 = CallByName List.38 Json.147;
let Json.457 : List U8 = CallByName List.4 Json.146 Json.148;
let Json.454 : {List U8, List U8} = Struct {Json.456, Json.457};
jump Json.450 Json.454 Json.144;
else
let Json.451 : {List U8, List U8} = Struct {Json.147, Json.146};
ret Json.451;
else
let Json.435 : {List U8, List U8} = Struct {Json.141, Json.140};
ret Json.435;
let Json.493 : U64 = lowlevel ListLen Json.147;
let Json.494 : U64 = 1i64;
let Json.495 : Int1 = lowlevel NumGte Json.493 Json.494;
if Json.495 then
let Json.492 : U64 = 0i64;
let Json.150 : U8 = lowlevel ListGetUnsafe Json.147 Json.492;
joinpoint Json.485 Json.491:
if Json.491 then
let Json.483 : List U8 = CallByName List.38 Json.147;
let Json.484 : List U8 = CallByName List.4 Json.146 Json.150;
let Json.481 : {List U8, List U8} = Struct {Json.483, Json.484};
jump Json.450 Json.481 Json.144;
else
jump Json.490;
in
let Json.486 : Int1 = CallByName Json.290 Json.150;
jump Json.485 Json.486;
else
jump Json.490;
in
jump Json.421 Json.452 Json.453;
procedure Json.143 (Json.432):
let Json.433 : List U8 = StructAtIndex 1 Json.432;
inc Json.433;
dec Json.432;
ret Json.433;
jump Json.450 Json.512 Json.513;
procedure Json.2 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.22 (Json.137, Json.138):
let Json.440 : List U8 = Array [];
let Json.420 : {List U8, List U8} = Struct {Json.137, Json.440};
let Json.419 : {List U8, List U8} = CallByName Json.139 Json.420 Json.138;
ret Json.419;
procedure Json.22 (Json.140, Json.141):
let Json.466 : {U8, U8} = Struct {Json.140, Json.141};
joinpoint Json.475:
let Json.474 : Int1 = CallByName Bool.1;
ret Json.474;
in
let Json.477 : U8 = StructAtIndex 0 Json.466;
let Json.478 : U8 = 92i64;
let Json.479 : Int1 = lowlevel Eq Json.478 Json.477;
if Json.479 then
let Json.476 : U8 = StructAtIndex 1 Json.466;
switch Json.476:
case 98:
let Json.467 : Int1 = CallByName Bool.2;
ret Json.467;
case 102:
let Json.468 : Int1 = CallByName Bool.2;
ret Json.468;
case 110:
let Json.469 : Int1 = CallByName Bool.2;
ret Json.469;
case 114:
let Json.470 : Int1 = CallByName Bool.2;
ret Json.470;
case 116:
let Json.471 : Int1 = CallByName Bool.2;
ret Json.471;
case 34:
let Json.472 : Int1 = CallByName Bool.2;
ret Json.472;
case 92:
let Json.473 : Int1 = CallByName Bool.2;
ret Json.473;
default:
jump Json.475;
else
jump Json.475;
procedure Json.283 (Json.284):
let Json.442 : U8 = 34i64;
let Json.441 : Int1 = CallByName Bool.7 Json.284 Json.442;
ret Json.441;
procedure Json.23 (Json.143, Json.144):
let Json.500 : List U8 = Array [];
let Json.449 : {List U8, List U8} = Struct {Json.143, Json.500};
let Json.448 : {List U8, List U8} = CallByName Json.145 Json.449 Json.144;
ret Json.448;
procedure Json.293 (Json.294, Json.399):
let Json.400 : {List U8, [C {}, C Str]} = CallByName Json.40 Json.294;
ret Json.400;
procedure Json.290 (Json.291):
let Json.502 : U8 = 34i64;
let Json.501 : Int1 = CallByName Bool.7 Json.291 Json.502;
ret Json.501;
procedure Json.40 (Json.276):
let Json.446 : U64 = 1i64;
inc Json.276;
let Json.445 : {List U8, List U8} = CallByName List.52 Json.276 Json.446;
let Json.277 : List U8 = StructAtIndex 0 Json.445;
inc Json.277;
let Json.279 : List U8 = StructAtIndex 1 Json.445;
inc Json.279;
dec Json.445;
let Json.444 : U8 = 34i64;
let Json.443 : List U8 = Array [Json.444];
let Json.404 : Int1 = CallByName Bool.11 Json.277 Json.443;
dec Json.443;
dec Json.277;
if Json.404 then
dec Json.276;
let Json.417 : {} = Struct {};
let Json.416 : {List U8, List U8} = CallByName Json.22 Json.279 Json.417;
let Json.282 : List U8 = StructAtIndex 0 Json.416;
inc Json.282;
let Json.281 : List U8 = StructAtIndex 1 Json.416;
inc Json.281;
dec Json.416;
let Json.405 : [C {U64, U8}, C Str] = CallByName Str.9 Json.281;
let Json.413 : U8 = 1i64;
let Json.414 : U8 = GetTagId Json.405;
let Json.415 : Int1 = lowlevel Eq Json.413 Json.414;
if Json.415 then
let Json.285 : Str = UnionAtIndex (Id 1) (Index 0) Json.405;
inc Json.285;
dec Json.405;
let Json.409 : U64 = 1i64;
let Json.408 : {List U8, List U8} = CallByName List.52 Json.282 Json.409;
let Json.287 : List U8 = StructAtIndex 1 Json.408;
inc Json.287;
dec Json.408;
let Json.407 : [C {}, C Str] = TagId(1) Json.285;
let Json.406 : {List U8, [C {}, C Str]} = Struct {Json.287, Json.407};
ret Json.406;
procedure Json.300 (Json.301, Json.428):
let Json.429 : {List U8, [C {}, C Str]} = CallByName Json.41 Json.301;
ret Json.429;
procedure Json.41 (Json.283):
let Json.506 : U64 = 1i64;
inc Json.283;
let Json.505 : {List U8, List U8} = CallByName List.52 Json.283 Json.506;
let Json.284 : List U8 = StructAtIndex 0 Json.505;
inc Json.284;
let Json.286 : List U8 = StructAtIndex 1 Json.505;
inc Json.286;
dec Json.505;
let Json.504 : U8 = 34i64;
let Json.503 : List U8 = Array [Json.504];
let Json.433 : Int1 = CallByName Bool.11 Json.284 Json.503;
dec Json.503;
dec Json.284;
if Json.433 then
dec Json.283;
let Json.446 : {} = Struct {};
let Json.445 : {List U8, List U8} = CallByName Json.23 Json.286 Json.446;
let Json.289 : List U8 = StructAtIndex 0 Json.445;
inc Json.289;
let Json.288 : List U8 = StructAtIndex 1 Json.445;
inc Json.288;
dec Json.445;
let Json.434 : [C {U64, U8}, C Str] = CallByName Str.9 Json.288;
let Json.442 : U8 = 1i64;
let Json.443 : U8 = GetTagId Json.434;
let Json.444 : Int1 = lowlevel Eq Json.442 Json.443;
if Json.444 then
let Json.292 : Str = UnionAtIndex (Id 1) (Index 0) Json.434;
inc Json.292;
dec Json.434;
let Json.438 : U64 = 1i64;
let Json.437 : {List U8, List U8} = CallByName List.52 Json.289 Json.438;
let Json.294 : List U8 = StructAtIndex 1 Json.437;
inc Json.294;
dec Json.437;
let Json.436 : [C {}, C Str] = TagId(1) Json.292;
let Json.435 : {List U8, [C {}, C Str]} = Struct {Json.294, Json.436};
ret Json.435;
else
dec Json.405;
let Json.412 : {} = Struct {};
let Json.411 : [C {}, C Str] = TagId(0) Json.412;
let Json.410 : {List U8, [C {}, C Str]} = Struct {Json.282, Json.411};
ret Json.410;
dec Json.434;
let Json.441 : {} = Struct {};
let Json.440 : [C {}, C Str] = TagId(0) Json.441;
let Json.439 : {List U8, [C {}, C Str]} = Struct {Json.289, Json.440};
ret Json.439;
else
dec Json.279;
let Json.403 : {} = Struct {};
let Json.402 : [C {}, C Str] = TagId(0) Json.403;
let Json.401 : {List U8, [C {}, C Str]} = Struct {Json.276, Json.402};
ret Json.401;
dec Json.286;
let Json.432 : {} = Struct {};
let Json.431 : [C {}, C Str] = TagId(0) Json.432;
let Json.430 : {List U8, [C {}, C Str]} = Struct {Json.283, Json.431};
ret Json.430;
procedure Json.41 ():
let Json.398 : {} = Struct {};
let Json.397 : {} = CallByName Decode.23 Json.398;
ret Json.397;
procedure Json.42 ():
let Json.427 : {} = Struct {};
let Json.426 : {} = CallByName Decode.23 Json.427;
ret Json.426;
procedure List.2 (List.95, List.96):
let List.545 : U64 = CallByName List.6 List.95;
let List.541 : Int1 = CallByName Num.22 List.96 List.545;
if List.541 then
let List.543 : U8 = CallByName List.66 List.95 List.96;
let List.542 : [C {}, C U8] = TagId(1) List.543;
ret List.542;
else
let List.540 : {} = Struct {};
let List.539 : [C {}, C U8] = TagId(0) List.540;
ret List.539;
procedure List.29 (List.297, List.298):
let List.542 : U64 = CallByName List.6 List.297;
let List.299 : U64 = CallByName Num.77 List.542 List.298;
let List.537 : List U8 = CallByName List.43 List.297 List.299;
ret List.537;
procedure List.31 (#Attr.2, #Attr.3):
let List.534 : List U8 = lowlevel ListDropAt #Attr.2 #Attr.3;
ret List.534;
procedure List.38 (List.291):
let List.536 : U64 = 0i64;
let List.535 : List U8 = CallByName List.31 List.291 List.536;
ret List.535;
procedure List.4 (List.106, List.107):
let List.529 : U64 = 1i64;
let List.527 : List U8 = CallByName List.70 List.106 List.529;
let List.526 : List U8 = CallByName List.71 List.527 List.107;
ret List.526;
let List.531 : U64 = 1i64;
let List.530 : List U8 = CallByName List.70 List.106 List.531;
let List.529 : List U8 = CallByName List.71 List.530 List.107;
ret List.529;
procedure List.43 (List.295, List.296):
let List.541 : U64 = CallByName List.6 List.295;
let List.540 : U64 = CallByName Num.77 List.541 List.296;
let List.539 : {U64, U64} = Struct {List.296, List.540};
let List.538 : List U8 = CallByName List.49 List.295 List.539;
ret List.538;
procedure List.49 (List.369, List.370):
let List.501 : U64 = StructAtIndex 0 List.370;
@ -183,69 +270,50 @@ procedure List.49 (List.369, List.370):
procedure List.52 (List.384, List.385):
let List.386 : U64 = CallByName List.6 List.384;
joinpoint List.524 List.387:
let List.522 : U64 = 0i64;
let List.521 : {U64, U64} = Struct {List.387, List.522};
joinpoint List.516 List.387:
let List.514 : U64 = 0i64;
let List.513 : {U64, U64} = Struct {List.387, List.514};
inc List.384;
let List.388 : List U8 = CallByName List.49 List.384 List.521;
let List.520 : U64 = CallByName Num.20 List.386 List.387;
let List.519 : {U64, U64} = Struct {List.520, List.387};
let List.389 : List U8 = CallByName List.49 List.384 List.519;
let List.518 : {List U8, List U8} = Struct {List.388, List.389};
ret List.518;
let List.388 : List U8 = CallByName List.49 List.384 List.513;
let List.512 : U64 = CallByName Num.20 List.386 List.387;
let List.511 : {U64, U64} = Struct {List.512, List.387};
let List.389 : List U8 = CallByName List.49 List.384 List.511;
let List.510 : {List U8, List U8} = Struct {List.388, List.389};
ret List.510;
in
let List.525 : Int1 = CallByName Num.24 List.386 List.385;
if List.525 then
jump List.524 List.385;
let List.517 : Int1 = CallByName Num.24 List.386 List.385;
if List.517 then
jump List.516 List.385;
else
jump List.524 List.386;
jump List.516 List.386;
procedure List.6 (#Attr.2):
let List.565 : U64 = lowlevel ListLen #Attr.2;
ret List.565;
procedure List.66 (#Attr.2, #Attr.3):
let List.544 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.544;
let List.564 : U64 = lowlevel ListLen #Attr.2;
ret List.564;
procedure List.70 (#Attr.2, #Attr.3):
let List.530 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
ret List.530;
let List.522 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
ret List.522;
procedure List.71 (#Attr.2, #Attr.3):
let List.528 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.528;
let List.520 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
ret List.520;
procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
let List.498 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
ret List.498;
procedure List.9 (List.286):
let List.538 : U64 = 0i64;
let List.531 : [C {}, C U8] = CallByName List.2 List.286 List.538;
let List.535 : U8 = 1i64;
let List.536 : U8 = GetTagId List.531;
let List.537 : Int1 = lowlevel Eq List.535 List.536;
if List.537 then
let List.287 : U8 = UnionAtIndex (Id 1) (Index 0) List.531;
let List.532 : [C {}, C U8] = TagId(1) List.287;
ret List.532;
else
let List.534 : {} = Struct {};
let List.533 : [C {}, C U8] = TagId(0) List.534;
ret List.533;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.258 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.258;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.262 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.262;
let Num.276 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.276;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.261 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.261;
let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.278;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.280 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.280;
procedure Str.12 (#Attr.2):
let Str.274 : List U8 = lowlevel StrToUtf8 #Attr.2;

16
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.256 : Str = lowlevel NumToStr #Attr.2;
ret Num.256;
procedure Num.96 (#Attr.2):
let Num.275 : Str = lowlevel NumToStr #Attr.2;
ret Num.275;
procedure Num.94 (#Attr.2):
let Num.257 : Str = lowlevel NumToStr #Attr.2;
ret Num.257;
procedure Num.96 (#Attr.2):
let Num.276 : Str = lowlevel NumToStr #Attr.2;
ret Num.276;
procedure Test.1 (Test.4):
let Test.13 : [C U8, C U64] = TagId(1) Test.4;
@ -16,12 +16,12 @@ procedure Test.1 (Test.4):
procedure Test.5 (Test.14, #Attr.12):
let Test.4 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.16 : Str = CallByName Num.94 Test.4;
let Test.16 : Str = CallByName Num.96 Test.4;
ret Test.16;
procedure Test.5 (Test.14, #Attr.12):
let Test.4 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.22 : Str = CallByName Num.94 Test.4;
let Test.22 : Str = CallByName Num.96 Test.4;
ret Test.22;
procedure Test.0 ():

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

@ -7,12 +7,12 @@ procedure Bool.2 ():
ret Bool.24;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.256 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.257 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.276;
procedure Test.0 (Test.8):
let Test.20 : Int1 = CallByName Bool.2;

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

@ -24,12 +24,12 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
ret List.500;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.256 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.276;
procedure Test.1 ():
let Test.8 : List I64 = Array [1i64, 2i64, 3i64];

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

@ -19,8 +19,8 @@ procedure List.66 (#Attr.2, #Attr.3):
ret List.498;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.256 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Test.1 (Test.2):
let Test.6 : List I64 = Array [1i64, 2i64, 3i64];

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

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

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

@ -23,8 +23,8 @@ procedure List.66 (#Attr.2, #Attr.3):
ret List.498;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.256 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.265 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;

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

@ -24,8 +24,8 @@ procedure List.66 (#Attr.2, #Attr.3):
ret List.498;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.256 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.266 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

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

@ -22,8 +22,8 @@ procedure List.5 (#Attr.2, #Attr.3):
procedure Num.19 (#Attr.2, #Attr.3):
let Num.258 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.277;
procedure Test.4 (Test.5, #Attr.12):
let Test.1 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;

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

@ -24,8 +24,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
ret List.498;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.256 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Test.2 (Test.3):
let Test.6 : U64 = 0i64;

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

@ -13,8 +13,8 @@ procedure List.59 (List.281):
ret List.493;
procedure Num.46 (#Attr.2, #Attr.3):
let Num.256 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
ret Num.275;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.0 ():
let Test.19 : I64 = 41i64;

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

@ -1,6 +1,6 @@
procedure Num.37 (#Attr.2, #Attr.3):
let Num.256 : Float64 = lowlevel NumDivFrac #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : Float64 = lowlevel NumDivFrac #Attr.2 #Attr.3;
ret Num.275;
procedure Test.0 ():
let Test.2 : Float64 = 1f64;

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

@ -1,6 +1,6 @@
procedure Num.21 (#Attr.2, #Attr.3):
let Num.258 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.277;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.257 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.276;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.277;
procedure Test.1 (Test.24, Test.25, Test.26):
joinpoint Test.12 Test.2 Test.3 Test.4:

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

@ -40,8 +40,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
ret List.498;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.277;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.1 (Test.2):
let Test.3 : I64 = 10i64;

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

@ -3,8 +3,8 @@ procedure Bool.2 ():
ret Bool.23;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.256 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.1 (Test.2):
let Test.8 : U32 = 0i64;

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

@ -1,6 +1,6 @@
procedure Num.20 (#Attr.2, #Attr.3):
let Num.256 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.275;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.267 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

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

@ -40,8 +40,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
ret List.498;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.277;
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

@ -3,12 +3,12 @@ procedure Bool.2 ():
ret Bool.24;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.276;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.256 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.275;
procedure Test.1 (Test.2, Test.3):
let Test.15 : U8 = GetTagId Test.2;

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

@ -3,12 +3,12 @@ procedure Bool.2 ():
ret Bool.23;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.276;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.256 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.275;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.257 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.276;
procedure Test.1 (Test.15, Test.16):
joinpoint Test.7 Test.2 Test.3:

180
crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt
View file

@ -16,11 +16,11 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.126 Encode.94 Encode.96 Encode.102;
let Encode.113 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102;
ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.118 : List U8 = CallByName Json.96 Encode.94 Encode.96 Encode.102;
let Encode.118 : List U8 = CallByName Json.99 Encode.94 Encode.96 Encode.102;
ret Encode.118;
procedure Encode.25 (Encode.100, Encode.101):
@ -30,93 +30,93 @@ procedure Encode.25 (Encode.100, Encode.101):
ret Encode.103;
procedure Json.1 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.126 (Json.127, Json.399, #Attr.12):
let Json.125 : List Str = StructAtIndex 1 #Attr.12;
inc Json.125;
let Json.124 : Str = StructAtIndex 0 #Attr.12;
inc Json.124;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List Str = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127;
dec #Attr.12;
let Json.437 : I64 = 123i64;
let Json.436 : U8 = CallByName Num.125 Json.437;
let Json.433 : List U8 = CallByName List.4 Json.127 Json.436;
let Json.435 : I64 = 34i64;
let Json.434 : U8 = CallByName Num.125 Json.435;
let Json.431 : List U8 = CallByName List.4 Json.433 Json.434;
let Json.432 : List U8 = CallByName Str.12 Json.124;
let Json.428 : List U8 = CallByName List.8 Json.431 Json.432;
let Json.430 : I64 = 34i64;
let Json.429 : U8 = CallByName Num.125 Json.430;
let Json.425 : List U8 = CallByName List.4 Json.428 Json.429;
let Json.427 : I64 = 58i64;
let Json.426 : U8 = CallByName Num.125 Json.427;
let Json.422 : List U8 = CallByName List.4 Json.425 Json.426;
let Json.424 : I64 = 91i64;
let Json.423 : U8 = CallByName Num.125 Json.424;
let Json.129 : List U8 = CallByName List.4 Json.422 Json.423;
let Json.421 : U64 = CallByName List.6 Json.125;
let Json.409 : {List U8, U64} = Struct {Json.129, Json.421};
let Json.410 : {} = Struct {};
let Json.408 : {List U8, U64} = CallByName List.18 Json.125 Json.409 Json.410;
dec Json.125;
let Json.131 : List U8 = StructAtIndex 0 Json.408;
inc Json.131;
dec Json.408;
let Json.407 : I64 = 93i64;
let Json.406 : U8 = CallByName Num.125 Json.407;
let Json.403 : List U8 = CallByName List.4 Json.131 Json.406;
let Json.405 : I64 = 125i64;
let Json.404 : U8 = CallByName Num.125 Json.405;
let Json.402 : List U8 = CallByName List.4 Json.403 Json.404;
ret Json.402;
let Json.466 : I64 = 123i64;
let Json.465 : U8 = CallByName Num.127 Json.466;
let Json.462 : List U8 = CallByName List.4 Json.130 Json.465;
let Json.464 : I64 = 34i64;
let Json.463 : U8 = CallByName Num.127 Json.464;
let Json.460 : List U8 = CallByName List.4 Json.462 Json.463;
let Json.461 : List U8 = CallByName Str.12 Json.127;
let Json.457 : List U8 = CallByName List.8 Json.460 Json.461;
let Json.459 : I64 = 34i64;
let Json.458 : U8 = CallByName Num.127 Json.459;
let Json.454 : List U8 = CallByName List.4 Json.457 Json.458;
let Json.456 : I64 = 58i64;
let Json.455 : U8 = CallByName Num.127 Json.456;
let Json.451 : List U8 = CallByName List.4 Json.454 Json.455;
let Json.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450};
let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.437;
inc Json.134;
dec Json.437;
let Json.436 : I64 = 93i64;
let Json.435 : U8 = CallByName Num.127 Json.436;
let Json.432 : List U8 = CallByName List.4 Json.134 Json.435;
let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431;
procedure Json.128 (Json.401, Json.134):
let Json.132 : List U8 = StructAtIndex 0 Json.401;
inc Json.132;
let Json.133 : U64 = StructAtIndex 1 Json.401;
dec Json.401;
let Json.420 : {} = Struct {};
let Json.135 : List U8 = CallByName Encode.23 Json.132 Json.134 Json.420;
joinpoint Json.415 Json.136:
let Json.413 : U64 = 1i64;
let Json.412 : U64 = CallByName Num.20 Json.133 Json.413;
let Json.411 : {List U8, U64} = Struct {Json.136, Json.412};
ret Json.411;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449;
joinpoint Json.444 Json.139:
let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441};
ret Json.440;
in
let Json.419 : U64 = 1i64;
let Json.416 : Int1 = CallByName Num.24 Json.133 Json.419;
if Json.416 then
let Json.418 : I64 = 44i64;
let Json.417 : U8 = CallByName Num.125 Json.418;
let Json.414 : List U8 = CallByName List.4 Json.135 Json.417;
jump Json.415 Json.414;
let Json.448 : U64 = 1i64;
let Json.445 : Int1 = CallByName Num.24 Json.136 Json.448;
if Json.445 then
let Json.447 : I64 = 44i64;
let Json.446 : U8 = CallByName Num.127 Json.447;
let Json.443 : List U8 = CallByName List.4 Json.138 Json.446;
jump Json.444 Json.443;
else
jump Json.415 Json.135;
jump Json.444 Json.138;
procedure Json.18 (Json.95):
let Json.453 : Str = CallByName Encode.22 Json.95;
ret Json.453;
procedure Json.18 (Json.98):
let Json.482 : Str = CallByName Encode.22 Json.98;
ret Json.482;
procedure Json.21 (Json.124, Json.125):
let Json.439 : {Str, List Str} = Struct {Json.124, Json.125};
let Json.438 : {Str, List Str} = CallByName Encode.22 Json.439;
ret Json.438;
procedure Json.21 (Json.127, Json.128):
let Json.468 : {Str, List Str} = Struct {Json.127, Json.128};
let Json.467 : {Str, List Str} = CallByName Encode.22 Json.468;
ret Json.467;
procedure Json.96 (Json.97, Json.443, Json.95):
let Json.452 : I64 = 34i64;
let Json.451 : U8 = CallByName Num.125 Json.452;
let Json.449 : List U8 = CallByName List.4 Json.97 Json.451;
let Json.450 : List U8 = CallByName Str.12 Json.95;
let Json.446 : List U8 = CallByName List.8 Json.449 Json.450;
let Json.448 : I64 = 34i64;
let Json.447 : U8 = CallByName Num.125 Json.448;
let Json.445 : List U8 = CallByName List.4 Json.446 Json.447;
ret Json.445;
procedure Json.99 (Json.100, Json.472, Json.98):
let Json.481 : I64 = 34i64;
let Json.480 : U8 = CallByName Num.127 Json.481;
let Json.478 : List U8 = CallByName List.4 Json.100 Json.480;
let Json.479 : List U8 = CallByName Str.12 Json.98;
let Json.475 : List U8 = CallByName List.8 Json.478 Json.479;
let Json.477 : I64 = 34i64;
let Json.476 : U8 = CallByName Num.127 Json.477;
let Json.474 : List U8 = CallByName List.4 Json.475 Json.476;
ret Json.474;
procedure List.138 (List.139, List.140, List.137):
let List.544 : {List U8, U64} = CallByName Json.128 List.139 List.140;
let List.544 : {List U8, U64} = CallByName Json.131 List.139 List.140;
ret List.544;
procedure List.18 (List.135, List.136, List.137):
@ -169,25 +169,25 @@ procedure List.91 (List.429, List.430, List.431):
let List.528 : {List U8, U64} = CallByName List.80 List.429 List.430 List.431 List.529 List.530;
ret List.528;
procedure Num.125 (#Attr.2):
let Num.265 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.265;
procedure Num.127 (#Attr.2):
let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.284;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.268;
let Num.287 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.287;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.266 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.266;
let Num.285 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.285;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.269;
let Num.288 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.288;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.267 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.267;
let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.286;
procedure Str.12 (#Attr.2):
let Str.266 : List U8 = lowlevel StrToUtf8 #Attr.2;

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

@ -51,7 +51,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
ret Encode.106;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.113 : List U8 = CallByName Json.126 Encode.94 Encode.96 Encode.102;
let Encode.113 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102;
ret Encode.113;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
@ -67,7 +67,7 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.129 : List U8 = CallByName Json.126 Encode.94 Encode.96 Encode.102;
let Encode.129 : List U8 = CallByName Json.129 Encode.94 Encode.96 Encode.102;
ret Encode.129;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
@ -81,150 +81,150 @@ procedure Encode.25 (Encode.100, Encode.101):
ret Encode.103;
procedure Json.1 ():
let Json.396 : {} = Struct {};
ret Json.396;
let Json.425 : {} = Struct {};
ret Json.425;
procedure Json.126 (Json.127, Json.399, #Attr.12):
let Json.125 : List [C {}, C {}] = StructAtIndex 1 #Attr.12;
inc Json.125;
let Json.124 : Str = StructAtIndex 0 #Attr.12;
inc Json.124;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List [C {}, C {}] = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127;
dec #Attr.12;
let Json.437 : I64 = 123i64;
let Json.436 : U8 = CallByName Num.125 Json.437;
let Json.433 : List U8 = CallByName List.4 Json.127 Json.436;
let Json.435 : I64 = 34i64;
let Json.434 : U8 = CallByName Num.125 Json.435;
let Json.431 : List U8 = CallByName List.4 Json.433 Json.434;
let Json.432 : List U8 = CallByName Str.12 Json.124;
let Json.428 : List U8 = CallByName List.8 Json.431 Json.432;
let Json.430 : I64 = 34i64;
let Json.429 : U8 = CallByName Num.125 Json.430;
let Json.425 : List U8 = CallByName List.4 Json.428 Json.429;
let Json.427 : I64 = 58i64;
let Json.426 : U8 = CallByName Num.125 Json.427;
let Json.422 : List U8 = CallByName List.4 Json.425 Json.426;
let Json.424 : I64 = 91i64;
let Json.423 : U8 = CallByName Num.125 Json.424;
let Json.129 : List U8 = CallByName List.4 Json.422 Json.423;
let Json.421 : U64 = CallByName List.6 Json.125;
let Json.409 : {List U8, U64} = Struct {Json.129, Json.421};
let Json.410 : {} = Struct {};
let Json.408 : {List U8, U64} = CallByName List.18 Json.125 Json.409 Json.410;
dec Json.125;
let Json.131 : List U8 = StructAtIndex 0 Json.408;
inc Json.131;
dec Json.408;
let Json.407 : I64 = 93i64;
let Json.406 : U8 = CallByName Num.125 Json.407;
let Json.403 : List U8 = CallByName List.4 Json.131 Json.406;
let Json.405 : I64 = 125i64;
let Json.404 : U8 = CallByName Num.125 Json.405;
let Json.402 : List U8 = CallByName List.4 Json.403 Json.404;
ret Json.402;
let Json.466 : I64 = 123i64;
let Json.465 : U8 = CallByName Num.127 Json.466;
let Json.462 : List U8 = CallByName List.4 Json.130 Json.465;
let Json.464 : I64 = 34i64;
let Json.463 : U8 = CallByName Num.127 Json.464;
let Json.460 : List U8 = CallByName List.4 Json.462 Json.463;
let Json.461 : List U8 = CallByName Str.12 Json.127;
let Json.457 : List U8 = CallByName List.8 Json.460 Json.461;
let Json.459 : I64 = 34i64;
let Json.458 : U8 = CallByName Num.127 Json.459;
let Json.454 : List U8 = CallByName List.4 Json.457 Json.458;
let Json.456 : I64 = 58i64;
let Json.455 : U8 = CallByName Num.127 Json.456;
let Json.451 : List U8 = CallByName List.4 Json.454 Json.455;
let Json.453 : I64 = 91i64;
let Json.452 : U8 = CallByName Num.127 Json.453;
let Json.132 : List U8 = CallByName List.4 Json.451 Json.452;
let Json.450 : U64 = CallByName List.6 Json.128;
let Json.438 : {List U8, U64} = Struct {Json.132, Json.450};
let Json.439 : {} = Struct {};
let Json.437 : {List U8, U64} = CallByName List.18 Json.128 Json.438 Json.439;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.437;
inc Json.134;
dec Json.437;
let Json.436 : I64 = 93i64;
let Json.435 : U8 = CallByName Num.127 Json.436;
let Json.432 : List U8 = CallByName List.4 Json.134 Json.435;
let Json.434 : I64 = 125i64;
let Json.433 : U8 = CallByName Num.127 Json.434;
let Json.431 : List U8 = CallByName List.4 Json.432 Json.433;
ret Json.431;
procedure Json.126 (Json.127, Json.399, #Attr.12):
let Json.125 : List [] = StructAtIndex 1 #Attr.12;
inc Json.125;
let Json.124 : Str = StructAtIndex 0 #Attr.12;
inc Json.124;
procedure Json.129 (Json.130, Json.428, #Attr.12):
let Json.128 : List [] = StructAtIndex 1 #Attr.12;
inc Json.128;
let Json.127 : Str = StructAtIndex 0 #Attr.12;
inc Json.127;
dec #Attr.12;
let Json.487 : I64 = 123i64;
let Json.486 : U8 = CallByName Num.125 Json.487;
let Json.483 : List U8 = CallByName List.4 Json.127 Json.486;
let Json.485 : I64 = 34i64;
let Json.484 : U8 = CallByName Num.125 Json.485;
let Json.481 : List U8 = CallByName List.4 Json.483 Json.484;
let Json.482 : List U8 = CallByName Str.12 Json.124;
let Json.478 : List U8 = CallByName List.8 Json.481 Json.482;
let Json.480 : I64 = 34i64;
let Json.479 : U8 = CallByName Num.125 Json.480;
let Json.475 : List U8 = CallByName List.4 Json.478 Json.479;
let Json.477 : I64 = 58i64;
let Json.476 : U8 = CallByName Num.125 Json.477;
let Json.472 : List U8 = CallByName List.4 Json.475 Json.476;
let Json.474 : I64 = 91i64;
let Json.473 : U8 = CallByName Num.125 Json.474;
let Json.129 : List U8 = CallByName List.4 Json.472 Json.473;
let Json.471 : U64 = CallByName List.6 Json.125;
let Json.459 : {List U8, U64} = Struct {Json.129, Json.471};
let Json.460 : {} = Struct {};
let Json.458 : {List U8, U64} = CallByName List.18 Json.125 Json.459 Json.460;
dec Json.125;
let Json.131 : List U8 = StructAtIndex 0 Json.458;
inc Json.131;
dec Json.458;
let Json.457 : I64 = 93i64;
let Json.456 : U8 = CallByName Num.125 Json.457;
let Json.453 : List U8 = CallByName List.4 Json.131 Json.456;
let Json.455 : I64 = 125i64;
let Json.454 : U8 = CallByName Num.125 Json.455;
let Json.452 : List U8 = CallByName List.4 Json.453 Json.454;
ret Json.452;
let Json.516 : I64 = 123i64;
let Json.515 : U8 = CallByName Num.127 Json.516;
let Json.512 : List U8 = CallByName List.4 Json.130 Json.515;
let Json.514 : I64 = 34i64;
let Json.513 : U8 = CallByName Num.127 Json.514;
let Json.510 : List U8 = CallByName List.4 Json.512 Json.513;
let Json.511 : List U8 = CallByName Str.12 Json.127;
let Json.507 : List U8 = CallByName List.8 Json.510 Json.511;
let Json.509 : I64 = 34i64;
let Json.508 : U8 = CallByName Num.127 Json.509;
let Json.504 : List U8 = CallByName List.4 Json.507 Json.508;
let Json.506 : I64 = 58i64;
let Json.505 : U8 = CallByName Num.127 Json.506;
let Json.501 : List U8 = CallByName List.4 Json.504 Json.505;
let Json.503 : I64 = 91i64;
let Json.502 : U8 = CallByName Num.127 Json.503;
let Json.132 : List U8 = CallByName List.4 Json.501 Json.502;
let Json.500 : U64 = CallByName List.6 Json.128;
let Json.488 : {List U8, U64} = Struct {Json.132, Json.500};
let Json.489 : {} = Struct {};
let Json.487 : {List U8, U64} = CallByName List.18 Json.128 Json.488 Json.489;
dec Json.128;
let Json.134 : List U8 = StructAtIndex 0 Json.487;
inc Json.134;
dec Json.487;
let Json.486 : I64 = 93i64;
let Json.485 : U8 = CallByName Num.127 Json.486;
let Json.482 : List U8 = CallByName List.4 Json.134 Json.485;
let Json.484 : I64 = 125i64;
let Json.483 : U8 = CallByName Num.127 Json.484;
let Json.481 : List U8 = CallByName List.4 Json.482 Json.483;
ret Json.481;
procedure Json.128 (Json.401, Json.134):
let Json.132 : List U8 = StructAtIndex 0 Json.401;
inc Json.132;
let Json.133 : U64 = StructAtIndex 1 Json.401;
dec Json.401;
let Json.420 : {} = Struct {};
let Json.135 : List U8 = CallByName Encode.23 Json.132 Json.134 Json.420;
joinpoint Json.415 Json.136:
let Json.413 : U64 = 1i64;
let Json.412 : U64 = CallByName Num.20 Json.133 Json.413;
let Json.411 : {List U8, U64} = Struct {Json.136, Json.412};
ret Json.411;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.449 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.449;
joinpoint Json.444 Json.139:
let Json.442 : U64 = 1i64;
let Json.441 : U64 = CallByName Num.20 Json.136 Json.442;
let Json.440 : {List U8, U64} = Struct {Json.139, Json.441};
ret Json.440;
in
let Json.419 : U64 = 1i64;
let Json.416 : Int1 = CallByName Num.24 Json.133 Json.419;
if Json.416 then
let Json.418 : I64 = 44i64;
let Json.417 : U8 = CallByName Num.125 Json.418;
let Json.414 : List U8 = CallByName List.4 Json.135 Json.417;
jump Json.415 Json.414;
let Json.448 : U64 = 1i64;
let Json.445 : Int1 = CallByName Num.24 Json.136 Json.448;
if Json.445 then
let Json.447 : I64 = 44i64;
let Json.446 : U8 = CallByName Num.127 Json.447;
let Json.443 : List U8 = CallByName List.4 Json.138 Json.446;
jump Json.444 Json.443;
else
jump Json.415 Json.135;
jump Json.444 Json.138;
procedure Json.128 (Json.401, Json.134):
let Json.132 : List U8 = StructAtIndex 0 Json.401;
inc Json.132;
let Json.133 : U64 = StructAtIndex 1 Json.401;
dec Json.401;
let Json.470 : {} = Struct {};
let Json.135 : List U8 = CallByName Encode.23 Json.132 Json.134 Json.470;
dec Json.132;
joinpoint Json.465 Json.136:
let Json.463 : U64 = 1i64;
let Json.462 : U64 = CallByName Num.20 Json.133 Json.463;
let Json.461 : {List U8, U64} = Struct {Json.136, Json.462};
ret Json.461;
procedure Json.131 (Json.430, Json.137):
let Json.135 : List U8 = StructAtIndex 0 Json.430;
inc Json.135;
let Json.136 : U64 = StructAtIndex 1 Json.430;
dec Json.430;
let Json.499 : {} = Struct {};
let Json.138 : List U8 = CallByName Encode.23 Json.135 Json.137 Json.499;
dec Json.135;
joinpoint Json.494 Json.139:
let Json.492 : U64 = 1i64;
let Json.491 : U64 = CallByName Num.20 Json.136 Json.492;
let Json.490 : {List U8, U64} = Struct {Json.139, Json.491};
ret Json.490;
in
let Json.469 : U64 = 1i64;
let Json.466 : Int1 = CallByName Num.24 Json.133 Json.469;
if Json.466 then
let Json.468 : I64 = 44i64;
let Json.467 : U8 = CallByName Num.125 Json.468;
let Json.464 : List U8 = CallByName List.4 Json.135 Json.467;
jump Json.465 Json.464;
let Json.498 : U64 = 1i64;
let Json.495 : Int1 = CallByName Num.24 Json.136 Json.498;
if Json.495 then
let Json.497 : I64 = 44i64;
let Json.496 : U8 = CallByName Num.127 Json.497;
let Json.493 : List U8 = CallByName List.4 Json.138 Json.496;
jump Json.494 Json.493;
else
jump Json.465 Json.135;
jump Json.494 Json.138;
procedure Json.21 (Json.124, Json.125):
let Json.439 : {Str, List [C {}, C {}]} = Struct {Json.124, Json.125};
let Json.438 : {Str, List [C {}, C {}]} = CallByName Encode.22 Json.439;
ret Json.438;
procedure Json.21 (Json.127, Json.128):
let Json.468 : {Str, List [C {}, C {}]} = Struct {Json.127, Json.128};
let Json.467 : {Str, List [C {}, C {}]} = CallByName Encode.22 Json.468;
ret Json.467;
procedure Json.21 (Json.124, Json.125):
let Json.489 : {Str, List []} = Struct {Json.124, Json.125};
let Json.488 : {Str, List []} = CallByName Encode.22 Json.489;
ret Json.488;
procedure Json.21 (Json.127, Json.128):
let Json.518 : {Str, List []} = Struct {Json.127, Json.128};
let Json.517 : {Str, List []} = CallByName Encode.22 Json.518;
ret Json.517;
procedure List.138 (List.139, List.140, List.137):
let List.538 : {List U8, U64} = CallByName Json.128 List.139 List.140;
let List.538 : {List U8, U64} = CallByName Json.131 List.139 List.140;
ret List.538;
procedure List.138 (List.139, List.140, List.137):
let List.611 : {List U8, U64} = CallByName Json.128 List.139 List.140;
let List.611 : {List U8, U64} = CallByName Json.131 List.139 List.140;
ret List.611;
procedure List.18 (List.135, List.136, List.137):
@ -309,25 +309,25 @@ procedure List.91 (List.429, List.430, List.431):
let List.595 : {List U8, U64} = CallByName List.80 List.429 List.430 List.431 List.596 List.597;
ret List.595;
procedure Num.125 (#Attr.2):
let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.284;
procedure Num.127 (#Attr.2):
let Num.303 : U8 = lowlevel NumIntCast #Attr.2;
ret Num.303;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.287 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.287;
let Num.306 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.306;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.285 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.285;
let Num.304 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.304;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.288 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.288;
let Num.307 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.307;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.286;
let Num.305 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
ret Num.305;
procedure Str.12 (#Attr.2):
let Str.267 : List U8 = lowlevel StrToUtf8 #Attr.2;

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

@ -84,16 +84,16 @@ procedure List.91 (List.429, List.430, List.431):
ret List.514;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
let Num.277 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.277;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.259;
let Num.278 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.278;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.257 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.257;
let Num.276 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.276;
procedure Test.3 (Test.4, Test.12):
let Test.13 : [C U64, C U64] = TagId(0) Test.4;

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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
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.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
let Num.275 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.0 ():
let Test.15 : I64 = 3i64;