language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-30 08:37:22 +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

14
crates/compiler/builtins/roc/Str.roc
View file

@ -333,6 +333,7 @@ module [
join_with,
split_on,
repeat,
len,
count_utf8_bytes,
to_utf8,
from_utf8,
@ -521,6 +522,11 @@ split_on : Str, Str -> List Str
## ```
repeat : Str, U64 -> Str
## A stub function to help people discover [how they should handle this in Roc](https://www.roc-lang.org/faq.html#strings-in-roc).
len : Str -> [LearnAboutStringsInRoc Str]
len = |_str|
LearnAboutStringsInRoc "We want to help you make reliable software, so we aim to make sure that you're aware of all the pitfalls when handing strings. For (professional) software that needs to be reliable, check out the explainer [here](https://www.roc-lang.org/builtins/Str) and the [unicode package](https://github.com/roc-lang/unicode). For personal scripts or things like advent of code, the [roc-ascii package](https://github.com/Hasnep/roc-ascii) can cover your needs."
## Returns a [List] of the string's [U8] UTF-8 [code units](https://unicode.org/glossary/#code_unit).
## (To split the string into a [List] of smaller [Str] values instead of [U8] values,
## see [Str.split_on].)
@ -1306,9 +1312,9 @@ drop_prefix : Str, Str -> Str
drop_prefix = |haystack, prefix|
if Str.starts_with(haystack, prefix) then
start = Str.count_utf8_bytes(prefix)
len = Num.sub_wrap(Str.count_utf8_bytes(haystack), start)
remaining_len = Num.sub_wrap(Str.count_utf8_bytes(haystack), start)
substring_unsafe(haystack, start, len)
substring_unsafe(haystack, start, remaining_len)
else
haystack
@ -1323,9 +1329,9 @@ drop_suffix : Str, Str -> Str
drop_suffix = |haystack, suffix|
if Str.ends_with(haystack, suffix) then
start = 0
len = Num.sub_wrap(Str.count_utf8_bytes(haystack), Str.count_utf8_bytes(suffix))
remaining_len = Num.sub_wrap(Str.count_utf8_bytes(haystack), Str.count_utf8_bytes(suffix))
substring_unsafe(haystack, start, len)
substring_unsafe(haystack, start, remaining_len)
else
haystack

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;

4
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic.txt
View file

@ -46,8 +46,8 @@ procedure Inspect.64 (Inspect.297):
ret Inspect.297;
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 : {} = Struct {};

4
crates/compiler/uitest/tests/ability/specialize/inspect/opaque_automatic_late.txt
View file

@ -49,8 +49,8 @@ procedure Inspect.64 (Inspect.297):
ret Inspect.297;
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.2 (Test.3):
let Test.4 : Str = CallByName Inspect.33 Test.3;