language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-11-02 22:01:20 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Add Str.len stub (#7732)

Browse source 
* Add Str.len stub

* mono update
This commit is contained in:
Anton-4 2025-04-09 12:19:34 +02:00 • committed by GitHub
parent 37b7f11dca
commit 1570a3df10
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
36 changed files with 1677 additions and 1671 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -41,8 +41,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.387 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.387;
let Str.390 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.390;
procedure Test.1 (Test.5):
ret Test.5;

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

@ -43,8 +43,8 @@ procedure Num.96 (#Attr.2):
ret Num.284;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Test.0 ():
let Test.4 : I64 = 1i64;

292
crates/compiler/test_mono/generated/dbg_in_expect.txt generated
View file

@ -104,184 +104,184 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453;
let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443;
let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.446;
procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406;
procedure Str.38 (Str.213, Str.214):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.412 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413;
if Str.414 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399;
let Str.408 : U64 = CallByName Str.36 Str.213;
let Str.409 : U64 = CallByName Str.36 Str.214;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215;
let Str.406 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215;
let Str.404 : U64 = CallByName Str.36 Str.214;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401;
ret Str.400;
procedure Str.38 (Str.215, Str.216):
let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.415 : U8 = 1i64;
let Str.416 : U8 = GetTagId Str.402;
let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.417 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.409 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.403;
else
dec Str.213;
let Str.411 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411;
ret Str.410;
dec Str.215;
let Str.414 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.489 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490;
if Str.491 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481;
let Str.196 : Str = StructAtIndex 0 Str.488;
let Str.195 : Str = StructAtIndex 1 Str.488;
let Str.486 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.485 : Str = CallByName Str.20 Str.486;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195;
dec Str.195;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194;
ret Str.482;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.492 : U8 = 1i64;
let Str.493 : U8 = GetTagId Str.484;
let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.494 then
let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.488 : Str = CallByName Str.20 Str.489;
let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.197;
let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.485;
else
dec Str.481;
ret Str.192;
dec Str.484;
ret Str.194;
procedure Str.64 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.396 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397;
if Str.398 then
dec Str.198;
let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390;
let Str.202 : Str = StructAtIndex 0 Str.395;
let Str.201 : Str = StructAtIndex 1 Str.395;
let Str.393 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.392 : Str = CallByName Str.3 Str.393 Str.200;
jump Str.389 Str.392 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.390;
procedure Str.65 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.399 : U8 = 1i64;
let Str.400 : U8 = GetTagId Str.393;
let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.401 then
dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.394;
let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
let Str.204 : Str = StructAtIndex 0 Str.398;
let Str.203 : Str = StructAtIndex 1 Str.398;
let Str.396 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.395 : Str = CallByName Str.3 Str.396 Str.202;
jump Str.392 Str.395 Str.204 Str.201 Str.202;
else
dec Str.201;
dec Str.202;
dec Str.393;
let Str.397 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.397;
in
inc #Derived_gen.3;
inc #Derived_gen.2;
jump Str.389 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
jump Str.392 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.416 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226;
ret Str.415;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.419 : U64 = 0i64;
let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.418;
procedure Str.66 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.419 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.423 then
dec Str.227;
dec Str.228;
let Str.424 : [C , C U64] = TagId(1) Str.229;
ret Str.424;
procedure Str.67 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.422 then
let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.426 then
dec Str.230;
dec Str.229;
let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.427;
else
let Str.422 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422;
jump Str.417 Str.227 Str.228 Str.421 Str.230;
let Str.425 : U64 = 1i64;
let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.420 Str.229 Str.230 Str.424 Str.232;
else
dec Str.227;
dec Str.228;
let Str.418 : [C , C U64] = TagId(0) ;
ret Str.418;
dec Str.230;
dec Str.229;
let Str.421 : [C , C U64] = TagId(0) ;
ret Str.421;
in
inc #Derived_gen.5;
inc #Derived_gen.4;
jump Str.417 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
jump Str.420 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
procedure Str.69 (Str.253, Str.254):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.448 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.451 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258;
let Str.445 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.448 : U64 = 0i64;
inc Str.257;
let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259};
let Str.425 : Int1 = CallByName Str.71 Str.426;
ret Str.425;
inc Str.259;
let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442;
let Str.431 : U64 = StructAtIndex 0 Str.261;
let Str.432 : Str = StructAtIndex 1 Str.261;
let Str.434 : Str = StructAtIndex 3 Str.261;
let Str.436 : U64 = StructAtIndex 5 Str.261;
let Str.440 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440;
let Str.439 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436};
let Str.271 : Int1 = CallByName Str.71 Str.430;
if Str.270 then
ret Str.271;
let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.443 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.442 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439};
let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.272 then
ret Str.273;
else
let Str.428 : Int1 = CallByName Bool.1;
ret Str.428;
let Str.431 : Int1 = CallByName Bool.1;
ret Str.431;
procedure Test.1 ():
let Test.4 : Str = "";

292
crates/compiler/test_mono/generated/dbg_inside_string.txt generated
View file

@ -100,184 +100,184 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.455 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.455;
let Str.458 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.458;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.387 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.387;
let Str.390 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.390;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.445 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.445;
let Str.448 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.448;
procedure Str.36 (#Attr.2):
let Str.407 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.407;
let Str.410 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.410;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.405 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.405;
let Str.408 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.408;
procedure Str.38 (Str.213, Str.214):
let Str.401 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.414 : U8 = 1i64;
let Str.415 : U8 = GetTagId Str.401;
let Str.416 : Int1 = lowlevel Eq Str.414 Str.415;
if Str.416 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.401;
let Str.410 : U64 = CallByName Str.36 Str.213;
let Str.411 : U64 = CallByName Str.36 Str.214;
let Str.409 : U64 = CallByName Num.20 Str.410 Str.411;
let Str.216 : U64 = CallByName Num.20 Str.409 Str.215;
let Str.408 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.408 Str.215;
let Str.406 : U64 = CallByName Str.36 Str.214;
let Str.404 : U64 = CallByName Num.51 Str.215 Str.406;
let Str.218 : Str = CallByName Str.37 Str.213 Str.404 Str.216;
let Str.403 : {Str, Str} = Struct {Str.218, Str.217};
let Str.402 : [C {}, C {Str, Str}] = TagId(1) Str.403;
ret Str.402;
procedure Str.38 (Str.215, Str.216):
let Str.404 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.417 : U8 = 1i64;
let Str.418 : U8 = GetTagId Str.404;
let Str.419 : Int1 = lowlevel Eq Str.417 Str.418;
if Str.419 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.404;
let Str.413 : U64 = CallByName Str.36 Str.215;
let Str.414 : U64 = CallByName Str.36 Str.216;
let Str.412 : U64 = CallByName Num.20 Str.413 Str.414;
let Str.218 : U64 = CallByName Num.20 Str.412 Str.217;
let Str.411 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.411 Str.217;
let Str.409 : U64 = CallByName Str.36 Str.216;
let Str.407 : U64 = CallByName Num.51 Str.217 Str.409;
let Str.220 : Str = CallByName Str.37 Str.215 Str.407 Str.218;
let Str.406 : {Str, Str} = Struct {Str.220, Str.219};
let Str.405 : [C {}, C {Str, Str}] = TagId(1) Str.406;
ret Str.405;
else
dec Str.213;
let Str.413 : {} = Struct {};
let Str.412 : [C {}, C {Str, Str}] = TagId(0) Str.413;
ret Str.412;
dec Str.215;
let Str.416 : {} = Struct {};
let Str.415 : [C {}, C {Str, Str}] = TagId(0) Str.416;
ret Str.415;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.483 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.491 : U8 = 1i64;
let Str.492 : U8 = GetTagId Str.483;
let Str.493 : Int1 = lowlevel Eq Str.491 Str.492;
if Str.493 then
let Str.490 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.483;
let Str.196 : Str = StructAtIndex 0 Str.490;
let Str.195 : Str = StructAtIndex 1 Str.490;
let Str.488 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.487 : Str = CallByName Str.20 Str.488;
let Str.486 : Str = CallByName Str.3 Str.487 Str.195;
dec Str.195;
let Str.485 : Str = CallByName Str.3 Str.486 Str.194;
let Str.484 : Str = CallByName Str.64 Str.485 Str.196 Str.193 Str.194;
ret Str.484;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.486 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.494 : U8 = 1i64;
let Str.495 : U8 = GetTagId Str.486;
let Str.496 : Int1 = lowlevel Eq Str.494 Str.495;
if Str.496 then
let Str.493 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.486;
let Str.198 : Str = StructAtIndex 0 Str.493;
let Str.197 : Str = StructAtIndex 1 Str.493;
let Str.491 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.490 : Str = CallByName Str.20 Str.491;
let Str.489 : Str = CallByName Str.3 Str.490 Str.197;
dec Str.197;
let Str.488 : Str = CallByName Str.3 Str.489 Str.196;
let Str.487 : Str = CallByName Str.65 Str.488 Str.198 Str.195 Str.196;
ret Str.487;
else
dec Str.483;
ret Str.192;
dec Str.486;
ret Str.194;
procedure Str.64 (Bool.24, Bool.25, Bool.26, Bool.27):
joinpoint Str.391 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.392 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.398 : U8 = 1i64;
let Str.399 : U8 = GetTagId Str.392;
let Str.400 : Int1 = lowlevel Eq Str.398 Str.399;
if Str.400 then
dec Str.198;
let Str.397 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.392;
let Str.202 : Str = StructAtIndex 0 Str.397;
let Str.201 : Str = StructAtIndex 1 Str.397;
let Str.395 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.394 : Str = CallByName Str.3 Str.395 Str.200;
jump Str.391 Str.394 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.392;
procedure Str.65 (Bool.24, Bool.25, Bool.26, Bool.27):
joinpoint Str.394 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.395 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.401 : U8 = 1i64;
let Str.402 : U8 = GetTagId Str.395;
let Str.403 : Int1 = lowlevel Eq Str.401 Str.402;
if Str.403 then
dec Str.200;
let Str.396 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.396;
let Str.400 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.395;
let Str.204 : Str = StructAtIndex 0 Str.400;
let Str.203 : Str = StructAtIndex 1 Str.400;
let Str.398 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.397 : Str = CallByName Str.3 Str.398 Str.202;
jump Str.394 Str.397 Str.204 Str.201 Str.202;
else
dec Str.395;
dec Str.201;
dec Str.202;
let Str.399 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.399;
in
inc Bool.26;
inc Bool.27;
jump Str.391 Bool.24 Bool.25 Bool.26 Bool.27;
jump Str.394 Bool.24 Bool.25 Bool.26 Bool.27;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.418 : U64 = 0i64;
let Str.417 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.418 Str.226;
ret Str.417;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.421 : U64 = 0i64;
let Str.420 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.421 Str.228;
ret Str.420;
procedure Str.66 (Bool.28, Bool.29, Bool.30, Bool.31):
joinpoint Str.419 Str.227 Str.228 Str.229 Str.230:
let Str.421 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.421 then
let Str.425 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.425 then
dec Str.227;
dec Str.228;
let Str.426 : [C , C U64] = TagId(1) Str.229;
ret Str.426;
procedure Str.67 (Bool.28, Bool.29, Bool.30, Bool.31):
joinpoint Str.422 Str.229 Str.230 Str.231 Str.232:
let Str.424 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.424 then
let Str.428 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.428 then
dec Str.230;
dec Str.229;
let Str.429 : [C , C U64] = TagId(1) Str.231;
ret Str.429;
else
let Str.424 : U64 = 1i64;
let Str.423 : U64 = CallByName Num.51 Str.229 Str.424;
jump Str.419 Str.227 Str.228 Str.423 Str.230;
let Str.427 : U64 = 1i64;
let Str.426 : U64 = CallByName Num.51 Str.231 Str.427;
jump Str.422 Str.229 Str.230 Str.426 Str.232;
else
dec Str.227;
dec Str.228;
let Str.420 : [C , C U64] = TagId(0) ;
ret Str.420;
dec Str.230;
dec Str.229;
let Str.423 : [C , C U64] = TagId(0) ;
ret Str.423;
in
inc Bool.29;
inc Bool.28;
jump Str.419 Bool.28 Bool.29 Bool.30 Bool.31;
jump Str.422 Bool.28 Bool.29 Bool.30 Bool.31;
procedure Str.69 (Str.253, Str.254):
let Str.450 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.450 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.453 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.453 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.448 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.448 Str.258;
let Str.447 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.451 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.451 Str.260;
let Str.450 : U64 = 0i64;
inc Str.257;
let Str.428 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.447, Str.259};
let Str.427 : Int1 = CallByName Str.71 Str.428;
ret Str.427;
inc Str.259;
let Str.431 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.450, Str.261};
let Str.430 : Int1 = CallByName Str.72 Str.431;
ret Str.430;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.443 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.443 Str.444;
let Str.433 : U64 = StructAtIndex 0 Str.261;
let Str.434 : Str = StructAtIndex 1 Str.261;
let Str.436 : Str = StructAtIndex 3 Str.261;
let Str.438 : U64 = StructAtIndex 5 Str.261;
let Str.442 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.441 : U64 = 1i64;
let Str.439 : U64 = CallByName Num.51 Str.263 Str.441;
let Str.432 : {U64, Str, U64, Str, U64, U64} = Struct {Str.433, Str.434, Str.439, Str.436, Str.440, Str.438};
let Str.271 : Int1 = CallByName Str.71 Str.432;
if Str.270 then
ret Str.271;
let Str.446 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.447 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.446 Str.447;
let Str.436 : U64 = StructAtIndex 0 Str.263;
let Str.437 : Str = StructAtIndex 1 Str.263;
let Str.439 : Str = StructAtIndex 3 Str.263;
let Str.441 : U64 = StructAtIndex 5 Str.263;
let Str.445 : U64 = 1i64;
let Str.443 : U64 = CallByName Num.51 Str.267 Str.445;
let Str.444 : U64 = 1i64;
let Str.442 : U64 = CallByName Num.51 Str.265 Str.444;
let Str.435 : {U64, Str, U64, Str, U64, U64} = Struct {Str.436, Str.437, Str.442, Str.439, Str.443, Str.441};
let Str.273 : Int1 = CallByName Str.72 Str.435;
if Str.272 then
ret Str.273;
else
let Str.430 : Int1 = CallByName Bool.1;
ret Str.430;
let Str.433 : Int1 = CallByName Bool.1;
ret Str.433;
procedure Test.0 ():
let Test.4 : Str = "Hello ";

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

@ -39,8 +39,8 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Test.0 ():
let Test.3 : I64 = 1i64;

292
crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt generated
View file

@ -100,184 +100,184 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453;
let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443;
let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.446;
procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406;
procedure Str.38 (Str.213, Str.214):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.412 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413;
if Str.414 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399;
let Str.408 : U64 = CallByName Str.36 Str.213;
let Str.409 : U64 = CallByName Str.36 Str.214;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215;
let Str.406 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215;
let Str.404 : U64 = CallByName Str.36 Str.214;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401;
ret Str.400;
procedure Str.38 (Str.215, Str.216):
let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.415 : U8 = 1i64;
let Str.416 : U8 = GetTagId Str.402;
let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.417 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.409 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.403;
else
dec Str.213;
let Str.411 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411;
ret Str.410;
dec Str.215;
let Str.414 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.489 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490;
if Str.491 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481;
let Str.196 : Str = StructAtIndex 0 Str.488;
let Str.195 : Str = StructAtIndex 1 Str.488;
let Str.486 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.485 : Str = CallByName Str.20 Str.486;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195;
dec Str.195;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194;
ret Str.482;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.492 : U8 = 1i64;
let Str.493 : U8 = GetTagId Str.484;
let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.494 then
let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.488 : Str = CallByName Str.20 Str.489;
let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.197;
let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.485;
else
dec Str.481;
ret Str.192;
dec Str.484;
ret Str.194;
procedure Str.64 (Bool.24, Bool.25, Bool.26, Bool.27):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.396 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397;
if Str.398 then
dec Str.198;
let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390;
let Str.202 : Str = StructAtIndex 0 Str.395;
let Str.201 : Str = StructAtIndex 1 Str.395;
let Str.393 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.392 : Str = CallByName Str.3 Str.393 Str.200;
jump Str.389 Str.392 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.390;
procedure Str.65 (Bool.24, Bool.25, Bool.26, Bool.27):
joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.399 : U8 = 1i64;
let Str.400 : U8 = GetTagId Str.393;
let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.401 then
dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.394;
let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
let Str.204 : Str = StructAtIndex 0 Str.398;
let Str.203 : Str = StructAtIndex 1 Str.398;
let Str.396 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.395 : Str = CallByName Str.3 Str.396 Str.202;
jump Str.392 Str.395 Str.204 Str.201 Str.202;
else
dec Str.201;
dec Str.202;
dec Str.393;
let Str.397 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.397;
in
inc Bool.26;
inc Bool.27;
jump Str.389 Bool.24 Bool.25 Bool.26 Bool.27;
jump Str.392 Bool.24 Bool.25 Bool.26 Bool.27;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.416 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226;
ret Str.415;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.419 : U64 = 0i64;
let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.418;
procedure Str.66 (Bool.28, Bool.29, Bool.30, Bool.31):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.419 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.423 then
dec Str.227;
dec Str.228;
let Str.424 : [C , C U64] = TagId(1) Str.229;
ret Str.424;
procedure Str.67 (Bool.28, Bool.29, Bool.30, Bool.31):
joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.422 then
let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.426 then
dec Str.230;
dec Str.229;
let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.427;
else
let Str.422 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422;
jump Str.417 Str.227 Str.228 Str.421 Str.230;
let Str.425 : U64 = 1i64;
let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.420 Str.229 Str.230 Str.424 Str.232;
else
dec Str.227;
dec Str.228;
let Str.418 : [C , C U64] = TagId(0) ;
ret Str.418;
dec Str.230;
dec Str.229;
let Str.421 : [C , C U64] = TagId(0) ;
ret Str.421;
in
inc Bool.29;
inc Bool.28;
jump Str.417 Bool.28 Bool.29 Bool.30 Bool.31;
jump Str.420 Bool.28 Bool.29 Bool.30 Bool.31;
procedure Str.69 (Str.253, Str.254):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.448 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.451 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258;
let Str.445 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.448 : U64 = 0i64;
inc Str.257;
let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259};
let Str.425 : Int1 = CallByName Str.71 Str.426;
ret Str.425;
inc Str.259;
let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442;
let Str.431 : U64 = StructAtIndex 0 Str.261;
let Str.432 : Str = StructAtIndex 1 Str.261;
let Str.434 : Str = StructAtIndex 3 Str.261;
let Str.436 : U64 = StructAtIndex 5 Str.261;
let Str.440 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440;
let Str.439 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436};
let Str.271 : Int1 = CallByName Str.71 Str.430;
if Str.270 then
ret Str.271;
let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.443 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.442 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439};
let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.272 then
ret Str.273;
else
let Str.428 : Int1 = CallByName Bool.1;
ret Str.428;
let Str.431 : Int1 = CallByName Bool.1;
ret Str.431;
procedure Test.0 ():
let Test.3 : Str = "";

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

@ -11,8 +11,8 @@ procedure Num.96 (#Attr.2):
ret Num.284;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386;
let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.389;
procedure Test.1 (Test.2):
let Test.3 : Str = CallByName Num.96 Test.2;

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

@ -164,32 +164,32 @@ procedure Num.96 (#Attr.2):
ret Num.287;
procedure Str.12 (#Attr.2):
let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.398;
let Str.401 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.401;
procedure Str.36 (#Attr.2):
let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.399;
let Str.402 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.402;
procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393;
let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.396;
procedure Str.9 (Str.79):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79;
let Str.390 : Int1 = StructAtIndex 2 Str.80;
if Str.390 then
let Str.392 : Str = StructAtIndex 1 Str.80;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392;
ret Str.391;
procedure Str.9 (Str.81):
let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.393 then
let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.394;
else
let Str.388 : U64 = StructAtIndex 0 Str.80;
let Str.389 : U8 = StructAtIndex 3 Str.80;
let #Derived_gen.45 : Str = StructAtIndex 1 Str.80;
let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.45 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.45;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387;
ret Str.385;
let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.388;
procedure Test.20 (Test.56):
let Test.325 : Str = CallByName Encode.23 Test.56;

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

@ -105,32 +105,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395;
let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.398;
procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396;
let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.399;
procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393;
let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.396;
procedure Str.9 (Str.79):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79;
let Str.390 : Int1 = StructAtIndex 2 Str.80;
if Str.390 then
let Str.392 : Str = StructAtIndex 1 Str.80;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392;
ret Str.391;
procedure Str.9 (Str.81):
let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.393 then
let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.394;
else
let Str.388 : U64 = StructAtIndex 0 Str.80;
let Str.389 : U8 = StructAtIndex 3 Str.80;
let #Derived_gen.24 : Str = StructAtIndex 1 Str.80;
let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.24 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.24;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387;
ret Str.385;
let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.388;
procedure Test.20 (Test.56):
let Test.292 : Str = CallByName Encode.23 Test.56;

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

@ -112,32 +112,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395;
let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.398;
procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396;
let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.399;
procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393;
let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.396;
procedure Str.9 (Str.79):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79;
let Str.390 : Int1 = StructAtIndex 2 Str.80;
if Str.390 then
let Str.392 : Str = StructAtIndex 1 Str.80;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392;
ret Str.391;
procedure Str.9 (Str.81):
let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.393 then
let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.394;
else
let Str.388 : U64 = StructAtIndex 0 Str.80;
let Str.389 : U8 = StructAtIndex 3 Str.80;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.80;
let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.28;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387;
ret Str.385;
let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.388;
procedure Test.20 (Test.56):
let Test.296 : Str = CallByName Encode.23 Test.56;

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

@ -38,32 +38,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395;
let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.398;
procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396;
let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.399;
procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393;
let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.396;
procedure Str.9 (Str.79):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79;
let Str.390 : Int1 = StructAtIndex 2 Str.80;
if Str.390 then
let Str.392 : Str = StructAtIndex 1 Str.80;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392;
ret Str.391;
procedure Str.9 (Str.81):
let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.393 then
let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.394;
else
let Str.388 : U64 = StructAtIndex 0 Str.80;
let Str.389 : U8 = StructAtIndex 3 Str.80;
let #Derived_gen.3 : Str = StructAtIndex 1 Str.80;
let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.3 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.3;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387;
ret Str.385;
let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.388;
procedure Test.20 (Test.56):
let Test.259 : Str = CallByName Encode.23 Test.56;

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

@ -110,32 +110,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395;
let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.398;
procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396;
let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.399;
procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393;
let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.396;
procedure Str.9 (Str.79):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79;
let Str.390 : Int1 = StructAtIndex 2 Str.80;
if Str.390 then
let Str.392 : Str = StructAtIndex 1 Str.80;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392;
ret Str.391;
procedure Str.9 (Str.81):
let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.393 then
let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.394;
else
let Str.388 : U64 = StructAtIndex 0 Str.80;
let Str.389 : U8 = StructAtIndex 3 Str.80;
let #Derived_gen.27 : Str = StructAtIndex 1 Str.80;
let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.27 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.27;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387;
ret Str.385;
let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.388;
procedure Test.20 (Test.56):
let Test.297 : Str = CallByName Encode.23 Test.56;

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

@ -113,32 +113,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395;
let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.398;
procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396;
let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.399;
procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393;
let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.396;
procedure Str.9 (Str.79):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79;
let Str.390 : Int1 = StructAtIndex 2 Str.80;
if Str.390 then
let Str.392 : Str = StructAtIndex 1 Str.80;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392;
ret Str.391;
procedure Str.9 (Str.81):
let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.393 then
let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.394;
else
let Str.388 : U64 = StructAtIndex 0 Str.80;
let Str.389 : U8 = StructAtIndex 3 Str.80;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.80;
let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.28;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387;
ret Str.385;
let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.388;
procedure Test.20 (Test.56):
let Test.301 : Str = CallByName Encode.23 Test.56;

296
crates/compiler/test_mono/generated/inspect_derived_dict.txt generated
View file

@ -1204,188 +1204,188 @@ procedure Num.96 (#Attr.2):
ret Num.440;
procedure Str.12 (#Attr.2):
let Str.387 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.387;
let Str.390 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.390;
procedure Str.20 (#Attr.2):
let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.456;
let Str.459 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.459;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
let Str.391 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.391;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.446;
let Str.449 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.449;
procedure Str.36 (#Attr.2):
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408;
let Str.411 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.411;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406;
let Str.409 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.409;
procedure Str.38 (Str.213, Str.214):
let Str.402 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.415 : U8 = 1i64;
let Str.416 : U8 = GetTagId Str.402;
let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.417 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.411 : U64 = CallByName Str.36 Str.213;
let Str.412 : U64 = CallByName Str.36 Str.214;
let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.216 : U64 = CallByName Num.20 Str.410 Str.215;
let Str.409 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.409 Str.215;
let Str.407 : U64 = CallByName Str.36 Str.214;
let Str.405 : U64 = CallByName Num.51 Str.215 Str.407;
let Str.218 : Str = CallByName Str.37 Str.213 Str.405 Str.216;
let Str.404 : {Str, Str} = Struct {Str.218, Str.217};
let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.403;
procedure Str.38 (Str.215, Str.216):
let Str.405 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.418 : U8 = 1i64;
let Str.419 : U8 = GetTagId Str.405;
let Str.420 : Int1 = lowlevel Eq Str.418 Str.419;
if Str.420 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.405;
let Str.414 : U64 = CallByName Str.36 Str.215;
let Str.415 : U64 = CallByName Str.36 Str.216;
let Str.413 : U64 = CallByName Num.20 Str.414 Str.415;
let Str.218 : U64 = CallByName Num.20 Str.413 Str.217;
let Str.412 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.412 Str.217;
let Str.410 : U64 = CallByName Str.36 Str.216;
let Str.408 : U64 = CallByName Num.51 Str.217 Str.410;
let Str.220 : Str = CallByName Str.37 Str.215 Str.408 Str.218;
let Str.407 : {Str, Str} = Struct {Str.220, Str.219};
let Str.406 : [C {}, C {Str, Str}] = TagId(1) Str.407;
ret Str.406;
else
dec Str.213;
let Str.414 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.413;
dec Str.215;
let Str.417 : {} = Struct {};
let Str.416 : [C {}, C {Str, Str}] = TagId(0) Str.417;
ret Str.416;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.492 : U8 = 1i64;
let Str.493 : U8 = GetTagId Str.484;
let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.494 then
let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.196 : Str = StructAtIndex 0 Str.491;
let Str.195 : Str = StructAtIndex 1 Str.491;
let Str.489 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.488 : Str = CallByName Str.20 Str.489;
let Str.487 : Str = CallByName Str.3 Str.488 Str.195;
dec Str.195;
let Str.486 : Str = CallByName Str.3 Str.487 Str.194;
let Str.485 : Str = CallByName Str.64 Str.486 Str.196 Str.193 Str.194;
ret Str.485;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.487 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.495 : U8 = 1i64;
let Str.496 : U8 = GetTagId Str.487;
let Str.497 : Int1 = lowlevel Eq Str.495 Str.496;
if Str.497 then
let Str.494 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.487;
let Str.198 : Str = StructAtIndex 0 Str.494;
let Str.197 : Str = StructAtIndex 1 Str.494;
let Str.492 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.491 : Str = CallByName Str.20 Str.492;
let Str.490 : Str = CallByName Str.3 Str.491 Str.197;
dec Str.197;
let Str.489 : Str = CallByName Str.3 Str.490 Str.196;
let Str.488 : Str = CallByName Str.65 Str.489 Str.198 Str.195 Str.196;
ret Str.488;
else
dec Str.484;
ret Str.192;
dec Str.487;
ret Str.194;
procedure Str.64 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
joinpoint Str.392 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.399 : U8 = 1i64;
let Str.400 : U8 = GetTagId Str.393;
let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.401 then
dec Str.198;
let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
let Str.202 : Str = StructAtIndex 0 Str.398;
let Str.201 : Str = StructAtIndex 1 Str.398;
let Str.396 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.395 : Str = CallByName Str.3 Str.396 Str.200;
jump Str.392 Str.395 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.393;
procedure Str.65 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
joinpoint Str.395 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.396 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.402 : U8 = 1i64;
let Str.403 : U8 = GetTagId Str.396;
let Str.404 : Int1 = lowlevel Eq Str.402 Str.403;
if Str.404 then
dec Str.200;
let Str.397 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.397;
let Str.401 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.396;
let Str.204 : Str = StructAtIndex 0 Str.401;
let Str.203 : Str = StructAtIndex 1 Str.401;
let Str.399 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.398 : Str = CallByName Str.3 Str.399 Str.202;
jump Str.395 Str.398 Str.204 Str.201 Str.202;
else
dec Str.201;
dec Str.396;
dec Str.202;
let Str.400 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.400;
in
inc #Derived_gen.12;
inc #Derived_gen.11;
jump Str.392 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
jump Str.395 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.419 : U64 = 0i64;
let Str.418 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.419 Str.226;
ret Str.418;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.422 : U64 = 0i64;
let Str.421 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.422 Str.228;
ret Str.421;
procedure Str.66 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
joinpoint Str.420 Str.227 Str.228 Str.229 Str.230:
let Str.422 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.422 then
let Str.426 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.426 then
dec Str.227;
dec Str.228;
let Str.427 : [C , C U64] = TagId(1) Str.229;
ret Str.427;
procedure Str.67 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
joinpoint Str.423 Str.229 Str.230 Str.231 Str.232:
let Str.425 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.425 then
let Str.429 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.429 then
dec Str.230;
dec Str.229;
let Str.430 : [C , C U64] = TagId(1) Str.231;
ret Str.430;
else
let Str.425 : U64 = 1i64;
let Str.424 : U64 = CallByName Num.51 Str.229 Str.425;
jump Str.420 Str.227 Str.228 Str.424 Str.230;
let Str.428 : U64 = 1i64;
let Str.427 : U64 = CallByName Num.51 Str.231 Str.428;
jump Str.423 Str.229 Str.230 Str.427 Str.232;
else
dec Str.227;
dec Str.228;
let Str.421 : [C , C U64] = TagId(0) ;
ret Str.421;
dec Str.230;
dec Str.229;
let Str.424 : [C , C U64] = TagId(0) ;
ret Str.424;
in
inc #Derived_gen.14;
inc #Derived_gen.13;
jump Str.420 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
jump Str.423 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
procedure Str.69 (Str.253, Str.254):
let Str.451 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.451 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.454 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.454 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.449 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.449 Str.258;
let Str.448 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.452 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.452 Str.260;
let Str.451 : U64 = 0i64;
inc Str.257;
let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.448, Str.259};
let Str.428 : Int1 = CallByName Str.71 Str.429;
ret Str.428;
inc Str.259;
let Str.432 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.451, Str.261};
let Str.431 : Int1 = CallByName Str.72 Str.432;
ret Str.431;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.444 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.445 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.434 : U64 = StructAtIndex 0 Str.261;
let Str.435 : Str = StructAtIndex 1 Str.261;
let Str.437 : Str = StructAtIndex 3 Str.261;
let Str.439 : U64 = StructAtIndex 5 Str.261;
let Str.443 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.265 Str.443;
let Str.442 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.263 Str.442;
let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439};
let Str.271 : Int1 = CallByName Str.71 Str.433;
if Str.270 then
ret Str.271;
let Str.447 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.448 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.447 Str.448;
let Str.437 : U64 = StructAtIndex 0 Str.263;
let Str.438 : Str = StructAtIndex 1 Str.263;
let Str.440 : Str = StructAtIndex 3 Str.263;
let Str.442 : U64 = StructAtIndex 5 Str.263;
let Str.446 : U64 = 1i64;
let Str.444 : U64 = CallByName Num.51 Str.267 Str.446;
let Str.445 : U64 = 1i64;
let Str.443 : U64 = CallByName Num.51 Str.265 Str.445;
let Str.436 : {U64, Str, U64, Str, U64, U64} = Struct {Str.437, Str.438, Str.443, Str.440, Str.444, Str.442};
let Str.273 : Int1 = CallByName Str.72 Str.436;
if Str.272 then
ret Str.273;
else
let Str.431 : Int1 = CallByName Bool.1;
ret Str.431;
let Str.434 : Int1 = CallByName Bool.1;
ret Str.434;
procedure Test.0 ():
let Test.8 : Str = "a";

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

@ -163,8 +163,8 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Test.0 ():
let Test.2 : List I64 = Array [1i64, 2i64, 3i64];

292
crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt generated
View file

@ -322,184 +322,184 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.295;
procedure Str.20 (#Attr.2):
let Str.454 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.454;
let Str.457 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.457;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386;
let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.389;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.444 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.444;
let Str.447 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.447;
procedure Str.36 (#Attr.2):
let Str.406 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.406;
let Str.409 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.409;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.404 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.404;
let Str.407 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.407;
procedure Str.38 (Str.213, Str.214):
let Str.400 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.413 : U8 = 1i64;
let Str.414 : U8 = GetTagId Str.400;
let Str.415 : Int1 = lowlevel Eq Str.413 Str.414;
if Str.415 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.400;
let Str.409 : U64 = CallByName Str.36 Str.213;
let Str.410 : U64 = CallByName Str.36 Str.214;
let Str.408 : U64 = CallByName Num.20 Str.409 Str.410;
let Str.216 : U64 = CallByName Num.20 Str.408 Str.215;
let Str.407 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.407 Str.215;
let Str.405 : U64 = CallByName Str.36 Str.214;
let Str.403 : U64 = CallByName Num.51 Str.215 Str.405;
let Str.218 : Str = CallByName Str.37 Str.213 Str.403 Str.216;
let Str.402 : {Str, Str} = Struct {Str.218, Str.217};
let Str.401 : [C {}, C {Str, Str}] = TagId(1) Str.402;
ret Str.401;
procedure Str.38 (Str.215, Str.216):
let Str.403 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.416 : U8 = 1i64;
let Str.417 : U8 = GetTagId Str.403;
let Str.418 : Int1 = lowlevel Eq Str.416 Str.417;
if Str.418 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.403;
let Str.412 : U64 = CallByName Str.36 Str.215;
let Str.413 : U64 = CallByName Str.36 Str.216;
let Str.411 : U64 = CallByName Num.20 Str.412 Str.413;
let Str.218 : U64 = CallByName Num.20 Str.411 Str.217;
let Str.410 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.410 Str.217;
let Str.408 : U64 = CallByName Str.36 Str.216;
let Str.406 : U64 = CallByName Num.51 Str.217 Str.408;
let Str.220 : Str = CallByName Str.37 Str.215 Str.406 Str.218;
let Str.405 : {Str, Str} = Struct {Str.220, Str.219};
let Str.404 : [C {}, C {Str, Str}] = TagId(1) Str.405;
ret Str.404;
else
dec Str.213;
let Str.412 : {} = Struct {};
let Str.411 : [C {}, C {Str, Str}] = TagId(0) Str.412;
ret Str.411;
dec Str.215;
let Str.415 : {} = Struct {};
let Str.414 : [C {}, C {Str, Str}] = TagId(0) Str.415;
ret Str.414;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.482 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.490 : U8 = 1i64;
let Str.491 : U8 = GetTagId Str.482;
let Str.492 : Int1 = lowlevel Eq Str.490 Str.491;
if Str.492 then
let Str.489 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.482;
let Str.196 : Str = StructAtIndex 0 Str.489;
let Str.195 : Str = StructAtIndex 1 Str.489;
let Str.487 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.486 : Str = CallByName Str.20 Str.487;
let Str.485 : Str = CallByName Str.3 Str.486 Str.195;
dec Str.195;
let Str.484 : Str = CallByName Str.3 Str.485 Str.194;
let Str.483 : Str = CallByName Str.64 Str.484 Str.196 Str.193 Str.194;
ret Str.483;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.485 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.493 : U8 = 1i64;
let Str.494 : U8 = GetTagId Str.485;
let Str.495 : Int1 = lowlevel Eq Str.493 Str.494;
if Str.495 then
let Str.492 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.485;
let Str.198 : Str = StructAtIndex 0 Str.492;
let Str.197 : Str = StructAtIndex 1 Str.492;
let Str.490 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.489 : Str = CallByName Str.20 Str.490;
let Str.488 : Str = CallByName Str.3 Str.489 Str.197;
dec Str.197;
let Str.487 : Str = CallByName Str.3 Str.488 Str.196;
let Str.486 : Str = CallByName Str.65 Str.487 Str.198 Str.195 Str.196;
ret Str.486;
else
dec Str.482;
ret Str.192;
dec Str.485;
ret Str.194;
procedure Str.64 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
joinpoint Str.390 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.391 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.397 : U8 = 1i64;
let Str.398 : U8 = GetTagId Str.391;
let Str.399 : Int1 = lowlevel Eq Str.397 Str.398;
if Str.399 then
dec Str.198;
let Str.396 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.391;
let Str.202 : Str = StructAtIndex 0 Str.396;
let Str.201 : Str = StructAtIndex 1 Str.396;
let Str.394 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.393 : Str = CallByName Str.3 Str.394 Str.200;
jump Str.390 Str.393 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.391;
procedure Str.65 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
joinpoint Str.393 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.394 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.400 : U8 = 1i64;
let Str.401 : U8 = GetTagId Str.394;
let Str.402 : Int1 = lowlevel Eq Str.400 Str.401;
if Str.402 then
dec Str.200;
let Str.395 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.395;
let Str.399 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.394;
let Str.204 : Str = StructAtIndex 0 Str.399;
let Str.203 : Str = StructAtIndex 1 Str.399;
let Str.397 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.396 : Str = CallByName Str.3 Str.397 Str.202;
jump Str.393 Str.396 Str.204 Str.201 Str.202;
else
dec Str.201;
dec Str.202;
dec Str.394;
let Str.398 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.398;
in
inc #Derived_gen.27;
inc #Derived_gen.26;
jump Str.390 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
jump Str.393 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.417 : U64 = 0i64;
let Str.416 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.417 Str.226;
ret Str.416;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.420 : U64 = 0i64;
let Str.419 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.420 Str.228;
ret Str.419;
procedure Str.66 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31):
joinpoint Str.418 Str.227 Str.228 Str.229 Str.230:
let Str.420 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.420 then
let Str.424 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.424 then
dec Str.227;
dec Str.228;
let Str.425 : [C , C U64] = TagId(1) Str.229;
ret Str.425;
procedure Str.67 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31):
joinpoint Str.421 Str.229 Str.230 Str.231 Str.232:
let Str.423 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.423 then
let Str.427 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.427 then
dec Str.230;
dec Str.229;
let Str.428 : [C , C U64] = TagId(1) Str.231;
ret Str.428;
else
let Str.423 : U64 = 1i64;
let Str.422 : U64 = CallByName Num.51 Str.229 Str.423;
jump Str.418 Str.227 Str.228 Str.422 Str.230;
let Str.426 : U64 = 1i64;
let Str.425 : U64 = CallByName Num.51 Str.231 Str.426;
jump Str.421 Str.229 Str.230 Str.425 Str.232;
else
dec Str.227;
dec Str.228;
let Str.419 : [C , C U64] = TagId(0) ;
ret Str.419;
dec Str.230;
dec Str.229;
let Str.422 : [C , C U64] = TagId(0) ;
ret Str.422;
in
inc #Derived_gen.29;
inc #Derived_gen.28;
jump Str.418 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31;
jump Str.421 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31;
procedure Str.69 (Str.253, Str.254):
let Str.449 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.449 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.452 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.452 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.447 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.447 Str.258;
let Str.446 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.450 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.450 Str.260;
let Str.449 : U64 = 0i64;
inc Str.257;
let Str.427 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.446, Str.259};
let Str.426 : Int1 = CallByName Str.71 Str.427;
ret Str.426;
inc Str.259;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.449, Str.261};
let Str.429 : Int1 = CallByName Str.72 Str.430;
ret Str.429;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.442 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.443 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.442 Str.443;
let Str.432 : U64 = StructAtIndex 0 Str.261;
let Str.433 : Str = StructAtIndex 1 Str.261;
let Str.435 : Str = StructAtIndex 3 Str.261;
let Str.437 : U64 = StructAtIndex 5 Str.261;
let Str.441 : U64 = 1i64;
let Str.439 : U64 = CallByName Num.51 Str.265 Str.441;
let Str.440 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.263 Str.440;
let Str.431 : {U64, Str, U64, Str, U64, U64} = Struct {Str.432, Str.433, Str.438, Str.435, Str.439, Str.437};
let Str.271 : Int1 = CallByName Str.71 Str.431;
if Str.270 then
ret Str.271;
let Str.445 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.446 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.445 Str.446;
let Str.435 : U64 = StructAtIndex 0 Str.263;
let Str.436 : Str = StructAtIndex 1 Str.263;
let Str.438 : Str = StructAtIndex 3 Str.263;
let Str.440 : U64 = StructAtIndex 5 Str.263;
let Str.444 : U64 = 1i64;
let Str.442 : U64 = CallByName Num.51 Str.267 Str.444;
let Str.443 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.265 Str.443;
let Str.434 : {U64, Str, U64, Str, U64, U64} = Struct {Str.435, Str.436, Str.441, Str.438, Str.442, Str.440};
let Str.273 : Int1 = CallByName Str.72 Str.434;
if Str.272 then
ret Str.273;
else
let Str.429 : Int1 = CallByName Bool.1;
ret Str.429;
let Str.432 : Int1 = CallByName Bool.1;
ret Str.432;
procedure Test.0 ():
let Test.4 : Str = "bar";

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

@ -198,8 +198,8 @@ procedure Num.96 (#Attr.2):
ret Num.284;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Test.0 ():
let Test.3 : Decimal = 3dec;

292
crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt generated
View file

@ -216,184 +216,184 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453;
let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443;
let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.446;
procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406;
procedure Str.38 (Str.213, Str.214):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.412 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413;
if Str.414 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399;
let Str.408 : U64 = CallByName Str.36 Str.213;
let Str.409 : U64 = CallByName Str.36 Str.214;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215;
let Str.406 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215;
let Str.404 : U64 = CallByName Str.36 Str.214;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401;
ret Str.400;
procedure Str.38 (Str.215, Str.216):
let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.415 : U8 = 1i64;
let Str.416 : U8 = GetTagId Str.402;
let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.417 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.409 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.403;
else
dec Str.213;
let Str.411 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411;
ret Str.410;
dec Str.215;
let Str.414 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.489 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490;
if Str.491 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481;
let Str.196 : Str = StructAtIndex 0 Str.488;
let Str.195 : Str = StructAtIndex 1 Str.488;
let Str.486 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.485 : Str = CallByName Str.20 Str.486;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195;
dec Str.195;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194;
ret Str.482;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.492 : U8 = 1i64;
let Str.493 : U8 = GetTagId Str.484;
let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.494 then
let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.488 : Str = CallByName Str.20 Str.489;
let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.197;
let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.485;
else
dec Str.481;
ret Str.192;
dec Str.484;
ret Str.194;
procedure Str.64 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.396 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397;
if Str.398 then
dec Str.198;
let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390;
let Str.202 : Str = StructAtIndex 0 Str.395;
let Str.201 : Str = StructAtIndex 1 Str.395;
let Str.393 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.392 : Str = CallByName Str.3 Str.393 Str.200;
jump Str.389 Str.392 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.390;
procedure Str.65 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.399 : U8 = 1i64;
let Str.400 : U8 = GetTagId Str.393;
let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.401 then
dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.394;
let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
let Str.204 : Str = StructAtIndex 0 Str.398;
let Str.203 : Str = StructAtIndex 1 Str.398;
let Str.396 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.395 : Str = CallByName Str.3 Str.396 Str.202;
jump Str.392 Str.395 Str.204 Str.201 Str.202;
else
dec Str.201;
dec Str.202;
dec Str.393;
let Str.397 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.397;
in
inc #Derived_gen.14;
inc #Derived_gen.15;
jump Str.389 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
jump Str.392 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.416 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226;
ret Str.415;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.419 : U64 = 0i64;
let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.418;
procedure Str.66 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.419 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.423 then
dec Str.227;
dec Str.228;
let Str.424 : [C , C U64] = TagId(1) Str.229;
ret Str.424;
procedure Str.67 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.422 then
let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.426 then
dec Str.230;
dec Str.229;
let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.427;
else
let Str.422 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422;
jump Str.417 Str.227 Str.228 Str.421 Str.230;
let Str.425 : U64 = 1i64;
let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.420 Str.229 Str.230 Str.424 Str.232;
else
dec Str.227;
dec Str.228;
let Str.418 : [C , C U64] = TagId(0) ;
ret Str.418;
dec Str.230;
dec Str.229;
let Str.421 : [C , C U64] = TagId(0) ;
ret Str.421;
in
inc #Derived_gen.17;
inc #Derived_gen.16;
jump Str.417 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
jump Str.420 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
procedure Str.69 (Str.253, Str.254):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.448 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.451 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258;
let Str.445 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.448 : U64 = 0i64;
inc Str.257;
let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259};
let Str.425 : Int1 = CallByName Str.71 Str.426;
ret Str.425;
inc Str.259;
let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442;
let Str.431 : U64 = StructAtIndex 0 Str.261;
let Str.432 : Str = StructAtIndex 1 Str.261;
let Str.434 : Str = StructAtIndex 3 Str.261;
let Str.436 : U64 = StructAtIndex 5 Str.261;
let Str.440 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440;
let Str.439 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436};
let Str.271 : Int1 = CallByName Str.71 Str.430;
if Str.270 then
ret Str.271;
let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.443 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.442 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439};
let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.272 then
ret Str.273;
else
let Str.428 : Int1 = CallByName Bool.1;
ret Str.428;
let Str.431 : Int1 = CallByName Bool.1;
ret Str.431;
procedure Test.0 ():
let Test.3 : Str = "foo";

292
crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt generated
View file

@ -223,184 +223,184 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453;
let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443;
let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.446;
procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406;
procedure Str.38 (Str.213, Str.214):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.412 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413;
if Str.414 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399;
let Str.408 : U64 = CallByName Str.36 Str.213;
let Str.409 : U64 = CallByName Str.36 Str.214;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215;
let Str.406 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215;
let Str.404 : U64 = CallByName Str.36 Str.214;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401;
ret Str.400;
procedure Str.38 (Str.215, Str.216):
let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.415 : U8 = 1i64;
let Str.416 : U8 = GetTagId Str.402;
let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.417 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.409 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.403;
else
dec Str.213;
let Str.411 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411;
ret Str.410;
dec Str.215;
let Str.414 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.525 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.533 : U8 = 1i64;
let Str.534 : U8 = GetTagId Str.525;
let Str.535 : Int1 = lowlevel Eq Str.533 Str.534;
if Str.535 then
let Str.532 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.525;
let Str.196 : Str = StructAtIndex 0 Str.532;
let Str.195 : Str = StructAtIndex 1 Str.532;
let Str.530 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.529 : Str = CallByName Str.20 Str.530;
let Str.528 : Str = CallByName Str.3 Str.529 Str.195;
dec Str.195;
let Str.527 : Str = CallByName Str.3 Str.528 Str.194;
let Str.526 : Str = CallByName Str.64 Str.527 Str.196 Str.193 Str.194;
ret Str.526;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.528 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.536 : U8 = 1i64;
let Str.537 : U8 = GetTagId Str.528;
let Str.538 : Int1 = lowlevel Eq Str.536 Str.537;
if Str.538 then
let Str.535 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.528;
let Str.198 : Str = StructAtIndex 0 Str.535;
let Str.197 : Str = StructAtIndex 1 Str.535;
let Str.533 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.532 : Str = CallByName Str.20 Str.533;
let Str.531 : Str = CallByName Str.3 Str.532 Str.197;
dec Str.197;
let Str.530 : Str = CallByName Str.3 Str.531 Str.196;
let Str.529 : Str = CallByName Str.65 Str.530 Str.198 Str.195 Str.196;
ret Str.529;
else
dec Str.525;
ret Str.192;
dec Str.528;
ret Str.194;
procedure Str.64 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.396 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397;
if Str.398 then
dec Str.198;
let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390;
let Str.202 : Str = StructAtIndex 0 Str.395;
let Str.201 : Str = StructAtIndex 1 Str.395;
let Str.393 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.392 : Str = CallByName Str.3 Str.393 Str.200;
jump Str.389 Str.392 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.390;
procedure Str.65 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.399 : U8 = 1i64;
let Str.400 : U8 = GetTagId Str.393;
let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.401 then
dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.394;
let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
let Str.204 : Str = StructAtIndex 0 Str.398;
let Str.203 : Str = StructAtIndex 1 Str.398;
let Str.396 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.395 : Str = CallByName Str.3 Str.396 Str.202;
jump Str.392 Str.395 Str.204 Str.201 Str.202;
else
dec Str.201;
dec Str.202;
dec Str.393;
let Str.397 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.397;
in
inc #Derived_gen.18;
inc #Derived_gen.19;
jump Str.389 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
jump Str.392 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.416 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226;
ret Str.415;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.419 : U64 = 0i64;
let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.418;
procedure Str.66 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.419 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.423 then
dec Str.227;
dec Str.228;
let Str.424 : [C , C U64] = TagId(1) Str.229;
ret Str.424;
procedure Str.67 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.422 then
let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.426 then
dec Str.230;
dec Str.229;
let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.427;
else
let Str.422 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422;
jump Str.417 Str.227 Str.228 Str.421 Str.230;
let Str.425 : U64 = 1i64;
let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.420 Str.229 Str.230 Str.424 Str.232;
else
dec Str.227;
dec Str.228;
let Str.418 : [C , C U64] = TagId(0) ;
ret Str.418;
dec Str.230;
dec Str.229;
let Str.421 : [C , C U64] = TagId(0) ;
ret Str.421;
in
inc #Derived_gen.20;
inc #Derived_gen.21;
jump Str.417 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
jump Str.420 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
procedure Str.69 (Str.253, Str.254):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.448 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.451 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258;
let Str.445 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.448 : U64 = 0i64;
inc Str.257;
let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259};
let Str.425 : Int1 = CallByName Str.71 Str.426;
ret Str.425;
inc Str.259;
let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442;
let Str.431 : U64 = StructAtIndex 0 Str.261;
let Str.432 : Str = StructAtIndex 1 Str.261;
let Str.434 : Str = StructAtIndex 3 Str.261;
let Str.436 : U64 = StructAtIndex 5 Str.261;
let Str.440 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440;
let Str.439 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436};
let Str.271 : Int1 = CallByName Str.71 Str.430;
if Str.270 then
ret Str.271;
let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.443 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.442 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439};
let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.272 then
ret Str.273;
else
let Str.428 : Int1 = CallByName Bool.1;
ret Str.428;
let Str.431 : Int1 = CallByName Bool.1;
ret Str.431;
procedure Test.0 ():
let Test.3 : Str = "foo";

292
crates/compiler/test_mono/generated/inspect_derived_string.txt generated
View file

@ -100,184 +100,184 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453;
let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443;
let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.446;
procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406;
procedure Str.38 (Str.213, Str.214):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.412 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413;
if Str.414 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399;
let Str.408 : U64 = CallByName Str.36 Str.213;
let Str.409 : U64 = CallByName Str.36 Str.214;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215;
let Str.406 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215;
let Str.404 : U64 = CallByName Str.36 Str.214;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401;
ret Str.400;
procedure Str.38 (Str.215, Str.216):
let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.415 : U8 = 1i64;
let Str.416 : U8 = GetTagId Str.402;
let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.417 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.409 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.403;
else
dec Str.213;
let Str.411 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411;
ret Str.410;
dec Str.215;
let Str.414 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.489 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490;
if Str.491 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481;
let Str.196 : Str = StructAtIndex 0 Str.488;
let Str.195 : Str = StructAtIndex 1 Str.488;
let Str.486 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.485 : Str = CallByName Str.20 Str.486;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195;
dec Str.195;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194;
ret Str.482;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.492 : U8 = 1i64;
let Str.493 : U8 = GetTagId Str.484;
let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.494 then
let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.488 : Str = CallByName Str.20 Str.489;
let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.197;
let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.485;
else
dec Str.481;
ret Str.192;
dec Str.484;
ret Str.194;
procedure Str.64 (Bool.24, Bool.25, Bool.26, Bool.27):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.396 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397;
if Str.398 then
dec Str.198;
let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390;
let Str.202 : Str = StructAtIndex 0 Str.395;
let Str.201 : Str = StructAtIndex 1 Str.395;
let Str.393 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.392 : Str = CallByName Str.3 Str.393 Str.200;
jump Str.389 Str.392 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.390;
procedure Str.65 (Bool.24, Bool.25, Bool.26, Bool.27):
joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.399 : U8 = 1i64;
let Str.400 : U8 = GetTagId Str.393;
let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.401 then
dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.394;
let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
let Str.204 : Str = StructAtIndex 0 Str.398;
let Str.203 : Str = StructAtIndex 1 Str.398;
let Str.396 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.395 : Str = CallByName Str.3 Str.396 Str.202;
jump Str.392 Str.395 Str.204 Str.201 Str.202;
else
dec Str.201;
dec Str.202;
dec Str.393;
let Str.397 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.397;
in
inc Bool.26;
inc Bool.27;
jump Str.389 Bool.24 Bool.25 Bool.26 Bool.27;
jump Str.392 Bool.24 Bool.25 Bool.26 Bool.27;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.416 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226;
ret Str.415;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.419 : U64 = 0i64;
let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.418;
procedure Str.66 (Bool.28, Bool.29, Bool.30, Bool.31):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.419 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.423 then
dec Str.227;
dec Str.228;
let Str.424 : [C , C U64] = TagId(1) Str.229;
ret Str.424;
procedure Str.67 (Bool.28, Bool.29, Bool.30, Bool.31):
joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.422 then
let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.426 then
dec Str.230;
dec Str.229;
let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.427;
else
let Str.422 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422;
jump Str.417 Str.227 Str.228 Str.421 Str.230;
let Str.425 : U64 = 1i64;
let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.420 Str.229 Str.230 Str.424 Str.232;
else
dec Str.227;
dec Str.228;
let Str.418 : [C , C U64] = TagId(0) ;
ret Str.418;
dec Str.230;
dec Str.229;
let Str.421 : [C , C U64] = TagId(0) ;
ret Str.421;
in
inc Bool.29;
inc Bool.28;
jump Str.417 Bool.28 Bool.29 Bool.30 Bool.31;
jump Str.420 Bool.28 Bool.29 Bool.30 Bool.31;
procedure Str.69 (Str.253, Str.254):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.448 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.451 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258;
let Str.445 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.448 : U64 = 0i64;
inc Str.257;
let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259};
let Str.425 : Int1 = CallByName Str.71 Str.426;
ret Str.425;
inc Str.259;
let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442;
let Str.431 : U64 = StructAtIndex 0 Str.261;
let Str.432 : Str = StructAtIndex 1 Str.261;
let Str.434 : Str = StructAtIndex 3 Str.261;
let Str.436 : U64 = StructAtIndex 5 Str.261;
let Str.440 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440;
let Str.439 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436};
let Str.271 : Int1 = CallByName Str.71 Str.430;
if Str.270 then
ret Str.271;
let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.443 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.442 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439};
let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.272 then
ret Str.273;
else
let Str.428 : Int1 = CallByName Bool.1;
ret Str.428;
let Str.431 : Int1 = CallByName Bool.1;
ret Str.431;
procedure Test.0 ():
let Test.2 : Str = "abc";

292
crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt generated
View file

@ -223,184 +223,184 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453;
let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443;
let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.446;
procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406;
procedure Str.38 (Str.213, Str.214):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.412 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413;
if Str.414 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399;
let Str.408 : U64 = CallByName Str.36 Str.213;
let Str.409 : U64 = CallByName Str.36 Str.214;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215;
let Str.406 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215;
let Str.404 : U64 = CallByName Str.36 Str.214;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401;
ret Str.400;
procedure Str.38 (Str.215, Str.216):
let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.415 : U8 = 1i64;
let Str.416 : U8 = GetTagId Str.402;
let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.417 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.409 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.403;
else
dec Str.213;
let Str.411 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411;
ret Str.410;
dec Str.215;
let Str.414 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.489 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490;
if Str.491 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481;
let Str.196 : Str = StructAtIndex 0 Str.488;
let Str.195 : Str = StructAtIndex 1 Str.488;
let Str.486 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.485 : Str = CallByName Str.20 Str.486;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195;
dec Str.195;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194;
ret Str.482;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.492 : U8 = 1i64;
let Str.493 : U8 = GetTagId Str.484;
let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.494 then
let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.488 : Str = CallByName Str.20 Str.489;
let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.197;
let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.485;
else
dec Str.481;
ret Str.192;
dec Str.484;
ret Str.194;
procedure Str.64 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.396 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397;
if Str.398 then
dec Str.198;
let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390;
let Str.202 : Str = StructAtIndex 0 Str.395;
let Str.201 : Str = StructAtIndex 1 Str.395;
let Str.393 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.392 : Str = CallByName Str.3 Str.393 Str.200;
jump Str.389 Str.392 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.390;
procedure Str.65 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.399 : U8 = 1i64;
let Str.400 : U8 = GetTagId Str.393;
let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.401 then
dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.394;
let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
let Str.204 : Str = StructAtIndex 0 Str.398;
let Str.203 : Str = StructAtIndex 1 Str.398;
let Str.396 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.395 : Str = CallByName Str.3 Str.396 Str.202;
jump Str.392 Str.395 Str.204 Str.201 Str.202;
else
dec Str.201;
dec Str.202;
dec Str.393;
let Str.397 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.397;
in
inc #Derived_gen.14;
inc #Derived_gen.15;
jump Str.389 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
jump Str.392 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.416 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226;
ret Str.415;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.419 : U64 = 0i64;
let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.418;
procedure Str.66 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.419 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.423 then
dec Str.227;
dec Str.228;
let Str.424 : [C , C U64] = TagId(1) Str.229;
ret Str.424;
procedure Str.67 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.422 then
let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.426 then
dec Str.230;
dec Str.229;
let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.427;
else
let Str.422 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422;
jump Str.417 Str.227 Str.228 Str.421 Str.230;
let Str.425 : U64 = 1i64;
let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.420 Str.229 Str.230 Str.424 Str.232;
else
dec Str.227;
dec Str.228;
let Str.418 : [C , C U64] = TagId(0) ;
ret Str.418;
dec Str.230;
dec Str.229;
let Str.421 : [C , C U64] = TagId(0) ;
ret Str.421;
in
inc #Derived_gen.17;
inc #Derived_gen.16;
jump Str.417 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
jump Str.420 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19;
procedure Str.69 (Str.253, Str.254):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.448 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.451 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258;
let Str.445 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.448 : U64 = 0i64;
inc Str.257;
let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259};
let Str.425 : Int1 = CallByName Str.71 Str.426;
ret Str.425;
inc Str.259;
let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442;
let Str.431 : U64 = StructAtIndex 0 Str.261;
let Str.432 : Str = StructAtIndex 1 Str.261;
let Str.434 : Str = StructAtIndex 3 Str.261;
let Str.436 : U64 = StructAtIndex 5 Str.261;
let Str.440 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440;
let Str.439 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436};
let Str.271 : Int1 = CallByName Str.71 Str.430;
if Str.270 then
ret Str.271;
let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.443 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.442 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439};
let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.272 then
ret Str.273;
else
let Str.428 : Int1 = CallByName Bool.1;
ret Str.428;
let Str.431 : Int1 = CallByName Bool.1;
ret Str.431;
procedure Test.0 ():
let Test.4 : Str = "foo";

292
crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt generated
View file

@ -226,184 +226,184 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453;
let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443;
let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.446;
procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405;
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403;
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406;
procedure Str.38 (Str.213, Str.214):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214;
let Str.412 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413;
if Str.414 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399;
let Str.408 : U64 = CallByName Str.36 Str.213;
let Str.409 : U64 = CallByName Str.36 Str.214;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215;
let Str.406 : U64 = 0i64;
inc Str.213;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215;
let Str.404 : U64 = CallByName Str.36 Str.214;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401;
ret Str.400;
procedure Str.38 (Str.215, Str.216):
let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.415 : U8 = 1i64;
let Str.416 : U8 = GetTagId Str.402;
let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.417 then
let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.409 : U64 = 0i64;
inc Str.215;
let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.403;
else
dec Str.213;
let Str.411 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411;
ret Str.410;
dec Str.215;
let Str.414 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194):
inc Str.192;
let Str.525 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193;
let Str.533 : U8 = 1i64;
let Str.534 : U8 = GetTagId Str.525;
let Str.535 : Int1 = lowlevel Eq Str.533 Str.534;
if Str.535 then
let Str.532 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.525;
let Str.196 : Str = StructAtIndex 0 Str.532;
let Str.195 : Str = StructAtIndex 1 Str.532;
let Str.530 : U64 = CallByName Str.36 Str.192;
dec Str.192;
let Str.529 : Str = CallByName Str.20 Str.530;
let Str.528 : Str = CallByName Str.3 Str.529 Str.195;
dec Str.195;
let Str.527 : Str = CallByName Str.3 Str.528 Str.194;
let Str.526 : Str = CallByName Str.64 Str.527 Str.196 Str.193 Str.194;
ret Str.526;
procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.194;
let Str.528 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.536 : U8 = 1i64;
let Str.537 : U8 = GetTagId Str.528;
let Str.538 : Int1 = lowlevel Eq Str.536 Str.537;
if Str.538 then
let Str.535 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.528;
let Str.198 : Str = StructAtIndex 0 Str.535;
let Str.197 : Str = StructAtIndex 1 Str.535;
let Str.533 : U64 = CallByName Str.36 Str.194;
dec Str.194;
let Str.532 : Str = CallByName Str.20 Str.533;
let Str.531 : Str = CallByName Str.3 Str.532 Str.197;
dec Str.197;
let Str.530 : Str = CallByName Str.3 Str.531 Str.196;
let Str.529 : Str = CallByName Str.65 Str.530 Str.198 Str.195 Str.196;
ret Str.529;
else
dec Str.525;
ret Str.192;
dec Str.528;
ret Str.194;
procedure Str.64 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200:
inc Str.198;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199;
let Str.396 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397;
if Str.398 then
dec Str.198;
let Str.395 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.390;
let Str.202 : Str = StructAtIndex 0 Str.395;
let Str.201 : Str = StructAtIndex 1 Str.395;
let Str.393 : Str = CallByName Str.3 Str.197 Str.201;
dec Str.201;
let Str.392 : Str = CallByName Str.3 Str.393 Str.200;
jump Str.389 Str.392 Str.202 Str.199 Str.200;
else
dec Str.199;
dec Str.390;
procedure Str.65 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.200;
let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.399 : U8 = 1i64;
let Str.400 : U8 = GetTagId Str.393;
let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.401 then
dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198;
dec Str.198;
ret Str.394;
let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
let Str.204 : Str = StructAtIndex 0 Str.398;
let Str.203 : Str = StructAtIndex 1 Str.398;
let Str.396 : Str = CallByName Str.3 Str.199 Str.203;
dec Str.203;
let Str.395 : Str = CallByName Str.3 Str.396 Str.202;
jump Str.392 Str.395 Str.204 Str.201 Str.202;
else
dec Str.201;
dec Str.202;
dec Str.393;
let Str.397 : Str = CallByName Str.3 Str.199 Str.200;
dec Str.200;
ret Str.397;
in
inc #Derived_gen.15;
inc #Derived_gen.16;
jump Str.389 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
jump Str.392 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
procedure Str.65 (Str.222, Str.223):
let Str.224 : U64 = CallByName Str.36 Str.222;
let Str.225 : U64 = CallByName Str.36 Str.223;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225;
let Str.416 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226;
ret Str.415;
procedure Str.66 (Str.224, Str.225):
let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.419 : U64 = 0i64;
let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.418;
procedure Str.66 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230;
if Str.419 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228;
if Str.423 then
dec Str.227;
dec Str.228;
let Str.424 : [C , C U64] = TagId(1) Str.229;
ret Str.424;
procedure Str.67 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.422 then
let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.426 then
dec Str.230;
dec Str.229;
let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.427;
else
let Str.422 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422;
jump Str.417 Str.227 Str.228 Str.421 Str.230;
let Str.425 : U64 = 1i64;
let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.420 Str.229 Str.230 Str.424 Str.232;
else
dec Str.227;
dec Str.228;
let Str.418 : [C , C U64] = TagId(0) ;
ret Str.418;
dec Str.230;
dec Str.229;
let Str.421 : [C , C U64] = TagId(0) ;
ret Str.421;
in
inc #Derived_gen.17;
inc #Derived_gen.18;
jump Str.417 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
jump Str.420 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
procedure Str.69 (Str.253, Str.254):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254;
if Str.448 then
ret Str.253;
procedure Str.70 (Str.255, Str.256):
let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.451 then
ret Str.255;
else
ret Str.254;
ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257):
let Str.258 : U64 = CallByName Str.36 Str.255;
let Str.259 : U64 = CallByName Str.36 Str.257;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258;
let Str.445 : U64 = 0i64;
inc Str.255;
procedure Str.71 (Str.257, Str.258, Str.259):
let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.448 : U64 = 0i64;
inc Str.257;
let Str.426 : {U64, Str, U64, Str, U64, U64} = Struct {Str.260, Str.255, Str.256, Str.257, Str.445, Str.259};
let Str.425 : Int1 = CallByName Str.71 Str.426;
ret Str.425;
inc Str.259;
let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261):
let Str.267 : U64 = StructAtIndex 0 Str.261;
let Str.262 : Str = StructAtIndex 1 Str.261;
let Str.263 : U64 = StructAtIndex 2 Str.261;
let Str.264 : Str = StructAtIndex 3 Str.261;
let Str.265 : U64 = StructAtIndex 4 Str.261;
let Str.266 : U64 = StructAtIndex 5 Str.261;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267;
if Str.268 then
dec Str.262;
procedure Str.72 (Str.263):
let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.270 then
dec Str.266;
dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266;
ret Str.269;
let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.271;
else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442;
let Str.431 : U64 = StructAtIndex 0 Str.261;
let Str.432 : Str = StructAtIndex 1 Str.261;
let Str.434 : Str = StructAtIndex 3 Str.261;
let Str.436 : U64 = StructAtIndex 5 Str.261;
let Str.440 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440;
let Str.439 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436};
let Str.271 : Int1 = CallByName Str.71 Str.430;
if Str.270 then
ret Str.271;
let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.443 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.442 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439};
let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.272 then
ret Str.273;
else
let Str.428 : Int1 = CallByName Bool.1;
ret Str.428;
let Str.431 : Int1 = CallByName Bool.1;
ret Str.431;
procedure Test.0 ():
let Test.5 : Str = "foo";

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

@ -45,27 +45,27 @@ procedure Num.22 (#Attr.2, #Attr.3):
let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.283;
procedure Str.27 (Str.185):
let Str.385 : [C Int1, C I64] = CallByName Str.74 Str.185;
ret Str.385;
procedure Str.27 (Str.187):
let Str.388 : [C Int1, C I64] = CallByName Str.75 Str.187;
ret Str.388;
procedure Str.42 (#Attr.2):
let Str.393 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.393;
let Str.396 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.396;
procedure Str.74 (Str.292):
let Str.293 : {I64, U8} = CallByName Str.42 Str.292;
let Str.391 : U8 = StructAtIndex 1 Str.293;
let Str.392 : U8 = 0i64;
let Str.388 : Int1 = CallByName Bool.9 Str.391 Str.392;
if Str.388 then
let Str.390 : I64 = StructAtIndex 0 Str.293;
let Str.389 : [C Int1, C I64] = TagId(1) Str.390;
ret Str.389;
procedure Str.75 (Str.294):
let Str.295 : {I64, U8} = CallByName Str.42 Str.294;
let Str.394 : U8 = StructAtIndex 1 Str.295;
let Str.395 : U8 = 0i64;
let Str.391 : Int1 = CallByName Bool.9 Str.394 Str.395;
if Str.391 then
let Str.393 : I64 = StructAtIndex 0 Str.295;
let Str.392 : [C Int1, C I64] = TagId(1) Str.393;
ret Str.392;
else
let Str.387 : Int1 = false;
let Str.386 : [C Int1, C I64] = TagId(0) Str.387;
ret Str.386;
let Str.390 : Int1 = false;
let Str.389 : [C Int1, C I64] = TagId(0) Str.390;
ret Str.389;
procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2;

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

@ -19,30 +19,30 @@ procedure Decode.26 (Decode.109, Decode.110):
ret Decode.126;
procedure Str.12 (#Attr.2):
let Str.394 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.394;
let Str.397 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.397;
procedure Str.27 (Str.185):
let Str.385 : [C {}, C I64] = CallByName Str.74 Str.185;
ret Str.385;
procedure Str.27 (Str.187):
let Str.388 : [C {}, C I64] = CallByName Str.75 Str.187;
ret Str.388;
procedure Str.42 (#Attr.2):
let Str.393 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.393;
let Str.396 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.396;
procedure Str.74 (Str.292):
let Str.293 : {I64, U8} = CallByName Str.42 Str.292;
let Str.391 : U8 = StructAtIndex 1 Str.293;
let Str.392 : U8 = 0i64;
let Str.388 : Int1 = CallByName Bool.9 Str.391 Str.392;
if Str.388 then
let Str.390 : I64 = StructAtIndex 0 Str.293;
let Str.389 : [C {}, C I64] = TagId(1) Str.390;
ret Str.389;
procedure Str.75 (Str.294):
let Str.295 : {I64, U8} = CallByName Str.42 Str.294;
let Str.394 : U8 = StructAtIndex 1 Str.295;
let Str.395 : U8 = 0i64;
let Str.391 : Int1 = CallByName Bool.9 Str.394 Str.395;
if Str.391 then
let Str.393 : I64 = StructAtIndex 0 Str.295;
let Str.392 : [C {}, C I64] = TagId(1) Str.393;
ret Str.392;
else
let Str.387 : {} = Struct {};
let Str.386 : [C {}, C I64] = TagId(0) Str.387;
ret Str.386;
let Str.390 : {} = Struct {};
let Str.389 : [C {}, C I64] = TagId(0) Str.390;
ret Str.389;
procedure Test.103 ():
let Test.101 : [C Str, C {List U8, I64}] = CallByName Test.19;

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

@ -1,6 +1,6 @@
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Test.1 (Test.5):
let Test.16 : [C {}, C U64, C Str] = TagId(0) Test.5;

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

@ -71,12 +71,12 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.285;
procedure Str.16 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.388;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386;
let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.389;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -70,8 +70,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.285;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386;
let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.389;
procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong";

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

@ -43,8 +43,8 @@ procedure Num.96 (#Attr.2):
ret Num.284;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385;
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388;
procedure Test.0 ():
let Test.2 : I64 = 1i64;

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

@ -3,8 +3,8 @@ procedure Bool.9 (#Attr.2, #Attr.3):
ret Bool.21;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386;
let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.389;
procedure Test.2 (Test.7):
let Test.24 : Str = ".trace(\"";

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

@ -3,8 +3,8 @@ procedure Num.20 (#Attr.2, #Attr.3):
ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.387 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.387;
let Str.390 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.390;
procedure Test.11 (Test.29, #Attr.12):
let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;

34
crates/compiler/test_mono/generated/return_annotated.txt generated
View file

@ -2,27 +2,27 @@ procedure Bool.9 (#Attr.2, #Attr.3):
let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21;
procedure Str.26 (Str.184):
let Str.385 : [C {}, C U64] = CallByName Str.74 Str.184;
ret Str.385;
procedure Str.26 (Str.186):
let Str.388 : [C {}, C U64] = CallByName Str.75 Str.186;
ret Str.388;
procedure Str.42 (#Attr.2):
let Str.393 : {U64, U8} = lowlevel StrToNum #Attr.2;
ret Str.393;
let Str.396 : {U64, U8} = lowlevel StrToNum #Attr.2;
ret Str.396;
procedure Str.74 (Str.292):
let Str.293 : {U64, U8} = CallByName Str.42 Str.292;
let Str.391 : U8 = StructAtIndex 1 Str.293;
let Str.392 : U8 = 0i64;
let Str.388 : Int1 = CallByName Bool.9 Str.391 Str.392;
if Str.388 then
let Str.390 : U64 = StructAtIndex 0 Str.293;
let Str.389 : [C {}, C U64] = TagId(1) Str.390;
ret Str.389;
procedure Str.75 (Str.294):
let Str.295 : {U64, U8} = CallByName Str.42 Str.294;
let Str.394 : U8 = StructAtIndex 1 Str.295;
let Str.395 : U8 = 0i64;
let Str.391 : Int1 = CallByName Bool.9 Str.394 Str.395;
if Str.391 then
let Str.393 : U64 = StructAtIndex 0 Str.295;
let Str.392 : [C {}, C U64] = TagId(1) Str.393;
ret Str.392;
else
let Str.387 : {} = Struct {};
let Str.386 : [C {}, C U64] = TagId(0) Str.387;
ret Str.386;
let Str.390 : {} = Struct {};
let Str.389 : [C {}, C U64] = TagId(0) Str.390;
ret Str.389;
procedure Test.1 (Test.2):
joinpoint Test.11 Test.3:

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

@ -99,12 +99,12 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.386 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.386;
let Str.389 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.389;
procedure Str.36 (#Attr.2):
let Str.387 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.387;
let Str.390 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.390;
procedure Test.20 (Test.58):
let Test.295 : Str = CallByName Encode.23 Test.58;

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

@ -192,12 +192,12 @@ procedure Num.96 (#Attr.2):
ret Num.287;
procedure Str.12 (#Attr.2):
let Str.389 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.389;
let Str.392 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.392;
procedure Str.36 (#Attr.2):
let Str.390 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.390;
let Str.393 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.393;
procedure Test.20 (Test.58):
inc Test.58;