language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-10-03 16:44:33 +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, join_with,
split_on, split_on,
repeat, repeat,
len,
count_utf8_bytes, count_utf8_bytes,
to_utf8, to_utf8,
from_utf8, from_utf8,
@ -521,6 +522,11 @@ split_on : Str, Str -> List Str
## ``` ## ```
repeat : Str, U64 -> 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). ## 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, ## (To split the string into a [List] of smaller [Str] values instead of [U8] values,
## see [Str.split_on].) ## see [Str.split_on].)
@ -1306,9 +1312,9 @@ drop_prefix : Str, Str -> Str
drop_prefix = |haystack, prefix| drop_prefix = |haystack, prefix|
if Str.starts_with(haystack, prefix) then if Str.starts_with(haystack, prefix) then
start = Str.count_utf8_bytes(prefix) 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 else
haystack haystack
@ -1323,9 +1329,9 @@ drop_suffix : Str, Str -> Str
drop_suffix = |haystack, suffix| drop_suffix = |haystack, suffix|
if Str.ends_with(haystack, suffix) then if Str.ends_with(haystack, suffix) then
start = 0 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 else
haystack 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; ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.387 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.390 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.387; ret Str.390;
procedure Test.1 (Test.5): procedure Test.1 (Test.5):
ret 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; ret Num.284;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : I64 = 1i64; 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; ret Num.293;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453; ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443; ret Str.446;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405; ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403; ret Str.406;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.412 : U8 = 1i64; let Str.415 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399; let Str.416 : U8 = GetTagId Str.402;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.414 then if Str.417 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.408 : U64 = CallByName Str.36 Str.213; let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.409 : U64 = CallByName Str.36 Str.214; let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.406 : U64 = 0i64; let Str.409 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.404 : U64 = CallByName Str.36 Str.214; let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.400; ret Str.403;
else else
dec Str.213; dec Str.215;
let Str.411 : {} = Struct {}; let Str.414 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.410; ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.489 : U8 = 1i64; let Str.492 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481; let Str.493 : U8 = GetTagId Str.484;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.491 then if Str.494 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.196 : Str = StructAtIndex 0 Str.488; let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.195 : Str = StructAtIndex 1 Str.488; let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.486 : U64 = CallByName Str.36 Str.192; let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.485 : Str = CallByName Str.20 Str.486; let Str.488 : Str = CallByName Str.20 Str.489;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195; let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.195; dec Str.197;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194; let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.482; ret Str.485;
else else
dec Str.481; dec Str.484;
ret Str.192; ret Str.194;
procedure Str.64 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3): procedure Str.65 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.396 : U8 = 1i64; let Str.399 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390; let Str.400 : U8 = GetTagId Str.393;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.398 then if Str.401 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;
dec Str.200; dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198; let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.398;
ret Str.394; 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 in
inc #Derived_gen.3; inc #Derived_gen.3;
inc #Derived_gen.2; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.416 : U64 = 0i64; let Str.419 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.415; ret Str.418;
procedure Str.66 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7): procedure Str.67 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.419 then if Str.422 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.423 then if Str.426 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.424 : [C , C U64] = TagId(1) Str.229; let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.424; ret Str.427;
else else
let Str.422 : U64 = 1i64; let Str.425 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.417 Str.227 Str.228 Str.421 Str.230; jump Str.420 Str.229 Str.230 Str.424 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.418 : [C , C U64] = TagId(0) ; let Str.421 : [C , C U64] = TagId(0) ;
ret Str.418; ret Str.421;
in in
inc #Derived_gen.5; inc #Derived_gen.5;
inc #Derived_gen.4; 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): procedure Str.70 (Str.255, Str.256):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.448 then if Str.451 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.445 : U64 = 0i64; let Str.448 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.425 : Int1 = CallByName Str.71 Str.426; let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
ret Str.425; let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.431 : U64 = StructAtIndex 0 Str.261; let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.432 : Str = StructAtIndex 1 Str.261; let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.434 : Str = StructAtIndex 3 Str.261; let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.436 : U64 = StructAtIndex 5 Str.261; let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.440 : U64 = 1i64; let Str.443 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.439 : U64 = 1i64; let Str.442 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; 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.430; let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.428 : Int1 = CallByName Bool.1; let Str.431 : Int1 = CallByName Bool.1;
ret Str.428; ret Str.431;
procedure Test.1 (): procedure Test.1 ():
let Test.4 : Str = ""; 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; ret Num.293;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.455 : Str = lowlevel StrWithCapacity #Attr.2; let Str.458 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.455; ret Str.458;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.387 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.390 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.387; ret Str.390;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.445 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.448 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.445; ret Str.448;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.407 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.410 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.407; ret Str.410;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.405 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.408 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.405; ret Str.408;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.401 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.404 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.414 : U8 = 1i64; let Str.417 : U8 = 1i64;
let Str.415 : U8 = GetTagId Str.401; let Str.418 : U8 = GetTagId Str.404;
let Str.416 : Int1 = lowlevel Eq Str.414 Str.415; let Str.419 : Int1 = lowlevel Eq Str.417 Str.418;
if Str.416 then if Str.419 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.401; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.404;
let Str.410 : U64 = CallByName Str.36 Str.213; let Str.413 : U64 = CallByName Str.36 Str.215;
let Str.411 : U64 = CallByName Str.36 Str.214; let Str.414 : U64 = CallByName Str.36 Str.216;
let Str.409 : U64 = CallByName Num.20 Str.410 Str.411; let Str.412 : U64 = CallByName Num.20 Str.413 Str.414;
let Str.216 : U64 = CallByName Num.20 Str.409 Str.215; let Str.218 : U64 = CallByName Num.20 Str.412 Str.217;
let Str.408 : U64 = 0i64; let Str.411 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.408 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.411 Str.217;
let Str.406 : U64 = CallByName Str.36 Str.214; let Str.409 : U64 = CallByName Str.36 Str.216;
let Str.404 : U64 = CallByName Num.51 Str.215 Str.406; let Str.407 : U64 = CallByName Num.51 Str.217 Str.409;
let Str.218 : Str = CallByName Str.37 Str.213 Str.404 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.407 Str.218;
let Str.403 : {Str, Str} = Struct {Str.218, Str.217}; let Str.406 : {Str, Str} = Struct {Str.220, Str.219};
let Str.402 : [C {}, C {Str, Str}] = TagId(1) Str.403; let Str.405 : [C {}, C {Str, Str}] = TagId(1) Str.406;
ret Str.402; ret Str.405;
else else
dec Str.213; dec Str.215;
let Str.413 : {} = Struct {}; let Str.416 : {} = Struct {};
let Str.412 : [C {}, C {Str, Str}] = TagId(0) Str.413; let Str.415 : [C {}, C {Str, Str}] = TagId(0) Str.416;
ret Str.412; ret Str.415;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.483 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.486 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.491 : U8 = 1i64; let Str.494 : U8 = 1i64;
let Str.492 : U8 = GetTagId Str.483; let Str.495 : U8 = GetTagId Str.486;
let Str.493 : Int1 = lowlevel Eq Str.491 Str.492; let Str.496 : Int1 = lowlevel Eq Str.494 Str.495;
if Str.493 then if Str.496 then
let Str.490 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.483; let Str.493 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.486;
let Str.196 : Str = StructAtIndex 0 Str.490; let Str.198 : Str = StructAtIndex 0 Str.493;
let Str.195 : Str = StructAtIndex 1 Str.490; let Str.197 : Str = StructAtIndex 1 Str.493;
let Str.488 : U64 = CallByName Str.36 Str.192; let Str.491 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.487 : Str = CallByName Str.20 Str.488; let Str.490 : Str = CallByName Str.20 Str.491;
let Str.486 : Str = CallByName Str.3 Str.487 Str.195; let Str.489 : Str = CallByName Str.3 Str.490 Str.197;
dec Str.195; dec Str.197;
let Str.485 : Str = CallByName Str.3 Str.486 Str.194; let Str.488 : Str = CallByName Str.3 Str.489 Str.196;
let Str.484 : Str = CallByName Str.64 Str.485 Str.196 Str.193 Str.194; let Str.487 : Str = CallByName Str.65 Str.488 Str.198 Str.195 Str.196;
ret Str.484; ret Str.487;
else else
dec Str.483; dec Str.486;
ret Str.192; ret Str.194;
procedure Str.64 (Bool.24, Bool.25, Bool.26, Bool.27): procedure Str.65 (Bool.24, Bool.25, Bool.26, Bool.27):
joinpoint Str.391 Str.197 Str.198 Str.199 Str.200: joinpoint Str.394 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.392 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.395 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.398 : U8 = 1i64; let Str.401 : U8 = 1i64;
let Str.399 : U8 = GetTagId Str.392; let Str.402 : U8 = GetTagId Str.395;
let Str.400 : Int1 = lowlevel Eq Str.398 Str.399; let Str.403 : Int1 = lowlevel Eq Str.401 Str.402;
if Str.400 then if Str.403 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;
dec Str.200; dec Str.200;
let Str.396 : Str = CallByName Str.3 Str.197 Str.198; let Str.400 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.395;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.400;
ret Str.396; 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 in
inc Bool.26; inc Bool.26;
inc Bool.27; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.418 : U64 = 0i64; let Str.421 : U64 = 0i64;
let Str.417 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.418 Str.226; let Str.420 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.421 Str.228;
ret Str.417; ret Str.420;
procedure Str.66 (Bool.28, Bool.29, Bool.30, Bool.31): procedure Str.67 (Bool.28, Bool.29, Bool.30, Bool.31):
joinpoint Str.419 Str.227 Str.228 Str.229 Str.230: joinpoint Str.422 Str.229 Str.230 Str.231 Str.232:
let Str.421 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.424 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.421 then if Str.424 then
let Str.425 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.428 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.425 then if Str.428 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.426 : [C , C U64] = TagId(1) Str.229; let Str.429 : [C , C U64] = TagId(1) Str.231;
ret Str.426; ret Str.429;
else else
let Str.424 : U64 = 1i64; let Str.427 : U64 = 1i64;
let Str.423 : U64 = CallByName Num.51 Str.229 Str.424; let Str.426 : U64 = CallByName Num.51 Str.231 Str.427;
jump Str.419 Str.227 Str.228 Str.423 Str.230; jump Str.422 Str.229 Str.230 Str.426 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.420 : [C , C U64] = TagId(0) ; let Str.423 : [C , C U64] = TagId(0) ;
ret Str.420; ret Str.423;
in in
inc Bool.29; inc Bool.29;
inc Bool.28; 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): procedure Str.70 (Str.255, Str.256):
let Str.450 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.453 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.450 then if Str.453 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.448 : U64 = CallByName Num.53 Str.256 Str.259; let Str.451 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.448 Str.258; let Str.262 : U64 = CallByName Str.70 Str.451 Str.260;
let Str.447 : U64 = 0i64; let Str.450 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.427 : Int1 = CallByName Str.71 Str.428; let Str.431 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.450, Str.261};
ret Str.427; let Str.430 : Int1 = CallByName Str.72 Str.431;
ret Str.430;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.443 : U8 = CallByName Str.35 Str.262 Str.263; let Str.446 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.444 : U8 = CallByName Str.35 Str.264 Str.265; let Str.447 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.443 Str.444; let Str.272 : Int1 = CallByName Bool.9 Str.446 Str.447;
let Str.433 : U64 = StructAtIndex 0 Str.261; let Str.436 : U64 = StructAtIndex 0 Str.263;
let Str.434 : Str = StructAtIndex 1 Str.261; let Str.437 : Str = StructAtIndex 1 Str.263;
let Str.436 : Str = StructAtIndex 3 Str.261; let Str.439 : Str = StructAtIndex 3 Str.263;
let Str.438 : U64 = StructAtIndex 5 Str.261; let Str.441 : U64 = StructAtIndex 5 Str.263;
let Str.442 : U64 = 1i64; let Str.445 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.265 Str.442; let Str.443 : U64 = CallByName Num.51 Str.267 Str.445;
let Str.441 : U64 = 1i64; let Str.444 : U64 = 1i64;
let Str.439 : U64 = CallByName Num.51 Str.263 Str.441; let Str.442 : U64 = CallByName Num.51 Str.265 Str.444;
let Str.432 : {U64, Str, U64, Str, U64, U64} = Struct {Str.433, Str.434, Str.439, Str.436, Str.440, Str.438}; let Str.435 : {U64, Str, U64, Str, U64, U64} = Struct {Str.436, Str.437, Str.442, Str.439, Str.443, Str.441};
let Str.271 : Int1 = CallByName Str.71 Str.432; let Str.273 : Int1 = CallByName Str.72 Str.435;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.430 : Int1 = CallByName Bool.1; let Str.433 : Int1 = CallByName Bool.1;
ret Str.430; ret Str.433;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Str = "Hello "; 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; ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Test.0 (): procedure Test.0 ():
let Test.3 : I64 = 1i64; 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; ret Num.293;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453; ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443; ret Str.446;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405; ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403; ret Str.406;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.412 : U8 = 1i64; let Str.415 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399; let Str.416 : U8 = GetTagId Str.402;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.414 then if Str.417 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.408 : U64 = CallByName Str.36 Str.213; let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.409 : U64 = CallByName Str.36 Str.214; let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.406 : U64 = 0i64; let Str.409 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.404 : U64 = CallByName Str.36 Str.214; let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.400; ret Str.403;
else else
dec Str.213; dec Str.215;
let Str.411 : {} = Struct {}; let Str.414 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.410; ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.489 : U8 = 1i64; let Str.492 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481; let Str.493 : U8 = GetTagId Str.484;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.491 then if Str.494 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.196 : Str = StructAtIndex 0 Str.488; let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.195 : Str = StructAtIndex 1 Str.488; let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.486 : U64 = CallByName Str.36 Str.192; let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.485 : Str = CallByName Str.20 Str.486; let Str.488 : Str = CallByName Str.20 Str.489;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195; let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.195; dec Str.197;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194; let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.482; ret Str.485;
else else
dec Str.481; dec Str.484;
ret Str.192; ret Str.194;
procedure Str.64 (Bool.24, Bool.25, Bool.26, Bool.27): procedure Str.65 (Bool.24, Bool.25, Bool.26, Bool.27):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.396 : U8 = 1i64; let Str.399 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390; let Str.400 : U8 = GetTagId Str.393;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.398 then if Str.401 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;
dec Str.200; dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198; let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.398;
ret Str.394; 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 in
inc Bool.26; inc Bool.26;
inc Bool.27; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.416 : U64 = 0i64; let Str.419 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.415; ret Str.418;
procedure Str.66 (Bool.28, Bool.29, Bool.30, Bool.31): procedure Str.67 (Bool.28, Bool.29, Bool.30, Bool.31):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.419 then if Str.422 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.423 then if Str.426 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.424 : [C , C U64] = TagId(1) Str.229; let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.424; ret Str.427;
else else
let Str.422 : U64 = 1i64; let Str.425 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.417 Str.227 Str.228 Str.421 Str.230; jump Str.420 Str.229 Str.230 Str.424 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.418 : [C , C U64] = TagId(0) ; let Str.421 : [C , C U64] = TagId(0) ;
ret Str.418; ret Str.421;
in in
inc Bool.29; inc Bool.29;
inc Bool.28; 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): procedure Str.70 (Str.255, Str.256):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.448 then if Str.451 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.445 : U64 = 0i64; let Str.448 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.425 : Int1 = CallByName Str.71 Str.426; let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
ret Str.425; let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.431 : U64 = StructAtIndex 0 Str.261; let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.432 : Str = StructAtIndex 1 Str.261; let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.434 : Str = StructAtIndex 3 Str.261; let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.436 : U64 = StructAtIndex 5 Str.261; let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.440 : U64 = 1i64; let Str.443 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.439 : U64 = 1i64; let Str.442 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; 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.430; let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.428 : Int1 = CallByName Bool.1; let Str.431 : Int1 = CallByName Bool.1;
ret Str.428; ret Str.431;
procedure Test.0 (): procedure Test.0 ():
let Test.3 : Str = ""; 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; ret Num.284;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386; ret Str.389;
procedure Test.1 (Test.2): procedure Test.1 (Test.2):
let Test.3 : Str = CallByName Num.96 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; ret Num.287;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.401 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.398; ret Str.401;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.402 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.399; ret Str.402;
procedure Str.43 (#Attr.2): procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393; ret Str.396;
procedure Str.9 (Str.79): procedure Str.9 (Str.81):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.390 : Int1 = StructAtIndex 2 Str.80; let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.390 then if Str.393 then
let Str.392 : Str = StructAtIndex 1 Str.80; let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.391; ret Str.394;
else else
let Str.388 : U64 = StructAtIndex 0 Str.80; let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.389 : U8 = StructAtIndex 3 Str.80; let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.45 : Str = StructAtIndex 1 Str.80; let #Derived_gen.45 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.45; dec #Derived_gen.45;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.385; ret Str.388;
procedure Test.20 (Test.56): procedure Test.20 (Test.56):
let Test.325 : Str = CallByName Encode.23 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; ret Num.283;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395; ret Str.398;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396; ret Str.399;
procedure Str.43 (#Attr.2): procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393; ret Str.396;
procedure Str.9 (Str.79): procedure Str.9 (Str.81):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.390 : Int1 = StructAtIndex 2 Str.80; let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.390 then if Str.393 then
let Str.392 : Str = StructAtIndex 1 Str.80; let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.391; ret Str.394;
else else
let Str.388 : U64 = StructAtIndex 0 Str.80; let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.389 : U8 = StructAtIndex 3 Str.80; let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.24 : Str = StructAtIndex 1 Str.80; let #Derived_gen.24 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.24; dec #Derived_gen.24;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.385; ret Str.388;
procedure Test.20 (Test.56): procedure Test.20 (Test.56):
let Test.292 : Str = CallByName Encode.23 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; ret Num.283;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395; ret Str.398;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396; ret Str.399;
procedure Str.43 (#Attr.2): procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393; ret Str.396;
procedure Str.9 (Str.79): procedure Str.9 (Str.81):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.390 : Int1 = StructAtIndex 2 Str.80; let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.390 then if Str.393 then
let Str.392 : Str = StructAtIndex 1 Str.80; let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.391; ret Str.394;
else else
let Str.388 : U64 = StructAtIndex 0 Str.80; let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.389 : U8 = StructAtIndex 3 Str.80; let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.80; let #Derived_gen.28 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.28; dec #Derived_gen.28;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.385; ret Str.388;
procedure Test.20 (Test.56): procedure Test.20 (Test.56):
let Test.296 : Str = CallByName Encode.23 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; ret Num.283;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395; ret Str.398;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396; ret Str.399;
procedure Str.43 (#Attr.2): procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393; ret Str.396;
procedure Str.9 (Str.79): procedure Str.9 (Str.81):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.390 : Int1 = StructAtIndex 2 Str.80; let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.390 then if Str.393 then
let Str.392 : Str = StructAtIndex 1 Str.80; let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.391; ret Str.394;
else else
let Str.388 : U64 = StructAtIndex 0 Str.80; let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.389 : U8 = StructAtIndex 3 Str.80; let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.3 : Str = StructAtIndex 1 Str.80; let #Derived_gen.3 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.3; dec #Derived_gen.3;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.385; ret Str.388;
procedure Test.20 (Test.56): procedure Test.20 (Test.56):
let Test.259 : Str = CallByName Encode.23 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; ret Num.283;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395; ret Str.398;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396; ret Str.399;
procedure Str.43 (#Attr.2): procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393; ret Str.396;
procedure Str.9 (Str.79): procedure Str.9 (Str.81):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.390 : Int1 = StructAtIndex 2 Str.80; let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.390 then if Str.393 then
let Str.392 : Str = StructAtIndex 1 Str.80; let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.391; ret Str.394;
else else
let Str.388 : U64 = StructAtIndex 0 Str.80; let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.389 : U8 = StructAtIndex 3 Str.80; let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.27 : Str = StructAtIndex 1 Str.80; let #Derived_gen.27 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.27; dec #Derived_gen.27;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.385; ret Str.388;
procedure Test.20 (Test.56): procedure Test.20 (Test.56):
let Test.297 : Str = CallByName Encode.23 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; ret Num.283;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.395 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.395; ret Str.398;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.396 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.396; ret Str.399;
procedure Str.43 (#Attr.2): procedure Str.43 (#Attr.2):
let Str.393 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2; let Str.396 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.393; ret Str.396;
procedure Str.9 (Str.79): procedure Str.9 (Str.81):
let Str.80 : {U64, Str, Int1, U8} = CallByName Str.43 Str.79; let Str.82 : {U64, Str, Int1, U8} = CallByName Str.43 Str.81;
let Str.390 : Int1 = StructAtIndex 2 Str.80; let Str.393 : Int1 = StructAtIndex 2 Str.82;
if Str.390 then if Str.393 then
let Str.392 : Str = StructAtIndex 1 Str.80; let Str.395 : Str = StructAtIndex 1 Str.82;
let Str.391 : [C {U64, U8}, C Str] = TagId(1) Str.392; let Str.394 : [C {U64, U8}, C Str] = TagId(1) Str.395;
ret Str.391; ret Str.394;
else else
let Str.388 : U64 = StructAtIndex 0 Str.80; let Str.391 : U64 = StructAtIndex 0 Str.82;
let Str.389 : U8 = StructAtIndex 3 Str.80; let Str.392 : U8 = StructAtIndex 3 Str.82;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.80; let #Derived_gen.28 : Str = StructAtIndex 1 Str.82;
dec #Derived_gen.28; dec #Derived_gen.28;
let Str.387 : {U64, U8} = Struct {Str.388, Str.389}; let Str.390 : {U64, U8} = Struct {Str.391, Str.392};
let Str.385 : [C {U64, U8}, C Str] = TagId(0) Str.387; let Str.388 : [C {U64, U8}, C Str] = TagId(0) Str.390;
ret Str.385; ret Str.388;
procedure Test.20 (Test.56): procedure Test.20 (Test.56):
let Test.301 : Str = CallByName Encode.23 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; ret Num.440;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.387 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.390 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.387; ret Str.390;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.456 : Str = lowlevel StrWithCapacity #Attr.2; let Str.459 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.456; ret Str.459;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.391 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.388; ret Str.391;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.449 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.446; ret Str.449;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.411 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.408; ret Str.411;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.409 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.406; ret Str.409;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.402 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.405 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.415 : U8 = 1i64; let Str.418 : U8 = 1i64;
let Str.416 : U8 = GetTagId Str.402; let Str.419 : U8 = GetTagId Str.405;
let Str.417 : Int1 = lowlevel Eq Str.415 Str.416; let Str.420 : Int1 = lowlevel Eq Str.418 Str.419;
if Str.417 then if Str.420 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.405;
let Str.411 : U64 = CallByName Str.36 Str.213; let Str.414 : U64 = CallByName Str.36 Str.215;
let Str.412 : U64 = CallByName Str.36 Str.214; let Str.415 : U64 = CallByName Str.36 Str.216;
let Str.410 : U64 = CallByName Num.20 Str.411 Str.412; let Str.413 : U64 = CallByName Num.20 Str.414 Str.415;
let Str.216 : U64 = CallByName Num.20 Str.410 Str.215; let Str.218 : U64 = CallByName Num.20 Str.413 Str.217;
let Str.409 : U64 = 0i64; let Str.412 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.409 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.412 Str.217;
let Str.407 : U64 = CallByName Str.36 Str.214; let Str.410 : U64 = CallByName Str.36 Str.216;
let Str.405 : U64 = CallByName Num.51 Str.215 Str.407; let Str.408 : U64 = CallByName Num.51 Str.217 Str.410;
let Str.218 : Str = CallByName Str.37 Str.213 Str.405 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.408 Str.218;
let Str.404 : {Str, Str} = Struct {Str.218, Str.217}; let Str.407 : {Str, Str} = Struct {Str.220, Str.219};
let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404; let Str.406 : [C {}, C {Str, Str}] = TagId(1) Str.407;
ret Str.403; ret Str.406;
else else
dec Str.213; dec Str.215;
let Str.414 : {} = Struct {}; let Str.417 : {} = Struct {};
let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414; let Str.416 : [C {}, C {Str, Str}] = TagId(0) Str.417;
ret Str.413; ret Str.416;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.487 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.492 : U8 = 1i64; let Str.495 : U8 = 1i64;
let Str.493 : U8 = GetTagId Str.484; let Str.496 : U8 = GetTagId Str.487;
let Str.494 : Int1 = lowlevel Eq Str.492 Str.493; let Str.497 : Int1 = lowlevel Eq Str.495 Str.496;
if Str.494 then if Str.497 then
let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484; let Str.494 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.487;
let Str.196 : Str = StructAtIndex 0 Str.491; let Str.198 : Str = StructAtIndex 0 Str.494;
let Str.195 : Str = StructAtIndex 1 Str.491; let Str.197 : Str = StructAtIndex 1 Str.494;
let Str.489 : U64 = CallByName Str.36 Str.192; let Str.492 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.488 : Str = CallByName Str.20 Str.489; let Str.491 : Str = CallByName Str.20 Str.492;
let Str.487 : Str = CallByName Str.3 Str.488 Str.195; let Str.490 : Str = CallByName Str.3 Str.491 Str.197;
dec Str.195; dec Str.197;
let Str.486 : Str = CallByName Str.3 Str.487 Str.194; let Str.489 : Str = CallByName Str.3 Str.490 Str.196;
let Str.485 : Str = CallByName Str.64 Str.486 Str.196 Str.193 Str.194; let Str.488 : Str = CallByName Str.65 Str.489 Str.198 Str.195 Str.196;
ret Str.485; ret Str.488;
else else
dec Str.484; dec Str.487;
ret Str.192; ret Str.194;
procedure Str.64 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12): procedure Str.65 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
joinpoint Str.392 Str.197 Str.198 Str.199 Str.200: joinpoint Str.395 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.396 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.399 : U8 = 1i64; let Str.402 : U8 = 1i64;
let Str.400 : U8 = GetTagId Str.393; let Str.403 : U8 = GetTagId Str.396;
let Str.401 : Int1 = lowlevel Eq Str.399 Str.400; let Str.404 : Int1 = lowlevel Eq Str.402 Str.403;
if Str.401 then if Str.404 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;
dec Str.200; dec Str.200;
let Str.397 : Str = CallByName Str.3 Str.197 Str.198; let Str.401 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.396;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.401;
ret Str.397; 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 in
inc #Derived_gen.12; inc #Derived_gen.12;
inc #Derived_gen.11; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.419 : U64 = 0i64; let Str.422 : U64 = 0i64;
let Str.418 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.419 Str.226; let Str.421 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.422 Str.228;
ret Str.418; ret Str.421;
procedure Str.66 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16): procedure Str.67 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
joinpoint Str.420 Str.227 Str.228 Str.229 Str.230: joinpoint Str.423 Str.229 Str.230 Str.231 Str.232:
let Str.422 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.425 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.422 then if Str.425 then
let Str.426 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.429 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.426 then if Str.429 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.427 : [C , C U64] = TagId(1) Str.229; let Str.430 : [C , C U64] = TagId(1) Str.231;
ret Str.427; ret Str.430;
else else
let Str.425 : U64 = 1i64; let Str.428 : U64 = 1i64;
let Str.424 : U64 = CallByName Num.51 Str.229 Str.425; let Str.427 : U64 = CallByName Num.51 Str.231 Str.428;
jump Str.420 Str.227 Str.228 Str.424 Str.230; jump Str.423 Str.229 Str.230 Str.427 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.421 : [C , C U64] = TagId(0) ; let Str.424 : [C , C U64] = TagId(0) ;
ret Str.421; ret Str.424;
in in
inc #Derived_gen.14; inc #Derived_gen.14;
inc #Derived_gen.13; 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): procedure Str.70 (Str.255, Str.256):
let Str.451 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.454 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.451 then if Str.454 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.449 : U64 = CallByName Num.53 Str.256 Str.259; let Str.452 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.449 Str.258; let Str.262 : U64 = CallByName Str.70 Str.452 Str.260;
let Str.448 : U64 = 0i64; let Str.451 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.428 : Int1 = CallByName Str.71 Str.429; let Str.432 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.451, Str.261};
ret Str.428; let Str.431 : Int1 = CallByName Str.72 Str.432;
ret Str.431;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.444 : U8 = CallByName Str.35 Str.262 Str.263; let Str.447 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.445 : U8 = CallByName Str.35 Str.264 Str.265; let Str.448 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.444 Str.445; let Str.272 : Int1 = CallByName Bool.9 Str.447 Str.448;
let Str.434 : U64 = StructAtIndex 0 Str.261; let Str.437 : U64 = StructAtIndex 0 Str.263;
let Str.435 : Str = StructAtIndex 1 Str.261; let Str.438 : Str = StructAtIndex 1 Str.263;
let Str.437 : Str = StructAtIndex 3 Str.261; let Str.440 : Str = StructAtIndex 3 Str.263;
let Str.439 : U64 = StructAtIndex 5 Str.261; let Str.442 : U64 = StructAtIndex 5 Str.263;
let Str.443 : U64 = 1i64; let Str.446 : U64 = 1i64;
let Str.441 : U64 = CallByName Num.51 Str.265 Str.443; let Str.444 : U64 = CallByName Num.51 Str.267 Str.446;
let Str.442 : U64 = 1i64; let Str.445 : U64 = 1i64;
let Str.440 : U64 = CallByName Num.51 Str.263 Str.442; let Str.443 : U64 = CallByName Num.51 Str.265 Str.445;
let Str.433 : {U64, Str, U64, Str, U64, U64} = Struct {Str.434, Str.435, Str.440, Str.437, Str.441, Str.439}; let Str.436 : {U64, Str, U64, Str, U64, U64} = Struct {Str.437, Str.438, Str.443, Str.440, Str.444, Str.442};
let Str.271 : Int1 = CallByName Str.71 Str.433; let Str.273 : Int1 = CallByName Str.72 Str.436;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.431 : Int1 = CallByName Bool.1; let Str.434 : Int1 = CallByName Bool.1;
ret Str.431; ret Str.434;
procedure Test.0 (): procedure Test.0 ():
let Test.8 : Str = "a"; 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; ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Test.0 (): procedure Test.0 ():
let Test.2 : List I64 = Array [1i64, 2i64, 3i64]; 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; ret Num.295;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.454 : Str = lowlevel StrWithCapacity #Attr.2; let Str.457 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.454; ret Str.457;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386; ret Str.389;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.444 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.447 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.444; ret Str.447;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.406 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.409 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.406; ret Str.409;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.404 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.407 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.404; ret Str.407;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.400 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.403 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.413 : U8 = 1i64; let Str.416 : U8 = 1i64;
let Str.414 : U8 = GetTagId Str.400; let Str.417 : U8 = GetTagId Str.403;
let Str.415 : Int1 = lowlevel Eq Str.413 Str.414; let Str.418 : Int1 = lowlevel Eq Str.416 Str.417;
if Str.415 then if Str.418 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.400; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.403;
let Str.409 : U64 = CallByName Str.36 Str.213; let Str.412 : U64 = CallByName Str.36 Str.215;
let Str.410 : U64 = CallByName Str.36 Str.214; let Str.413 : U64 = CallByName Str.36 Str.216;
let Str.408 : U64 = CallByName Num.20 Str.409 Str.410; let Str.411 : U64 = CallByName Num.20 Str.412 Str.413;
let Str.216 : U64 = CallByName Num.20 Str.408 Str.215; let Str.218 : U64 = CallByName Num.20 Str.411 Str.217;
let Str.407 : U64 = 0i64; let Str.410 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.407 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.410 Str.217;
let Str.405 : U64 = CallByName Str.36 Str.214; let Str.408 : U64 = CallByName Str.36 Str.216;
let Str.403 : U64 = CallByName Num.51 Str.215 Str.405; let Str.406 : U64 = CallByName Num.51 Str.217 Str.408;
let Str.218 : Str = CallByName Str.37 Str.213 Str.403 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.406 Str.218;
let Str.402 : {Str, Str} = Struct {Str.218, Str.217}; let Str.405 : {Str, Str} = Struct {Str.220, Str.219};
let Str.401 : [C {}, C {Str, Str}] = TagId(1) Str.402; let Str.404 : [C {}, C {Str, Str}] = TagId(1) Str.405;
ret Str.401; ret Str.404;
else else
dec Str.213; dec Str.215;
let Str.412 : {} = Struct {}; let Str.415 : {} = Struct {};
let Str.411 : [C {}, C {Str, Str}] = TagId(0) Str.412; let Str.414 : [C {}, C {Str, Str}] = TagId(0) Str.415;
ret Str.411; ret Str.414;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.482 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.485 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.490 : U8 = 1i64; let Str.493 : U8 = 1i64;
let Str.491 : U8 = GetTagId Str.482; let Str.494 : U8 = GetTagId Str.485;
let Str.492 : Int1 = lowlevel Eq Str.490 Str.491; let Str.495 : Int1 = lowlevel Eq Str.493 Str.494;
if Str.492 then if Str.495 then
let Str.489 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.482; let Str.492 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.485;
let Str.196 : Str = StructAtIndex 0 Str.489; let Str.198 : Str = StructAtIndex 0 Str.492;
let Str.195 : Str = StructAtIndex 1 Str.489; let Str.197 : Str = StructAtIndex 1 Str.492;
let Str.487 : U64 = CallByName Str.36 Str.192; let Str.490 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.486 : Str = CallByName Str.20 Str.487; let Str.489 : Str = CallByName Str.20 Str.490;
let Str.485 : Str = CallByName Str.3 Str.486 Str.195; let Str.488 : Str = CallByName Str.3 Str.489 Str.197;
dec Str.195; dec Str.197;
let Str.484 : Str = CallByName Str.3 Str.485 Str.194; let Str.487 : Str = CallByName Str.3 Str.488 Str.196;
let Str.483 : Str = CallByName Str.64 Str.484 Str.196 Str.193 Str.194; let Str.486 : Str = CallByName Str.65 Str.487 Str.198 Str.195 Str.196;
ret Str.483; ret Str.486;
else else
dec Str.482; dec Str.485;
ret Str.192; ret Str.194;
procedure Str.64 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27): procedure Str.65 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
joinpoint Str.390 Str.197 Str.198 Str.199 Str.200: joinpoint Str.393 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.391 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.394 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.397 : U8 = 1i64; let Str.400 : U8 = 1i64;
let Str.398 : U8 = GetTagId Str.391; let Str.401 : U8 = GetTagId Str.394;
let Str.399 : Int1 = lowlevel Eq Str.397 Str.398; let Str.402 : Int1 = lowlevel Eq Str.400 Str.401;
if Str.399 then if Str.402 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;
dec Str.200; dec Str.200;
let Str.395 : Str = CallByName Str.3 Str.197 Str.198; let Str.399 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.394;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.399;
ret Str.395; 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 in
inc #Derived_gen.27; inc #Derived_gen.27;
inc #Derived_gen.26; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.417 : U64 = 0i64; let Str.420 : U64 = 0i64;
let Str.416 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.417 Str.226; let Str.419 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.420 Str.228;
ret Str.416; ret Str.419;
procedure Str.66 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31): procedure Str.67 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31):
joinpoint Str.418 Str.227 Str.228 Str.229 Str.230: joinpoint Str.421 Str.229 Str.230 Str.231 Str.232:
let Str.420 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.423 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.420 then if Str.423 then
let Str.424 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.427 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.424 then if Str.427 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.425 : [C , C U64] = TagId(1) Str.229; let Str.428 : [C , C U64] = TagId(1) Str.231;
ret Str.425; ret Str.428;
else else
let Str.423 : U64 = 1i64; let Str.426 : U64 = 1i64;
let Str.422 : U64 = CallByName Num.51 Str.229 Str.423; let Str.425 : U64 = CallByName Num.51 Str.231 Str.426;
jump Str.418 Str.227 Str.228 Str.422 Str.230; jump Str.421 Str.229 Str.230 Str.425 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.419 : [C , C U64] = TagId(0) ; let Str.422 : [C , C U64] = TagId(0) ;
ret Str.419; ret Str.422;
in in
inc #Derived_gen.29; inc #Derived_gen.29;
inc #Derived_gen.28; 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): procedure Str.70 (Str.255, Str.256):
let Str.449 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.452 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.449 then if Str.452 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.447 : U64 = CallByName Num.53 Str.256 Str.259; let Str.450 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.447 Str.258; let Str.262 : U64 = CallByName Str.70 Str.450 Str.260;
let Str.446 : U64 = 0i64; let Str.449 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.426 : Int1 = CallByName Str.71 Str.427; let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.449, Str.261};
ret Str.426; let Str.429 : Int1 = CallByName Str.72 Str.430;
ret Str.429;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.442 : U8 = CallByName Str.35 Str.262 Str.263; let Str.445 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.443 : U8 = CallByName Str.35 Str.264 Str.265; let Str.446 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.442 Str.443; let Str.272 : Int1 = CallByName Bool.9 Str.445 Str.446;
let Str.432 : U64 = StructAtIndex 0 Str.261; let Str.435 : U64 = StructAtIndex 0 Str.263;
let Str.433 : Str = StructAtIndex 1 Str.261; let Str.436 : Str = StructAtIndex 1 Str.263;
let Str.435 : Str = StructAtIndex 3 Str.261; let Str.438 : Str = StructAtIndex 3 Str.263;
let Str.437 : U64 = StructAtIndex 5 Str.261; let Str.440 : U64 = StructAtIndex 5 Str.263;
let Str.441 : U64 = 1i64; let Str.444 : U64 = 1i64;
let Str.439 : U64 = CallByName Num.51 Str.265 Str.441; let Str.442 : U64 = CallByName Num.51 Str.267 Str.444;
let Str.440 : U64 = 1i64; let Str.443 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.263 Str.440; let Str.441 : U64 = CallByName Num.51 Str.265 Str.443;
let Str.431 : {U64, Str, U64, Str, U64, U64} = Struct {Str.432, Str.433, Str.438, Str.435, Str.439, Str.437}; let Str.434 : {U64, Str, U64, Str, U64, U64} = Struct {Str.435, Str.436, Str.441, Str.438, Str.442, Str.440};
let Str.271 : Int1 = CallByName Str.71 Str.431; let Str.273 : Int1 = CallByName Str.72 Str.434;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.429 : Int1 = CallByName Bool.1; let Str.432 : Int1 = CallByName Bool.1;
ret Str.429; ret Str.432;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Str = "bar"; 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; ret Num.284;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Test.0 (): procedure Test.0 ():
let Test.3 : Decimal = 3dec; 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; ret Num.293;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453; ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443; ret Str.446;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405; ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403; ret Str.406;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.412 : U8 = 1i64; let Str.415 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399; let Str.416 : U8 = GetTagId Str.402;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.414 then if Str.417 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.408 : U64 = CallByName Str.36 Str.213; let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.409 : U64 = CallByName Str.36 Str.214; let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.406 : U64 = 0i64; let Str.409 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.404 : U64 = CallByName Str.36 Str.214; let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.400; ret Str.403;
else else
dec Str.213; dec Str.215;
let Str.411 : {} = Struct {}; let Str.414 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.410; ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.489 : U8 = 1i64; let Str.492 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481; let Str.493 : U8 = GetTagId Str.484;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.491 then if Str.494 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.196 : Str = StructAtIndex 0 Str.488; let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.195 : Str = StructAtIndex 1 Str.488; let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.486 : U64 = CallByName Str.36 Str.192; let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.485 : Str = CallByName Str.20 Str.486; let Str.488 : Str = CallByName Str.20 Str.489;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195; let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.195; dec Str.197;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194; let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.482; ret Str.485;
else else
dec Str.481; dec Str.484;
ret Str.192; ret Str.194;
procedure Str.64 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15): procedure Str.65 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.396 : U8 = 1i64; let Str.399 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390; let Str.400 : U8 = GetTagId Str.393;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.398 then if Str.401 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;
dec Str.200; dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198; let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.398;
ret Str.394; 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 in
inc #Derived_gen.14; inc #Derived_gen.14;
inc #Derived_gen.15; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.416 : U64 = 0i64; let Str.419 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.415; ret Str.418;
procedure Str.66 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19): procedure Str.67 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.419 then if Str.422 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.423 then if Str.426 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.424 : [C , C U64] = TagId(1) Str.229; let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.424; ret Str.427;
else else
let Str.422 : U64 = 1i64; let Str.425 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.417 Str.227 Str.228 Str.421 Str.230; jump Str.420 Str.229 Str.230 Str.424 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.418 : [C , C U64] = TagId(0) ; let Str.421 : [C , C U64] = TagId(0) ;
ret Str.418; ret Str.421;
in in
inc #Derived_gen.17; inc #Derived_gen.17;
inc #Derived_gen.16; 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): procedure Str.70 (Str.255, Str.256):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.448 then if Str.451 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.445 : U64 = 0i64; let Str.448 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.425 : Int1 = CallByName Str.71 Str.426; let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
ret Str.425; let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.431 : U64 = StructAtIndex 0 Str.261; let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.432 : Str = StructAtIndex 1 Str.261; let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.434 : Str = StructAtIndex 3 Str.261; let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.436 : U64 = StructAtIndex 5 Str.261; let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.440 : U64 = 1i64; let Str.443 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.439 : U64 = 1i64; let Str.442 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; 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.430; let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.428 : Int1 = CallByName Bool.1; let Str.431 : Int1 = CallByName Bool.1;
ret Str.428; ret Str.431;
procedure Test.0 (): procedure Test.0 ():
let Test.3 : Str = "foo"; 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; ret Num.293;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453; ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443; ret Str.446;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405; ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403; ret Str.406;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.412 : U8 = 1i64; let Str.415 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399; let Str.416 : U8 = GetTagId Str.402;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.414 then if Str.417 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.408 : U64 = CallByName Str.36 Str.213; let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.409 : U64 = CallByName Str.36 Str.214; let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.406 : U64 = 0i64; let Str.409 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.404 : U64 = CallByName Str.36 Str.214; let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.400; ret Str.403;
else else
dec Str.213; dec Str.215;
let Str.411 : {} = Struct {}; let Str.414 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.410; ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.525 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.528 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.533 : U8 = 1i64; let Str.536 : U8 = 1i64;
let Str.534 : U8 = GetTagId Str.525; let Str.537 : U8 = GetTagId Str.528;
let Str.535 : Int1 = lowlevel Eq Str.533 Str.534; let Str.538 : Int1 = lowlevel Eq Str.536 Str.537;
if Str.535 then if Str.538 then
let Str.532 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.525; let Str.535 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.528;
let Str.196 : Str = StructAtIndex 0 Str.532; let Str.198 : Str = StructAtIndex 0 Str.535;
let Str.195 : Str = StructAtIndex 1 Str.532; let Str.197 : Str = StructAtIndex 1 Str.535;
let Str.530 : U64 = CallByName Str.36 Str.192; let Str.533 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.529 : Str = CallByName Str.20 Str.530; let Str.532 : Str = CallByName Str.20 Str.533;
let Str.528 : Str = CallByName Str.3 Str.529 Str.195; let Str.531 : Str = CallByName Str.3 Str.532 Str.197;
dec Str.195; dec Str.197;
let Str.527 : Str = CallByName Str.3 Str.528 Str.194; let Str.530 : Str = CallByName Str.3 Str.531 Str.196;
let Str.526 : Str = CallByName Str.64 Str.527 Str.196 Str.193 Str.194; let Str.529 : Str = CallByName Str.65 Str.530 Str.198 Str.195 Str.196;
ret Str.526; ret Str.529;
else else
dec Str.525; dec Str.528;
ret Str.192; ret Str.194;
procedure Str.64 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19): procedure Str.65 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.396 : U8 = 1i64; let Str.399 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390; let Str.400 : U8 = GetTagId Str.393;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.398 then if Str.401 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;
dec Str.200; dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198; let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.398;
ret Str.394; 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 in
inc #Derived_gen.18; inc #Derived_gen.18;
inc #Derived_gen.19; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.416 : U64 = 0i64; let Str.419 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.415; ret Str.418;
procedure Str.66 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23): procedure Str.67 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.419 then if Str.422 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.423 then if Str.426 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.424 : [C , C U64] = TagId(1) Str.229; let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.424; ret Str.427;
else else
let Str.422 : U64 = 1i64; let Str.425 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.417 Str.227 Str.228 Str.421 Str.230; jump Str.420 Str.229 Str.230 Str.424 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.418 : [C , C U64] = TagId(0) ; let Str.421 : [C , C U64] = TagId(0) ;
ret Str.418; ret Str.421;
in in
inc #Derived_gen.20; inc #Derived_gen.20;
inc #Derived_gen.21; 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): procedure Str.70 (Str.255, Str.256):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.448 then if Str.451 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.445 : U64 = 0i64; let Str.448 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.425 : Int1 = CallByName Str.71 Str.426; let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
ret Str.425; let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.431 : U64 = StructAtIndex 0 Str.261; let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.432 : Str = StructAtIndex 1 Str.261; let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.434 : Str = StructAtIndex 3 Str.261; let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.436 : U64 = StructAtIndex 5 Str.261; let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.440 : U64 = 1i64; let Str.443 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.439 : U64 = 1i64; let Str.442 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; 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.430; let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.428 : Int1 = CallByName Bool.1; let Str.431 : Int1 = CallByName Bool.1;
ret Str.428; ret Str.431;
procedure Test.0 (): procedure Test.0 ():
let Test.3 : Str = "foo"; 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; ret Num.293;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453; ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443; ret Str.446;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405; ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403; ret Str.406;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.412 : U8 = 1i64; let Str.415 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399; let Str.416 : U8 = GetTagId Str.402;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.414 then if Str.417 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.408 : U64 = CallByName Str.36 Str.213; let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.409 : U64 = CallByName Str.36 Str.214; let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.406 : U64 = 0i64; let Str.409 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.404 : U64 = CallByName Str.36 Str.214; let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.400; ret Str.403;
else else
dec Str.213; dec Str.215;
let Str.411 : {} = Struct {}; let Str.414 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.410; ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.489 : U8 = 1i64; let Str.492 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481; let Str.493 : U8 = GetTagId Str.484;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.491 then if Str.494 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.196 : Str = StructAtIndex 0 Str.488; let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.195 : Str = StructAtIndex 1 Str.488; let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.486 : U64 = CallByName Str.36 Str.192; let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.485 : Str = CallByName Str.20 Str.486; let Str.488 : Str = CallByName Str.20 Str.489;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195; let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.195; dec Str.197;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194; let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.482; ret Str.485;
else else
dec Str.481; dec Str.484;
ret Str.192; ret Str.194;
procedure Str.64 (Bool.24, Bool.25, Bool.26, Bool.27): procedure Str.65 (Bool.24, Bool.25, Bool.26, Bool.27):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.396 : U8 = 1i64; let Str.399 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390; let Str.400 : U8 = GetTagId Str.393;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.398 then if Str.401 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;
dec Str.200; dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198; let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.398;
ret Str.394; 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 in
inc Bool.26; inc Bool.26;
inc Bool.27; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.416 : U64 = 0i64; let Str.419 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.415; ret Str.418;
procedure Str.66 (Bool.28, Bool.29, Bool.30, Bool.31): procedure Str.67 (Bool.28, Bool.29, Bool.30, Bool.31):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.419 then if Str.422 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.423 then if Str.426 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.424 : [C , C U64] = TagId(1) Str.229; let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.424; ret Str.427;
else else
let Str.422 : U64 = 1i64; let Str.425 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.417 Str.227 Str.228 Str.421 Str.230; jump Str.420 Str.229 Str.230 Str.424 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.418 : [C , C U64] = TagId(0) ; let Str.421 : [C , C U64] = TagId(0) ;
ret Str.418; ret Str.421;
in in
inc Bool.29; inc Bool.29;
inc Bool.28; 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): procedure Str.70 (Str.255, Str.256):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.448 then if Str.451 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.445 : U64 = 0i64; let Str.448 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.425 : Int1 = CallByName Str.71 Str.426; let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
ret Str.425; let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.431 : U64 = StructAtIndex 0 Str.261; let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.432 : Str = StructAtIndex 1 Str.261; let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.434 : Str = StructAtIndex 3 Str.261; let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.436 : U64 = StructAtIndex 5 Str.261; let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.440 : U64 = 1i64; let Str.443 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.439 : U64 = 1i64; let Str.442 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; 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.430; let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.428 : Int1 = CallByName Bool.1; let Str.431 : Int1 = CallByName Bool.1;
ret Str.428; ret Str.431;
procedure Test.0 (): procedure Test.0 ():
let Test.2 : Str = "abc"; 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; ret Num.293;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453; ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443; ret Str.446;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405; ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403; ret Str.406;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.412 : U8 = 1i64; let Str.415 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399; let Str.416 : U8 = GetTagId Str.402;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.414 then if Str.417 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.408 : U64 = CallByName Str.36 Str.213; let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.409 : U64 = CallByName Str.36 Str.214; let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.406 : U64 = 0i64; let Str.409 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.404 : U64 = CallByName Str.36 Str.214; let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.400; ret Str.403;
else else
dec Str.213; dec Str.215;
let Str.411 : {} = Struct {}; let Str.414 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.410; ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.481 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.484 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.489 : U8 = 1i64; let Str.492 : U8 = 1i64;
let Str.490 : U8 = GetTagId Str.481; let Str.493 : U8 = GetTagId Str.484;
let Str.491 : Int1 = lowlevel Eq Str.489 Str.490; let Str.494 : Int1 = lowlevel Eq Str.492 Str.493;
if Str.491 then if Str.494 then
let Str.488 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.481; let Str.491 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.484;
let Str.196 : Str = StructAtIndex 0 Str.488; let Str.198 : Str = StructAtIndex 0 Str.491;
let Str.195 : Str = StructAtIndex 1 Str.488; let Str.197 : Str = StructAtIndex 1 Str.491;
let Str.486 : U64 = CallByName Str.36 Str.192; let Str.489 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.485 : Str = CallByName Str.20 Str.486; let Str.488 : Str = CallByName Str.20 Str.489;
let Str.484 : Str = CallByName Str.3 Str.485 Str.195; let Str.487 : Str = CallByName Str.3 Str.488 Str.197;
dec Str.195; dec Str.197;
let Str.483 : Str = CallByName Str.3 Str.484 Str.194; let Str.486 : Str = CallByName Str.3 Str.487 Str.196;
let Str.482 : Str = CallByName Str.64 Str.483 Str.196 Str.193 Str.194; let Str.485 : Str = CallByName Str.65 Str.486 Str.198 Str.195 Str.196;
ret Str.482; ret Str.485;
else else
dec Str.481; dec Str.484;
ret Str.192; ret Str.194;
procedure Str.64 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15): procedure Str.65 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.396 : U8 = 1i64; let Str.399 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390; let Str.400 : U8 = GetTagId Str.393;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.398 then if Str.401 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;
dec Str.200; dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198; let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.398;
ret Str.394; 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 in
inc #Derived_gen.14; inc #Derived_gen.14;
inc #Derived_gen.15; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.416 : U64 = 0i64; let Str.419 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.415; ret Str.418;
procedure Str.66 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19): procedure Str.67 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.419 then if Str.422 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.423 then if Str.426 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.424 : [C , C U64] = TagId(1) Str.229; let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.424; ret Str.427;
else else
let Str.422 : U64 = 1i64; let Str.425 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.417 Str.227 Str.228 Str.421 Str.230; jump Str.420 Str.229 Str.230 Str.424 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.418 : [C , C U64] = TagId(0) ; let Str.421 : [C , C U64] = TagId(0) ;
ret Str.418; ret Str.421;
in in
inc #Derived_gen.17; inc #Derived_gen.17;
inc #Derived_gen.16; 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): procedure Str.70 (Str.255, Str.256):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.448 then if Str.451 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.445 : U64 = 0i64; let Str.448 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.425 : Int1 = CallByName Str.71 Str.426; let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
ret Str.425; let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.431 : U64 = StructAtIndex 0 Str.261; let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.432 : Str = StructAtIndex 1 Str.261; let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.434 : Str = StructAtIndex 3 Str.261; let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.436 : U64 = StructAtIndex 5 Str.261; let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.440 : U64 = 1i64; let Str.443 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.439 : U64 = 1i64; let Str.442 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; 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.430; let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.428 : Int1 = CallByName Bool.1; let Str.431 : Int1 = CallByName Bool.1;
ret Str.428; ret Str.431;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : Str = "foo"; 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; ret Num.293;
procedure Str.20 (#Attr.2): procedure Str.20 (#Attr.2):
let Str.453 : Str = lowlevel StrWithCapacity #Attr.2; let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.453; ret Str.456;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Str.35 (#Attr.2, #Attr.3): procedure Str.35 (#Attr.2, #Attr.3):
let Str.443 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3; let Str.446 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.443; ret Str.446;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.405 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.408 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.405; ret Str.408;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4): procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.403 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4; let Str.406 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.403; ret Str.406;
procedure Str.38 (Str.213, Str.214): procedure Str.38 (Str.215, Str.216):
let Str.399 : [C , C U64] = CallByName Str.65 Str.213 Str.214; let Str.402 : [C , C U64] = CallByName Str.66 Str.215 Str.216;
let Str.412 : U8 = 1i64; let Str.415 : U8 = 1i64;
let Str.413 : U8 = GetTagId Str.399; let Str.416 : U8 = GetTagId Str.402;
let Str.414 : Int1 = lowlevel Eq Str.412 Str.413; let Str.417 : Int1 = lowlevel Eq Str.415 Str.416;
if Str.414 then if Str.417 then
let Str.215 : U64 = UnionAtIndex (Id 1) (Index 0) Str.399; let Str.217 : U64 = UnionAtIndex (Id 1) (Index 0) Str.402;
let Str.408 : U64 = CallByName Str.36 Str.213; let Str.411 : U64 = CallByName Str.36 Str.215;
let Str.409 : U64 = CallByName Str.36 Str.214; let Str.412 : U64 = CallByName Str.36 Str.216;
let Str.407 : U64 = CallByName Num.20 Str.408 Str.409; let Str.410 : U64 = CallByName Num.20 Str.411 Str.412;
let Str.216 : U64 = CallByName Num.20 Str.407 Str.215; let Str.218 : U64 = CallByName Num.20 Str.410 Str.217;
let Str.406 : U64 = 0i64; let Str.409 : U64 = 0i64;
inc Str.213; inc Str.215;
let Str.217 : Str = CallByName Str.37 Str.213 Str.406 Str.215; let Str.219 : Str = CallByName Str.37 Str.215 Str.409 Str.217;
let Str.404 : U64 = CallByName Str.36 Str.214; let Str.407 : U64 = CallByName Str.36 Str.216;
let Str.402 : U64 = CallByName Num.51 Str.215 Str.404; let Str.405 : U64 = CallByName Num.51 Str.217 Str.407;
let Str.218 : Str = CallByName Str.37 Str.213 Str.402 Str.216; let Str.220 : Str = CallByName Str.37 Str.215 Str.405 Str.218;
let Str.401 : {Str, Str} = Struct {Str.218, Str.217}; let Str.404 : {Str, Str} = Struct {Str.220, Str.219};
let Str.400 : [C {}, C {Str, Str}] = TagId(1) Str.401; let Str.403 : [C {}, C {Str, Str}] = TagId(1) Str.404;
ret Str.400; ret Str.403;
else else
dec Str.213; dec Str.215;
let Str.411 : {} = Struct {}; let Str.414 : {} = Struct {};
let Str.410 : [C {}, C {Str, Str}] = TagId(0) Str.411; let Str.413 : [C {}, C {Str, Str}] = TagId(0) Str.414;
ret Str.410; ret Str.413;
procedure Str.45 (Str.192, Str.193, Str.194): procedure Str.45 (Str.194, Str.195, Str.196):
inc Str.192; inc Str.194;
let Str.525 : [C {}, C {Str, Str}] = CallByName Str.38 Str.192 Str.193; let Str.528 : [C {}, C {Str, Str}] = CallByName Str.38 Str.194 Str.195;
let Str.533 : U8 = 1i64; let Str.536 : U8 = 1i64;
let Str.534 : U8 = GetTagId Str.525; let Str.537 : U8 = GetTagId Str.528;
let Str.535 : Int1 = lowlevel Eq Str.533 Str.534; let Str.538 : Int1 = lowlevel Eq Str.536 Str.537;
if Str.535 then if Str.538 then
let Str.532 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.525; let Str.535 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.528;
let Str.196 : Str = StructAtIndex 0 Str.532; let Str.198 : Str = StructAtIndex 0 Str.535;
let Str.195 : Str = StructAtIndex 1 Str.532; let Str.197 : Str = StructAtIndex 1 Str.535;
let Str.530 : U64 = CallByName Str.36 Str.192; let Str.533 : U64 = CallByName Str.36 Str.194;
dec Str.192; dec Str.194;
let Str.529 : Str = CallByName Str.20 Str.530; let Str.532 : Str = CallByName Str.20 Str.533;
let Str.528 : Str = CallByName Str.3 Str.529 Str.195; let Str.531 : Str = CallByName Str.3 Str.532 Str.197;
dec Str.195; dec Str.197;
let Str.527 : Str = CallByName Str.3 Str.528 Str.194; let Str.530 : Str = CallByName Str.3 Str.531 Str.196;
let Str.526 : Str = CallByName Str.64 Str.527 Str.196 Str.193 Str.194; let Str.529 : Str = CallByName Str.65 Str.530 Str.198 Str.195 Str.196;
ret Str.526; ret Str.529;
else else
dec Str.525; dec Str.528;
ret Str.192; ret Str.194;
procedure Str.64 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16): procedure Str.65 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
joinpoint Str.389 Str.197 Str.198 Str.199 Str.200: joinpoint Str.392 Str.199 Str.200 Str.201 Str.202:
inc Str.198; inc Str.200;
let Str.390 : [C {}, C {Str, Str}] = CallByName Str.38 Str.198 Str.199; let Str.393 : [C {}, C {Str, Str}] = CallByName Str.38 Str.200 Str.201;
let Str.396 : U8 = 1i64; let Str.399 : U8 = 1i64;
let Str.397 : U8 = GetTagId Str.390; let Str.400 : U8 = GetTagId Str.393;
let Str.398 : Int1 = lowlevel Eq Str.396 Str.397; let Str.401 : Int1 = lowlevel Eq Str.399 Str.400;
if Str.398 then if Str.401 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;
dec Str.200; dec Str.200;
let Str.394 : Str = CallByName Str.3 Str.197 Str.198; let Str.398 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.393;
dec Str.198; let Str.204 : Str = StructAtIndex 0 Str.398;
ret Str.394; 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 in
inc #Derived_gen.15; inc #Derived_gen.15;
inc #Derived_gen.16; 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): procedure Str.66 (Str.224, Str.225):
let Str.224 : U64 = CallByName Str.36 Str.222; let Str.226 : U64 = CallByName Str.36 Str.224;
let Str.225 : U64 = CallByName Str.36 Str.223; let Str.227 : U64 = CallByName Str.36 Str.225;
let Str.226 : U64 = CallByName Num.77 Str.224 Str.225; let Str.228 : U64 = CallByName Num.77 Str.226 Str.227;
let Str.416 : U64 = 0i64; let Str.419 : U64 = 0i64;
let Str.415 : [C , C U64] = CallByName Str.66 Str.222 Str.223 Str.416 Str.226; let Str.418 : [C , C U64] = CallByName Str.67 Str.224 Str.225 Str.419 Str.228;
ret Str.415; ret Str.418;
procedure Str.66 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20): procedure Str.67 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
joinpoint Str.417 Str.227 Str.228 Str.229 Str.230: joinpoint Str.420 Str.229 Str.230 Str.231 Str.232:
let Str.419 : Int1 = CallByName Num.23 Str.229 Str.230; let Str.422 : Int1 = CallByName Num.23 Str.231 Str.232;
if Str.419 then if Str.422 then
let Str.423 : Int1 = CallByName Str.70 Str.227 Str.229 Str.228; let Str.426 : Int1 = CallByName Str.71 Str.229 Str.231 Str.230;
if Str.423 then if Str.426 then
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.424 : [C , C U64] = TagId(1) Str.229; let Str.427 : [C , C U64] = TagId(1) Str.231;
ret Str.424; ret Str.427;
else else
let Str.422 : U64 = 1i64; let Str.425 : U64 = 1i64;
let Str.421 : U64 = CallByName Num.51 Str.229 Str.422; let Str.424 : U64 = CallByName Num.51 Str.231 Str.425;
jump Str.417 Str.227 Str.228 Str.421 Str.230; jump Str.420 Str.229 Str.230 Str.424 Str.232;
else else
dec Str.227; dec Str.230;
dec Str.228; dec Str.229;
let Str.418 : [C , C U64] = TagId(0) ; let Str.421 : [C , C U64] = TagId(0) ;
ret Str.418; ret Str.421;
in in
inc #Derived_gen.17; inc #Derived_gen.17;
inc #Derived_gen.18; 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): procedure Str.70 (Str.255, Str.256):
let Str.448 : Int1 = CallByName Num.22 Str.253 Str.254; let Str.451 : Int1 = CallByName Num.22 Str.255 Str.256;
if Str.448 then if Str.451 then
ret Str.253; ret Str.255;
else else
ret Str.254; ret Str.256;
procedure Str.70 (Str.255, Str.256, Str.257): procedure Str.71 (Str.257, Str.258, Str.259):
let Str.258 : U64 = CallByName Str.36 Str.255; let Str.260 : U64 = CallByName Str.36 Str.257;
let Str.259 : U64 = CallByName Str.36 Str.257; let Str.261 : U64 = CallByName Str.36 Str.259;
let Str.446 : U64 = CallByName Num.53 Str.256 Str.259; let Str.449 : U64 = CallByName Num.53 Str.258 Str.261;
let Str.260 : U64 = CallByName Str.69 Str.446 Str.258; let Str.262 : U64 = CallByName Str.70 Str.449 Str.260;
let Str.445 : U64 = 0i64; let Str.448 : U64 = 0i64;
inc Str.255;
inc Str.257; 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}; inc Str.259;
let Str.425 : Int1 = CallByName Str.71 Str.426; let Str.429 : {U64, Str, U64, Str, U64, U64} = Struct {Str.262, Str.257, Str.258, Str.259, Str.448, Str.261};
ret Str.425; let Str.428 : Int1 = CallByName Str.72 Str.429;
ret Str.428;
procedure Str.71 (Str.261): procedure Str.72 (Str.263):
let Str.267 : U64 = StructAtIndex 0 Str.261; let Str.269 : U64 = StructAtIndex 0 Str.263;
let Str.262 : Str = StructAtIndex 1 Str.261; let Str.264 : Str = StructAtIndex 1 Str.263;
let Str.263 : U64 = StructAtIndex 2 Str.261; let Str.265 : U64 = StructAtIndex 2 Str.263;
let Str.264 : Str = StructAtIndex 3 Str.261; let Str.266 : Str = StructAtIndex 3 Str.263;
let Str.265 : U64 = StructAtIndex 4 Str.261; let Str.267 : U64 = StructAtIndex 4 Str.263;
let Str.266 : U64 = StructAtIndex 5 Str.261; let Str.268 : U64 = StructAtIndex 5 Str.263;
let Str.268 : Int1 = CallByName Num.25 Str.263 Str.267; let Str.270 : Int1 = CallByName Num.25 Str.265 Str.269;
if Str.268 then if Str.270 then
dec Str.262; dec Str.266;
dec Str.264; dec Str.264;
let Str.269 : Int1 = CallByName Bool.9 Str.265 Str.266; let Str.271 : Int1 = CallByName Bool.9 Str.267 Str.268;
ret Str.269; ret Str.271;
else else
let Str.441 : U8 = CallByName Str.35 Str.262 Str.263; let Str.444 : U8 = CallByName Str.35 Str.264 Str.265;
let Str.442 : U8 = CallByName Str.35 Str.264 Str.265; let Str.445 : U8 = CallByName Str.35 Str.266 Str.267;
let Str.270 : Int1 = CallByName Bool.9 Str.441 Str.442; let Str.272 : Int1 = CallByName Bool.9 Str.444 Str.445;
let Str.431 : U64 = StructAtIndex 0 Str.261; let Str.434 : U64 = StructAtIndex 0 Str.263;
let Str.432 : Str = StructAtIndex 1 Str.261; let Str.435 : Str = StructAtIndex 1 Str.263;
let Str.434 : Str = StructAtIndex 3 Str.261; let Str.437 : Str = StructAtIndex 3 Str.263;
let Str.436 : U64 = StructAtIndex 5 Str.261; let Str.439 : U64 = StructAtIndex 5 Str.263;
let Str.440 : U64 = 1i64; let Str.443 : U64 = 1i64;
let Str.438 : U64 = CallByName Num.51 Str.265 Str.440; let Str.441 : U64 = CallByName Num.51 Str.267 Str.443;
let Str.439 : U64 = 1i64; let Str.442 : U64 = 1i64;
let Str.437 : U64 = CallByName Num.51 Str.263 Str.439; let Str.440 : U64 = CallByName Num.51 Str.265 Str.442;
let Str.430 : {U64, Str, U64, Str, U64, U64} = Struct {Str.431, Str.432, Str.437, Str.434, Str.438, Str.436}; 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.430; let Str.273 : Int1 = CallByName Str.72 Str.433;
if Str.270 then if Str.272 then
ret Str.271; ret Str.273;
else else
let Str.428 : Int1 = CallByName Bool.1; let Str.431 : Int1 = CallByName Bool.1;
ret Str.428; ret Str.431;
procedure Test.0 (): procedure Test.0 ():
let Test.5 : Str = "foo"; 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; let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.283; ret Num.283;
procedure Str.27 (Str.185): procedure Str.27 (Str.187):
let Str.385 : [C Int1, C I64] = CallByName Str.74 Str.185; let Str.388 : [C Int1, C I64] = CallByName Str.75 Str.187;
ret Str.385; ret Str.388;
procedure Str.42 (#Attr.2): procedure Str.42 (#Attr.2):
let Str.393 : {I64, U8} = lowlevel StrToNum #Attr.2; let Str.396 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.393; ret Str.396;
procedure Str.74 (Str.292): procedure Str.75 (Str.294):
let Str.293 : {I64, U8} = CallByName Str.42 Str.292; let Str.295 : {I64, U8} = CallByName Str.42 Str.294;
let Str.391 : U8 = StructAtIndex 1 Str.293; let Str.394 : U8 = StructAtIndex 1 Str.295;
let Str.392 : U8 = 0i64; let Str.395 : U8 = 0i64;
let Str.388 : Int1 = CallByName Bool.9 Str.391 Str.392; let Str.391 : Int1 = CallByName Bool.9 Str.394 Str.395;
if Str.388 then if Str.391 then
let Str.390 : I64 = StructAtIndex 0 Str.293; let Str.393 : I64 = StructAtIndex 0 Str.295;
let Str.389 : [C Int1, C I64] = TagId(1) Str.390; let Str.392 : [C Int1, C I64] = TagId(1) Str.393;
ret Str.389; ret Str.392;
else else
let Str.387 : Int1 = false; let Str.390 : Int1 = false;
let Str.386 : [C Int1, C I64] = TagId(0) Str.387; let Str.389 : [C Int1, C I64] = TagId(0) Str.390;
ret Str.386; ret Str.389;
procedure Test.0 (): procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2; 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; ret Decode.126;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.394 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.397 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.394; ret Str.397;
procedure Str.27 (Str.185): procedure Str.27 (Str.187):
let Str.385 : [C {}, C I64] = CallByName Str.74 Str.185; let Str.388 : [C {}, C I64] = CallByName Str.75 Str.187;
ret Str.385; ret Str.388;
procedure Str.42 (#Attr.2): procedure Str.42 (#Attr.2):
let Str.393 : {I64, U8} = lowlevel StrToNum #Attr.2; let Str.396 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.393; ret Str.396;
procedure Str.74 (Str.292): procedure Str.75 (Str.294):
let Str.293 : {I64, U8} = CallByName Str.42 Str.292; let Str.295 : {I64, U8} = CallByName Str.42 Str.294;
let Str.391 : U8 = StructAtIndex 1 Str.293; let Str.394 : U8 = StructAtIndex 1 Str.295;
let Str.392 : U8 = 0i64; let Str.395 : U8 = 0i64;
let Str.388 : Int1 = CallByName Bool.9 Str.391 Str.392; let Str.391 : Int1 = CallByName Bool.9 Str.394 Str.395;
if Str.388 then if Str.391 then
let Str.390 : I64 = StructAtIndex 0 Str.293; let Str.393 : I64 = StructAtIndex 0 Str.295;
let Str.389 : [C {}, C I64] = TagId(1) Str.390; let Str.392 : [C {}, C I64] = TagId(1) Str.393;
ret Str.389; ret Str.392;
else else
let Str.387 : {} = Struct {}; let Str.390 : {} = Struct {};
let Str.386 : [C {}, C I64] = TagId(0) Str.387; let Str.389 : [C {}, C I64] = TagId(0) Str.390;
ret Str.386; ret Str.389;
procedure Test.103 (): procedure Test.103 ():
let Test.101 : [C Str, C {List U8, I64}] = CallByName Test.19; 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): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Test.1 (Test.5): procedure Test.1 (Test.5):
let Test.16 : [C {}, C U64, C Str] = TagId(0) 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; ret Num.285;
procedure Str.16 (#Attr.2, #Attr.3): procedure Str.16 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrRepeat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386; ret Str.389;
procedure Test.1 (): procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong"; 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; ret Num.285;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386; ret Str.389;
procedure Test.1 (): procedure Test.1 ():
let Test.21 : Str = "lllllllllllllllllllllooooooooooong"; 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; ret Num.284;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Test.0 (): procedure Test.0 ():
let Test.2 : I64 = 1i64; 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; ret Bool.21;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.386 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.386; ret Str.389;
procedure Test.2 (Test.7): procedure Test.2 (Test.7):
let Test.24 : Str = ".trace(\""; 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; ret Num.283;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.387 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.390 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.387; ret Str.390;
procedure Test.11 (Test.29, #Attr.12): procedure Test.11 (Test.29, #Attr.12):
let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #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; let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.21; ret Bool.21;
procedure Str.26 (Str.184): procedure Str.26 (Str.186):
let Str.385 : [C {}, C U64] = CallByName Str.74 Str.184; let Str.388 : [C {}, C U64] = CallByName Str.75 Str.186;
ret Str.385; ret Str.388;
procedure Str.42 (#Attr.2): procedure Str.42 (#Attr.2):
let Str.393 : {U64, U8} = lowlevel StrToNum #Attr.2; let Str.396 : {U64, U8} = lowlevel StrToNum #Attr.2;
ret Str.393; ret Str.396;
procedure Str.74 (Str.292): procedure Str.75 (Str.294):
let Str.293 : {U64, U8} = CallByName Str.42 Str.292; let Str.295 : {U64, U8} = CallByName Str.42 Str.294;
let Str.391 : U8 = StructAtIndex 1 Str.293; let Str.394 : U8 = StructAtIndex 1 Str.295;
let Str.392 : U8 = 0i64; let Str.395 : U8 = 0i64;
let Str.388 : Int1 = CallByName Bool.9 Str.391 Str.392; let Str.391 : Int1 = CallByName Bool.9 Str.394 Str.395;
if Str.388 then if Str.391 then
let Str.390 : U64 = StructAtIndex 0 Str.293; let Str.393 : U64 = StructAtIndex 0 Str.295;
let Str.389 : [C {}, C U64] = TagId(1) Str.390; let Str.392 : [C {}, C U64] = TagId(1) Str.393;
ret Str.389; ret Str.392;
else else
let Str.387 : {} = Struct {}; let Str.390 : {} = Struct {};
let Str.386 : [C {}, C U64] = TagId(0) Str.387; let Str.389 : [C {}, C U64] = TagId(0) Str.390;
ret Str.386; ret Str.389;
procedure Test.1 (Test.2): procedure Test.1 (Test.2):
joinpoint Test.11 Test.3: 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; ret Num.283;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.386 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.389 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.386; ret Str.389;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.387 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.390 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.387; ret Str.390;
procedure Test.20 (Test.58): procedure Test.20 (Test.58):
let Test.295 : Str = CallByName Encode.23 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; ret Num.287;
procedure Str.12 (#Attr.2): procedure Str.12 (#Attr.2):
let Str.389 : List U8 = lowlevel StrToUtf8 #Attr.2; let Str.392 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.389; ret Str.392;
procedure Str.36 (#Attr.2): procedure Str.36 (#Attr.2):
let Str.390 : U64 = lowlevel StrCountUtf8Bytes #Attr.2; let Str.393 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.390; ret Str.393;
procedure Test.20 (Test.58): procedure Test.20 (Test.58):
inc 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; ret Inspect.297;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Test.0 (): procedure Test.0 ():
let Test.4 : {} = Struct {}; 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; ret Inspect.297;
procedure Str.3 (#Attr.2, #Attr.3): procedure Str.3 (#Attr.2, #Attr.3):
let Str.385 : Str = lowlevel StrConcat #Attr.2 #Attr.3; let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.385; ret Str.388;
procedure Test.2 (Test.3): procedure Test.2 (Test.3):
let Test.4 : Str = CallByName Inspect.33 Test.3; let Test.4 : Str = CallByName Inspect.33 Test.3;