language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-27 13:59:08 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

update mono tests

Browse source
This commit is contained in:
shua 2025-01-15 00:15:43 +01:00
parent 414fecd14d
commit 57fec060bb
No known key found for this signature in database
35 changed files with 1739 additions and 1739 deletions
Download patch file Download diff file Expand all files Collapse all files

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

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

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

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

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

@ -104,181 +104,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.445;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.378;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.435;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.398;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.396;
procedure Str.38 (Str.112, Str.113):
let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.273 : U8 = 1i64;
let Str.274 : U8 = GetTagId Str.260;
let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
if Str.275 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
let Str.269 : U64 = CallByName Str.36 Str.112;
let Str.270 : U64 = CallByName Str.36 Str.113;
let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
let Str.267 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
let Str.265 : U64 = CallByName Str.36 Str.113;
let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
ret Str.261;
procedure Str.38 (Str.210, Str.211):
let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.405 : U8 = 1i64;
let Str.406 : U8 = GetTagId Str.392;
let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
if Str.407 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
let Str.401 : U64 = CallByName Str.36 Str.210;
let Str.402 : U64 = CallByName Str.36 Str.211;
let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
let Str.399 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
let Str.397 : U64 = CallByName Str.36 Str.211;
let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
ret Str.393;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
dec Str.210;
let Str.404 : {} = Struct {};
let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
ret Str.403;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.481 : U8 = 1i64;
let Str.482 : U8 = GetTagId Str.473;
let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
if Str.483 then
let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
let Str.193 : Str = StructAtIndex 0 Str.480;
let Str.192 : Str = StructAtIndex 1 Str.480;
let Str.478 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.477 : Str = CallByName Str.20 Str.478;
let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
dec Str.192;
let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
ret Str.474;
else
dec Str.341;
ret Str.91;
dec Str.473;
ret Str.189;
procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.257 : U8 = 1i64;
let Str.258 : U8 = GetTagId Str.251;
let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
if Str.259 then
dec Str.97;
let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
let Str.101 : Str = StructAtIndex 0 Str.256;
let Str.100 : Str = StructAtIndex 1 Str.256;
let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
jump Str.250 Str.253 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.389 : U8 = 1i64;
let Str.390 : U8 = GetTagId Str.383;
let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
if Str.391 then
dec Str.195;
let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
let Str.199 : Str = StructAtIndex 0 Str.388;
let Str.198 : Str = StructAtIndex 1 Str.388;
let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
jump Str.382 Str.385 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.251;
dec Str.99;
let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.255;
dec Str.196;
dec Str.383;
dec Str.197;
let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.387;
in
inc #Derived_gen.7;
inc #Derived_gen.8;
jump Str.250 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
jump Str.382 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.277 : U64 = 0i64;
let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
ret Str.276;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.409 : U64 = 0i64;
let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
ret Str.408;
procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.280 then
let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.284 then
dec Str.127;
dec Str.126;
let Str.285 : [C , C U64] = TagId(1) Str.128;
ret Str.285;
procedure Str.63 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.412 then
let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.416 then
dec Str.224;
dec Str.225;
let Str.417 : [C , C U64] = TagId(1) Str.226;
ret Str.417;
else
let Str.283 : U64 = 1i64;
let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
jump Str.278 Str.126 Str.127 Str.282 Str.129;
let Str.415 : U64 = 1i64;
let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
jump Str.410 Str.224 Str.225 Str.414 Str.227;
else
dec Str.127;
dec Str.126;
let Str.279 : [C , C U64] = TagId(0) ;
ret Str.279;
dec Str.224;
dec Str.225;
let Str.411 : [C , C U64] = TagId(0) ;
ret Str.411;
in
inc #Derived_gen.0;
inc #Derived_gen.1;
inc #Derived_gen.2;
jump Str.278 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
jump Str.410 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
ret Str.152;
procedure Str.66 (Str.250, Str.251):
let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.440 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
let Str.437 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
let Str.418 : Int1 = CallByName Str.68 Str.419;
ret Str.418;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
let Str.423 : U64 = StructAtIndex 0 Str.258;
let Str.424 : Str = StructAtIndex 1 Str.258;
let Str.426 : Str = StructAtIndex 3 Str.258;
let Str.428 : U64 = StructAtIndex 5 Str.258;
let Str.432 : U64 = 1i64;
let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
let Str.431 : U64 = 1i64;
let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
let Str.268 : Int1 = CallByName Str.68 Str.422;
let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.421;
procedure Test.1 ():
let Test.4 : Str = "";

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

@ -100,181 +100,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.315 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.315;
let Str.447 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.447;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.248;
let Str.380 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.380;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.305 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.305;
let Str.437 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.437;
procedure Str.36 (#Attr.2):
let Str.268 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.268;
let Str.400 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.400;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.266 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.266;
let Str.398 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.398;
procedure Str.38 (Str.112, Str.113):
let Str.262 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.275 : U8 = 1i64;
let Str.276 : U8 = GetTagId Str.262;
let Str.277 : Int1 = lowlevel Eq Str.275 Str.276;
if Str.277 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.262;
let Str.271 : U64 = CallByName Str.36 Str.112;
let Str.272 : U64 = CallByName Str.36 Str.113;
let Str.270 : U64 = CallByName Num.20 Str.271 Str.272;
let Str.115 : U64 = CallByName Num.20 Str.270 Str.114;
let Str.269 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.269 Str.114;
let Str.267 : U64 = CallByName Str.36 Str.113;
let Str.265 : U64 = CallByName Num.51 Str.114 Str.267;
let Str.117 : Str = CallByName Str.37 Str.112 Str.265 Str.115;
let Str.264 : {Str, Str} = Struct {Str.117, Str.116};
let Str.263 : [C {}, C {Str, Str}] = TagId(1) Str.264;
ret Str.263;
procedure Str.38 (Str.210, Str.211):
let Str.394 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.407 : U8 = 1i64;
let Str.408 : U8 = GetTagId Str.394;
let Str.409 : Int1 = lowlevel Eq Str.407 Str.408;
if Str.409 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.394;
let Str.403 : U64 = CallByName Str.36 Str.210;
let Str.404 : U64 = CallByName Str.36 Str.211;
let Str.402 : U64 = CallByName Num.20 Str.403 Str.404;
let Str.213 : U64 = CallByName Num.20 Str.402 Str.212;
let Str.401 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.401 Str.212;
let Str.399 : U64 = CallByName Str.36 Str.211;
let Str.397 : U64 = CallByName Num.51 Str.212 Str.399;
let Str.215 : Str = CallByName Str.37 Str.210 Str.397 Str.213;
let Str.396 : {Str, Str} = Struct {Str.215, Str.214};
let Str.395 : [C {}, C {Str, Str}] = TagId(1) Str.396;
ret Str.395;
else
dec Str.112;
let Str.274 : {} = Struct {};
let Str.273 : [C {}, C {Str, Str}] = TagId(0) Str.274;
ret Str.273;
dec Str.210;
let Str.406 : {} = Struct {};
let Str.405 : [C {}, C {Str, Str}] = TagId(0) Str.406;
ret Str.405;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.343 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.351 : U8 = 1i64;
let Str.352 : U8 = GetTagId Str.343;
let Str.353 : Int1 = lowlevel Eq Str.351 Str.352;
if Str.353 then
let Str.350 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.343;
let Str.95 : Str = StructAtIndex 0 Str.350;
let Str.94 : Str = StructAtIndex 1 Str.350;
let Str.348 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.347 : Str = CallByName Str.20 Str.348;
let Str.346 : Str = CallByName Str.3 Str.347 Str.94;
dec Str.94;
let Str.345 : Str = CallByName Str.3 Str.346 Str.93;
let Str.344 : Str = CallByName Str.56 Str.345 Str.95 Str.92 Str.93;
ret Str.344;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.475 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.483 : U8 = 1i64;
let Str.484 : U8 = GetTagId Str.475;
let Str.485 : Int1 = lowlevel Eq Str.483 Str.484;
if Str.485 then
let Str.482 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.475;
let Str.193 : Str = StructAtIndex 0 Str.482;
let Str.192 : Str = StructAtIndex 1 Str.482;
let Str.480 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.479 : Str = CallByName Str.20 Str.480;
let Str.478 : Str = CallByName Str.3 Str.479 Str.192;
dec Str.192;
let Str.477 : Str = CallByName Str.3 Str.478 Str.191;
let Str.476 : Str = CallByName Str.61 Str.477 Str.193 Str.190 Str.191;
ret Str.476;
else
dec Str.343;
ret Str.91;
dec Str.475;
ret Str.189;
procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
joinpoint Str.252 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.253 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.259 : U8 = 1i64;
let Str.260 : U8 = GetTagId Str.253;
let Str.261 : Int1 = lowlevel Eq Str.259 Str.260;
if Str.261 then
dec Str.97;
let Str.258 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.253;
let Str.101 : Str = StructAtIndex 0 Str.258;
let Str.100 : Str = StructAtIndex 1 Str.258;
let Str.256 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.255 : Str = CallByName Str.3 Str.256 Str.99;
jump Str.252 Str.255 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
joinpoint Str.384 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.391 : U8 = 1i64;
let Str.392 : U8 = GetTagId Str.385;
let Str.393 : Int1 = lowlevel Eq Str.391 Str.392;
if Str.393 then
dec Str.195;
let Str.390 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385;
let Str.199 : Str = StructAtIndex 0 Str.390;
let Str.198 : Str = StructAtIndex 1 Str.390;
let Str.388 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.387 : Str = CallByName Str.3 Str.388 Str.197;
jump Str.384 Str.387 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.99;
dec Str.253;
let Str.257 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.257;
dec Str.385;
dec Str.196;
dec Str.197;
let Str.389 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.389;
in
inc #Derived_gen.7;
inc #Derived_gen.8;
jump Str.252 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.279 : U64 = 0i64;
let Str.278 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.279 Str.125;
ret Str.278;
procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
joinpoint Str.280 Str.126 Str.127 Str.128 Str.129:
let Str.282 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.282 then
let Str.286 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.286 then
dec Str.127;
dec Str.126;
let Str.287 : [C , C U64] = TagId(1) Str.128;
ret Str.287;
else
let Str.285 : U64 = 1i64;
let Str.284 : U64 = CallByName Num.51 Str.128 Str.285;
jump Str.280 Str.126 Str.127 Str.284 Str.129;
else
dec Str.127;
dec Str.126;
let Str.281 : [C , C U64] = TagId(0) ;
ret Str.281;
in
inc #Derived_gen.1;
inc #Derived_gen.3;
inc #Derived_gen.2;
jump Str.280 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
jump Str.384 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
procedure Str.61 (Str.152, Str.153):
let Str.310 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.310 then
ret Str.152;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.411 : U64 = 0i64;
let Str.410 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.411 Str.223;
ret Str.410;
procedure Str.63 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
joinpoint Str.412 Str.224 Str.225 Str.226 Str.227:
let Str.414 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.414 then
let Str.418 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.418 then
dec Str.224;
dec Str.225;
let Str.419 : [C , C U64] = TagId(1) Str.226;
ret Str.419;
else
let Str.417 : U64 = 1i64;
let Str.416 : U64 = CallByName Num.51 Str.226 Str.417;
jump Str.412 Str.224 Str.225 Str.416 Str.227;
else
dec Str.224;
dec Str.225;
let Str.413 : [C , C U64] = TagId(0) ;
ret Str.413;
in
inc #Derived_gen.5;
inc #Derived_gen.4;
jump Str.412 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
procedure Str.66 (Str.250, Str.251):
let Str.442 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.442 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.308 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.308 Str.157;
let Str.307 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.289 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.307, Str.158};
let Str.288 : Int1 = CallByName Str.63 Str.289;
ret Str.288;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.440 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.440 Str.255;
let Str.439 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.421 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.439, Str.256};
let Str.420 : Int1 = CallByName Str.68 Str.421;
ret Str.420;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.303 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.304 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.303 Str.304;
let Str.293 : U64 = StructAtIndex 0 Str.160;
let Str.294 : Str = StructAtIndex 1 Str.160;
let Str.296 : Str = StructAtIndex 3 Str.160;
let Str.298 : U64 = StructAtIndex 5 Str.160;
let Str.302 : U64 = 1i64;
let Str.300 : U64 = CallByName Num.51 Str.164 Str.302;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.162 Str.301;
let Str.292 : {U64, Str, U64, Str, U64, U64} = Struct {Str.293, Str.294, Str.299, Str.296, Str.300, Str.298};
let Str.170 : Int1 = CallByName Str.63 Str.292;
let Str.291 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.291;
let Str.435 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.436 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.435 Str.436;
let Str.425 : U64 = StructAtIndex 0 Str.258;
let Str.426 : Str = StructAtIndex 1 Str.258;
let Str.428 : Str = StructAtIndex 3 Str.258;
let Str.430 : U64 = StructAtIndex 5 Str.258;
let Str.434 : U64 = 1i64;
let Str.432 : U64 = CallByName Num.51 Str.262 Str.434;
let Str.433 : U64 = 1i64;
let Str.431 : U64 = CallByName Num.51 Str.260 Str.433;
let Str.424 : {U64, Str, U64, Str, U64, U64} = Struct {Str.425, Str.426, Str.431, Str.428, Str.432, Str.430};
let Str.268 : Int1 = CallByName Str.68 Str.424;
let Str.423 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.423;
procedure Test.0 ():
let Test.5 : Str = "Hello ";

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

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

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

@ -100,181 +100,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.445;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.378;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.435;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.398;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.396;
procedure Str.38 (Str.112, Str.113):
let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.273 : U8 = 1i64;
let Str.274 : U8 = GetTagId Str.260;
let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
if Str.275 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
let Str.269 : U64 = CallByName Str.36 Str.112;
let Str.270 : U64 = CallByName Str.36 Str.113;
let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
let Str.267 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
let Str.265 : U64 = CallByName Str.36 Str.113;
let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
ret Str.261;
procedure Str.38 (Str.210, Str.211):
let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.405 : U8 = 1i64;
let Str.406 : U8 = GetTagId Str.392;
let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
if Str.407 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
let Str.401 : U64 = CallByName Str.36 Str.210;
let Str.402 : U64 = CallByName Str.36 Str.211;
let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
let Str.399 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
let Str.397 : U64 = CallByName Str.36 Str.211;
let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
ret Str.393;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
dec Str.210;
let Str.404 : {} = Struct {};
let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
ret Str.403;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.481 : U8 = 1i64;
let Str.482 : U8 = GetTagId Str.473;
let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
if Str.483 then
let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
let Str.193 : Str = StructAtIndex 0 Str.480;
let Str.192 : Str = StructAtIndex 1 Str.480;
let Str.478 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.477 : Str = CallByName Str.20 Str.478;
let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
dec Str.192;
let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
ret Str.474;
else
dec Str.341;
ret Str.91;
dec Str.473;
ret Str.189;
procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.257 : U8 = 1i64;
let Str.258 : U8 = GetTagId Str.251;
let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
if Str.259 then
dec Str.97;
let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
let Str.101 : Str = StructAtIndex 0 Str.256;
let Str.100 : Str = StructAtIndex 1 Str.256;
let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
jump Str.250 Str.253 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.389 : U8 = 1i64;
let Str.390 : U8 = GetTagId Str.383;
let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
if Str.391 then
dec Str.195;
let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
let Str.199 : Str = StructAtIndex 0 Str.388;
let Str.198 : Str = StructAtIndex 1 Str.388;
let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
jump Str.382 Str.385 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.251;
dec Str.99;
let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.255;
dec Str.196;
dec Str.383;
dec Str.197;
let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.387;
in
inc #Derived_gen.7;
inc #Derived_gen.8;
jump Str.250 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.277 : U64 = 0i64;
let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
ret Str.276;
procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.280 then
let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.284 then
dec Str.127;
dec Str.126;
let Str.285 : [C , C U64] = TagId(1) Str.128;
ret Str.285;
else
let Str.283 : U64 = 1i64;
let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
jump Str.278 Str.126 Str.127 Str.282 Str.129;
else
dec Str.127;
dec Str.126;
let Str.279 : [C , C U64] = TagId(0) ;
ret Str.279;
in
inc #Derived_gen.1;
inc #Derived_gen.3;
inc #Derived_gen.2;
jump Str.278 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
jump Str.382 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
ret Str.152;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.409 : U64 = 0i64;
let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
ret Str.408;
procedure Str.63 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.412 then
let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.416 then
dec Str.224;
dec Str.225;
let Str.417 : [C , C U64] = TagId(1) Str.226;
ret Str.417;
else
let Str.415 : U64 = 1i64;
let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
jump Str.410 Str.224 Str.225 Str.414 Str.227;
else
dec Str.224;
dec Str.225;
let Str.411 : [C , C U64] = TagId(0) ;
ret Str.411;
in
inc #Derived_gen.5;
inc #Derived_gen.4;
jump Str.410 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
procedure Str.66 (Str.250, Str.251):
let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.440 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
let Str.437 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
let Str.418 : Int1 = CallByName Str.68 Str.419;
ret Str.418;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
let Str.423 : U64 = StructAtIndex 0 Str.258;
let Str.424 : Str = StructAtIndex 1 Str.258;
let Str.426 : Str = StructAtIndex 3 Str.258;
let Str.428 : U64 = StructAtIndex 5 Str.258;
let Str.432 : U64 = 1i64;
let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
let Str.431 : U64 = 1i64;
let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
let Str.268 : Int1 = CallByName Str.68 Str.422;
let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.421;
procedure Test.0 ():
let Test.3 : Str = "";

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

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

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

@ -164,32 +164,32 @@ procedure Num.96 (#Attr.2):
ret Num.287;
procedure Str.12 (#Attr.2):
let Str.259 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.259;
let Str.391 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.391;
procedure Str.36 (#Attr.2):
let Str.260 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.260;
let Str.392 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.392;
procedure Str.43 (#Attr.2):
let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.254;
let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.386;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.251 : Int1 = StructAtIndex 2 Str.74;
if Str.251 then
let Str.253 : Str = StructAtIndex 1 Str.74;
let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
ret Str.252;
procedure Str.9 (Str.76):
let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
let Str.383 : Int1 = StructAtIndex 2 Str.77;
if Str.383 then
let Str.385 : Str = StructAtIndex 1 Str.77;
let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
ret Str.384;
else
let Str.249 : U64 = StructAtIndex 0 Str.74;
let Str.250 : U8 = StructAtIndex 3 Str.74;
let #Derived_gen.45 : Str = StructAtIndex 1 Str.74;
let Str.381 : U64 = StructAtIndex 0 Str.77;
let Str.382 : U8 = StructAtIndex 3 Str.77;
let #Derived_gen.45 : Str = StructAtIndex 1 Str.77;
dec #Derived_gen.45;
let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
ret Str.246;
let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
ret Str.378;
procedure Test.20 (Test.56):
let Test.325 : Str = CallByName Encode.23 Test.56;

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

@ -105,32 +105,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.256;
let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.388;
procedure Str.36 (#Attr.2):
let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.257;
let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.389;
procedure Str.43 (#Attr.2):
let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.254;
let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.386;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.251 : Int1 = StructAtIndex 2 Str.74;
if Str.251 then
let Str.253 : Str = StructAtIndex 1 Str.74;
let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
ret Str.252;
procedure Str.9 (Str.76):
let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
let Str.383 : Int1 = StructAtIndex 2 Str.77;
if Str.383 then
let Str.385 : Str = StructAtIndex 1 Str.77;
let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
ret Str.384;
else
let Str.249 : U64 = StructAtIndex 0 Str.74;
let Str.250 : U8 = StructAtIndex 3 Str.74;
let #Derived_gen.24 : Str = StructAtIndex 1 Str.74;
let Str.381 : U64 = StructAtIndex 0 Str.77;
let Str.382 : U8 = StructAtIndex 3 Str.77;
let #Derived_gen.24 : Str = StructAtIndex 1 Str.77;
dec #Derived_gen.24;
let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
ret Str.246;
let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
ret Str.378;
procedure Test.20 (Test.56):
let Test.292 : Str = CallByName Encode.23 Test.56;

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

@ -112,32 +112,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.256;
let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.388;
procedure Str.36 (#Attr.2):
let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.257;
let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.389;
procedure Str.43 (#Attr.2):
let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.254;
let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.386;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.251 : Int1 = StructAtIndex 2 Str.74;
if Str.251 then
let Str.253 : Str = StructAtIndex 1 Str.74;
let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
ret Str.252;
procedure Str.9 (Str.76):
let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
let Str.383 : Int1 = StructAtIndex 2 Str.77;
if Str.383 then
let Str.385 : Str = StructAtIndex 1 Str.77;
let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
ret Str.384;
else
let Str.249 : U64 = StructAtIndex 0 Str.74;
let Str.250 : U8 = StructAtIndex 3 Str.74;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.74;
let Str.381 : U64 = StructAtIndex 0 Str.77;
let Str.382 : U8 = StructAtIndex 3 Str.77;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.77;
dec #Derived_gen.28;
let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
ret Str.246;
let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
ret Str.378;
procedure Test.20 (Test.56):
let Test.296 : Str = CallByName Encode.23 Test.56;

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

@ -38,32 +38,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.256;
let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.388;
procedure Str.36 (#Attr.2):
let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.257;
let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.389;
procedure Str.43 (#Attr.2):
let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.254;
let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.386;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.251 : Int1 = StructAtIndex 2 Str.74;
if Str.251 then
let Str.253 : Str = StructAtIndex 1 Str.74;
let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
ret Str.252;
procedure Str.9 (Str.76):
let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
let Str.383 : Int1 = StructAtIndex 2 Str.77;
if Str.383 then
let Str.385 : Str = StructAtIndex 1 Str.77;
let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
ret Str.384;
else
let Str.249 : U64 = StructAtIndex 0 Str.74;
let Str.250 : U8 = StructAtIndex 3 Str.74;
let #Derived_gen.3 : Str = StructAtIndex 1 Str.74;
let Str.381 : U64 = StructAtIndex 0 Str.77;
let Str.382 : U8 = StructAtIndex 3 Str.77;
let #Derived_gen.3 : Str = StructAtIndex 1 Str.77;
dec #Derived_gen.3;
let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
ret Str.246;
let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
ret Str.378;
procedure Test.20 (Test.56):
let Test.259 : Str = CallByName Encode.23 Test.56;

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

@ -110,32 +110,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.256;
let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.388;
procedure Str.36 (#Attr.2):
let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.257;
let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.389;
procedure Str.43 (#Attr.2):
let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.254;
let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.386;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.251 : Int1 = StructAtIndex 2 Str.74;
if Str.251 then
let Str.253 : Str = StructAtIndex 1 Str.74;
let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
ret Str.252;
procedure Str.9 (Str.76):
let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
let Str.383 : Int1 = StructAtIndex 2 Str.77;
if Str.383 then
let Str.385 : Str = StructAtIndex 1 Str.77;
let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
ret Str.384;
else
let Str.249 : U64 = StructAtIndex 0 Str.74;
let Str.250 : U8 = StructAtIndex 3 Str.74;
let #Derived_gen.27 : Str = StructAtIndex 1 Str.74;
let Str.381 : U64 = StructAtIndex 0 Str.77;
let Str.382 : U8 = StructAtIndex 3 Str.77;
let #Derived_gen.27 : Str = StructAtIndex 1 Str.77;
dec #Derived_gen.27;
let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
ret Str.246;
let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
ret Str.378;
procedure Test.20 (Test.56):
let Test.297 : Str = CallByName Encode.23 Test.56;

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

@ -113,32 +113,32 @@ procedure Num.96 (#Attr.2):
ret Num.283;
procedure Str.12 (#Attr.2):
let Str.256 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.256;
let Str.388 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.388;
procedure Str.36 (#Attr.2):
let Str.257 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.257;
let Str.389 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.389;
procedure Str.43 (#Attr.2):
let Str.254 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.254;
let Str.386 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
ret Str.386;
procedure Str.9 (Str.73):
let Str.74 : {U64, Str, Int1, U8} = CallByName Str.43 Str.73;
let Str.251 : Int1 = StructAtIndex 2 Str.74;
if Str.251 then
let Str.253 : Str = StructAtIndex 1 Str.74;
let Str.252 : [C {U64, U8}, C Str] = TagId(1) Str.253;
ret Str.252;
procedure Str.9 (Str.76):
let Str.77 : {U64, Str, Int1, U8} = CallByName Str.43 Str.76;
let Str.383 : Int1 = StructAtIndex 2 Str.77;
if Str.383 then
let Str.385 : Str = StructAtIndex 1 Str.77;
let Str.384 : [C {U64, U8}, C Str] = TagId(1) Str.385;
ret Str.384;
else
let Str.249 : U64 = StructAtIndex 0 Str.74;
let Str.250 : U8 = StructAtIndex 3 Str.74;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.74;
let Str.381 : U64 = StructAtIndex 0 Str.77;
let Str.382 : U8 = StructAtIndex 3 Str.77;
let #Derived_gen.28 : Str = StructAtIndex 1 Str.77;
dec #Derived_gen.28;
let Str.248 : {U64, U8} = Struct {Str.249, Str.250};
let Str.246 : [C {U64, U8}, C Str] = TagId(0) Str.248;
ret Str.246;
let Str.380 : {U64, U8} = Struct {Str.381, Str.382};
let Str.378 : [C {U64, U8}, C Str] = TagId(0) Str.380;
ret Str.378;
procedure Test.20 (Test.56):
let Test.301 : Str = CallByName Encode.23 Test.56;

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

@ -153,7 +153,7 @@ procedure Dict.43 (Dict.126):
let Dict.1102 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Inspect.30 Dict.126;
ret Dict.1102;
procedure Dict.45 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47):
procedure Dict.45 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_gen.48):
joinpoint Dict.745 Dict.228 Dict.229 Dict.230 Dict.231 Dict.232 Dict.233 Dict.234 Dict.235 Dict.236:
let Dict.237 : {U32, U32} = CallByName Dict.22 Dict.228 Dict.230;
let Dict.792 : U32 = StructAtIndex 1 Dict.237;
@ -196,8 +196,8 @@ procedure Dict.45 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_g
let Dict.246 : U32 = CallByName Dict.55 Dict.231;
jump Dict.745 Dict.228 Dict.229 Dict.245 Dict.246 Dict.232 Dict.233 Dict.234 Dict.235 Dict.236;
in
inc #Derived_gen.43;
jump Dict.745 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47;
inc #Derived_gen.44;
jump Dict.745 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48;
procedure Dict.48 ():
let Dict.869 : U32 = 0i64;
@ -312,7 +312,7 @@ procedure Dict.72 (Dict.413, Dict.414, Dict.415):
let Dict.855 : {U64, U32} = CallByName Dict.73 Dict.413 Dict.418 Dict.417;
ret Dict.855;
procedure Dict.73 (#Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
procedure Dict.73 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
joinpoint Dict.856 Dict.419 Dict.420 Dict.421:
let Dict.422 : {U32, U32} = CallByName Dict.22 Dict.419 Dict.420;
let Dict.863 : U32 = StructAtIndex 1 Dict.422;
@ -327,10 +327,10 @@ procedure Dict.73 (#Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
let Dict.857 : {U64, U32} = Struct {Dict.420, Dict.421};
ret Dict.857;
in
inc #Derived_gen.15;
jump Dict.856 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
inc #Derived_gen.19;
jump Dict.856 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
procedure Dict.74 (#Derived_gen.48, #Derived_gen.49, #Derived_gen.50):
procedure Dict.74 (#Derived_gen.49, #Derived_gen.50, #Derived_gen.51):
joinpoint Dict.762 Dict.423 Dict.424 Dict.425:
let Dict.426 : {U32, U32} = CallByName Dict.22 Dict.423 Dict.425;
let Dict.772 : U32 = StructAtIndex 1 Dict.426;
@ -349,7 +349,7 @@ procedure Dict.74 (#Derived_gen.48, #Derived_gen.49, #Derived_gen.50):
let Dict.763 : List {U32, U32} = CallByName List.3 Dict.423 Dict.425 Dict.424;
ret Dict.763;
in
jump Dict.762 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50;
jump Dict.762 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51;
procedure Dict.75 (Dict.428, Dict.429):
let Dict.758 : U64 = 1i64;
@ -529,7 +529,7 @@ procedure Dict.89 (Dict.711, Dict.489):
let Dict.926 : {U64, U64, U64} = CallByName Dict.90 Dict.487 Dict.487 Dict.487 Dict.489 Dict.928 Dict.490;
jump Dict.927 Dict.926;
procedure Dict.90 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
procedure Dict.90 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13):
joinpoint Dict.929 Dict.495 Dict.496 Dict.497 Dict.498 Dict.499 Dict.500:
let Dict.1036 : U64 = CallByName Dict.98 Dict.498 Dict.499;
let Dict.1037 : U64 = CallByName Dict.93;
@ -591,8 +591,8 @@ procedure Dict.90 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.
let Dict.930 : {U64, U64, U64} = Struct {Dict.931, Dict.932, Dict.507};
ret Dict.930;
in
inc #Derived_gen.7;
jump Dict.929 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
inc #Derived_gen.11;
jump Dict.929 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13;
procedure Dict.91 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
joinpoint Dict.982 Dict.508 Dict.509 Dict.510 Dict.511:
@ -902,7 +902,7 @@ procedure Inspect.63 (Inspect.295, Inspect.291):
procedure Inspect.64 (Inspect.297):
ret Inspect.297;
procedure List.101 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
procedure List.101 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
joinpoint List.678 List.175 List.176 List.177 List.178 List.179:
let List.680 : Int1 = CallByName Num.22 List.178 List.179;
if List.680 then
@ -916,10 +916,10 @@ procedure List.101 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_
dec List.175;
ret List.176;
in
inc #Derived_gen.10;
jump List.678 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
inc #Derived_gen.14;
jump List.678 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
procedure List.101 (#Derived_gen.51, #Derived_gen.52, #Derived_gen.53, #Derived_gen.54, #Derived_gen.55):
procedure List.101 (#Derived_gen.52, #Derived_gen.53, #Derived_gen.54, #Derived_gen.55, #Derived_gen.56):
joinpoint List.742 List.175 List.176 List.177 List.178 List.179:
let List.744 : Int1 = CallByName Num.22 List.178 List.179;
if List.744 then
@ -933,10 +933,10 @@ procedure List.101 (#Derived_gen.51, #Derived_gen.52, #Derived_gen.53, #Derived_
dec List.175;
ret List.176;
in
inc #Derived_gen.51;
jump List.742 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54 #Derived_gen.55;
inc #Derived_gen.52;
jump List.742 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54 #Derived_gen.55 #Derived_gen.56;
procedure List.102 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
procedure List.102 (#Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31):
joinpoint List.717 List.184 List.185 List.186 List.187 List.188:
let List.719 : Int1 = CallByName Num.22 List.187 List.188;
if List.719 then
@ -950,8 +950,8 @@ procedure List.102 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_
dec List.184;
ret List.185;
in
inc #Derived_gen.23;
jump List.717 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
inc #Derived_gen.27;
jump List.717 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31;
procedure List.11 (List.150, List.151):
let List.737 : List {U32, U32} = CallByName List.68 List.151;
@ -1054,7 +1054,7 @@ procedure List.83 (List.181, List.182, List.183):
let List.714 : List {U32, U32} = CallByName List.102 List.181 List.182 List.183 List.715 List.716;
ret List.714;
procedure List.99 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
procedure List.99 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
joinpoint List.726 List.152 List.153 List.154:
let List.734 : U64 = 0i64;
let List.728 : Int1 = CallByName Num.24 List.153 List.734;
@ -1066,7 +1066,7 @@ procedure List.99 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
else
ret List.154;
in
jump List.726 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
jump List.726 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
procedure Num.131 (#Attr.2):
let Num.291 : U32 = lowlevel NumIntCast #Attr.2;
@ -1208,185 +1208,185 @@ procedure Num.96 (#Attr.2):
ret Num.440;
procedure Str.12 (#Attr.2):
let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.248;
let Str.380 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.380;
procedure Str.20 (#Attr.2):
let Str.316 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.316;
let Str.448 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.448;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
let Str.381 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.381;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.306 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.306;
let Str.438 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.438;
procedure Str.36 (#Attr.2):
let Str.269 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.269;
let Str.401 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.401;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.267 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.267;
let Str.399 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.399;
procedure Str.38 (Str.112, Str.113):
let Str.263 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.276 : U8 = 1i64;
let Str.277 : U8 = GetTagId Str.263;
let Str.278 : Int1 = lowlevel Eq Str.276 Str.277;
if Str.278 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.263;
let Str.272 : U64 = CallByName Str.36 Str.112;
let Str.273 : U64 = CallByName Str.36 Str.113;
let Str.271 : U64 = CallByName Num.20 Str.272 Str.273;
let Str.115 : U64 = CallByName Num.20 Str.271 Str.114;
let Str.270 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.270 Str.114;
let Str.268 : U64 = CallByName Str.36 Str.113;
let Str.266 : U64 = CallByName Num.51 Str.114 Str.268;
let Str.117 : Str = CallByName Str.37 Str.112 Str.266 Str.115;
let Str.265 : {Str, Str} = Struct {Str.117, Str.116};
let Str.264 : [C {}, C {Str, Str}] = TagId(1) Str.265;
ret Str.264;
procedure Str.38 (Str.210, Str.211):
let Str.395 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.408 : U8 = 1i64;
let Str.409 : U8 = GetTagId Str.395;
let Str.410 : Int1 = lowlevel Eq Str.408 Str.409;
if Str.410 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.395;
let Str.404 : U64 = CallByName Str.36 Str.210;
let Str.405 : U64 = CallByName Str.36 Str.211;
let Str.403 : U64 = CallByName Num.20 Str.404 Str.405;
let Str.213 : U64 = CallByName Num.20 Str.403 Str.212;
let Str.402 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.402 Str.212;
let Str.400 : U64 = CallByName Str.36 Str.211;
let Str.398 : U64 = CallByName Num.51 Str.212 Str.400;
let Str.215 : Str = CallByName Str.37 Str.210 Str.398 Str.213;
let Str.397 : {Str, Str} = Struct {Str.215, Str.214};
let Str.396 : [C {}, C {Str, Str}] = TagId(1) Str.397;
ret Str.396;
else
dec Str.112;
let Str.275 : {} = Struct {};
let Str.274 : [C {}, C {Str, Str}] = TagId(0) Str.275;
ret Str.274;
dec Str.210;
let Str.407 : {} = Struct {};
let Str.406 : [C {}, C {Str, Str}] = TagId(0) Str.407;
ret Str.406;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.344 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.352 : U8 = 1i64;
let Str.353 : U8 = GetTagId Str.344;
let Str.354 : Int1 = lowlevel Eq Str.352 Str.353;
if Str.354 then
let Str.351 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.344;
let Str.95 : Str = StructAtIndex 0 Str.351;
let Str.94 : Str = StructAtIndex 1 Str.351;
let Str.349 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.348 : Str = CallByName Str.20 Str.349;
let Str.347 : Str = CallByName Str.3 Str.348 Str.94;
dec Str.94;
let Str.346 : Str = CallByName Str.3 Str.347 Str.93;
let Str.345 : Str = CallByName Str.56 Str.346 Str.95 Str.92 Str.93;
ret Str.345;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.476 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.484 : U8 = 1i64;
let Str.485 : U8 = GetTagId Str.476;
let Str.486 : Int1 = lowlevel Eq Str.484 Str.485;
if Str.486 then
let Str.483 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.476;
let Str.193 : Str = StructAtIndex 0 Str.483;
let Str.192 : Str = StructAtIndex 1 Str.483;
let Str.481 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.480 : Str = CallByName Str.20 Str.481;
let Str.479 : Str = CallByName Str.3 Str.480 Str.192;
dec Str.192;
let Str.478 : Str = CallByName Str.3 Str.479 Str.191;
let Str.477 : Str = CallByName Str.61 Str.478 Str.193 Str.190 Str.191;
ret Str.477;
else
dec Str.344;
ret Str.91;
dec Str.476;
ret Str.189;
procedure Str.56 (#Derived_gen.56, #Derived_gen.57, #Derived_gen.58, #Derived_gen.59):
joinpoint Str.253 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.254 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.260 : U8 = 1i64;
let Str.261 : U8 = GetTagId Str.254;
let Str.262 : Int1 = lowlevel Eq Str.260 Str.261;
if Str.262 then
dec Str.97;
let Str.259 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.254;
let Str.101 : Str = StructAtIndex 0 Str.259;
let Str.100 : Str = StructAtIndex 1 Str.259;
let Str.257 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.256 : Str = CallByName Str.3 Str.257 Str.99;
jump Str.253 Str.256 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.61, #Derived_gen.62, #Derived_gen.63, #Derived_gen.64):
joinpoint Str.385 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.386 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.392 : U8 = 1i64;
let Str.393 : U8 = GetTagId Str.386;
let Str.394 : Int1 = lowlevel Eq Str.392 Str.393;
if Str.394 then
dec Str.195;
let Str.391 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.386;
let Str.199 : Str = StructAtIndex 0 Str.391;
let Str.198 : Str = StructAtIndex 1 Str.391;
let Str.389 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.388 : Str = CallByName Str.3 Str.389 Str.197;
jump Str.385 Str.388 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.99;
dec Str.254;
let Str.258 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.258;
dec Str.386;
dec Str.196;
dec Str.197;
let Str.390 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.390;
in
inc #Derived_gen.58;
inc #Derived_gen.59;
jump Str.253 #Derived_gen.56 #Derived_gen.57 #Derived_gen.58 #Derived_gen.59;
inc #Derived_gen.63;
inc #Derived_gen.64;
jump Str.385 #Derived_gen.61 #Derived_gen.62 #Derived_gen.63 #Derived_gen.64;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.280 : U64 = 0i64;
let Str.279 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.280 Str.125;
ret Str.279;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.412 : U64 = 0i64;
let Str.411 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.412 Str.223;
ret Str.411;
procedure Str.58 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36):
joinpoint Str.281 Str.126 Str.127 Str.128 Str.129:
let Str.283 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.283 then
let Str.287 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.287 then
dec Str.127;
dec Str.126;
let Str.288 : [C , C U64] = TagId(1) Str.128;
ret Str.288;
procedure Str.63 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
joinpoint Str.413 Str.224 Str.225 Str.226 Str.227:
let Str.415 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.415 then
let Str.419 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.419 then
dec Str.224;
dec Str.225;
let Str.420 : [C , C U64] = TagId(1) Str.226;
ret Str.420;
else
let Str.286 : U64 = 1i64;
let Str.285 : U64 = CallByName Num.51 Str.128 Str.286;
jump Str.281 Str.126 Str.127 Str.285 Str.129;
let Str.418 : U64 = 1i64;
let Str.417 : U64 = CallByName Num.51 Str.226 Str.418;
jump Str.413 Str.224 Str.225 Str.417 Str.227;
else
dec Str.127;
dec Str.126;
let Str.282 : [C , C U64] = TagId(0) ;
ret Str.282;
dec Str.224;
dec Str.225;
let Str.414 : [C , C U64] = TagId(0) ;
ret Str.414;
in
inc #Derived_gen.34;
inc #Derived_gen.33;
jump Str.281 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
inc #Derived_gen.5;
inc #Derived_gen.4;
jump Str.413 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
procedure Str.61 (Str.152, Str.153):
let Str.311 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.311 then
ret Str.152;
procedure Str.66 (Str.250, Str.251):
let Str.443 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.443 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.309 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.309 Str.157;
let Str.308 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.308, Str.158};
let Str.289 : Int1 = CallByName Str.63 Str.290;
ret Str.289;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.441 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.441 Str.255;
let Str.440 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.440, Str.256};
let Str.421 : Int1 = CallByName Str.68 Str.422;
ret Str.421;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.304 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.305 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.304 Str.305;
let Str.294 : U64 = StructAtIndex 0 Str.160;
let Str.295 : Str = StructAtIndex 1 Str.160;
let Str.297 : Str = StructAtIndex 3 Str.160;
let Str.299 : U64 = StructAtIndex 5 Str.160;
let Str.303 : U64 = 1i64;
let Str.301 : U64 = CallByName Num.51 Str.164 Str.303;
let Str.302 : U64 = 1i64;
let Str.300 : U64 = CallByName Num.51 Str.162 Str.302;
let Str.293 : {U64, Str, U64, Str, U64, U64} = Struct {Str.294, Str.295, Str.300, Str.297, Str.301, Str.299};
let Str.170 : Int1 = CallByName Str.63 Str.293;
let Str.292 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.292;
let Str.436 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.437 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.436 Str.437;
let Str.426 : U64 = StructAtIndex 0 Str.258;
let Str.427 : Str = StructAtIndex 1 Str.258;
let Str.429 : Str = StructAtIndex 3 Str.258;
let Str.431 : U64 = StructAtIndex 5 Str.258;
let Str.435 : U64 = 1i64;
let Str.433 : U64 = CallByName Num.51 Str.262 Str.435;
let Str.434 : U64 = 1i64;
let Str.432 : U64 = CallByName Num.51 Str.260 Str.434;
let Str.425 : {U64, Str, U64, Str, U64, U64} = Struct {Str.426, Str.427, Str.432, Str.429, Str.433, Str.431};
let Str.268 : Int1 = CallByName Str.68 Str.425;
let Str.424 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.424;
procedure Test.0 ():
let Test.8 : Str = "a";

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

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

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

@ -252,7 +252,7 @@ procedure List.101 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_
inc #Derived_gen.20;
jump List.678 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
procedure List.101 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43):
procedure List.101 (#Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_gen.40):
joinpoint List.690 List.175 List.176 List.177 List.178 List.179:
let List.692 : Int1 = CallByName Num.22 List.178 List.179;
if List.692 then
@ -266,8 +266,8 @@ procedure List.101 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_
dec List.175;
ret List.176;
in
inc #Derived_gen.39;
jump List.690 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43;
inc #Derived_gen.36;
jump List.690 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40;
procedure List.18 (List.172, List.173, List.174):
let List.676 : U64 = 0i64;
@ -326,181 +326,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.295;
procedure Str.20 (#Attr.2):
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
let Str.446 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.446;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
let Str.379 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.379;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
let Str.436 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.436;
procedure Str.36 (#Attr.2):
let Str.267 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.267;
let Str.399 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.399;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.265 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.265;
let Str.397 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.397;
procedure Str.38 (Str.112, Str.113):
let Str.261 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.274 : U8 = 1i64;
let Str.275 : U8 = GetTagId Str.261;
let Str.276 : Int1 = lowlevel Eq Str.274 Str.275;
if Str.276 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.261;
let Str.270 : U64 = CallByName Str.36 Str.112;
let Str.271 : U64 = CallByName Str.36 Str.113;
let Str.269 : U64 = CallByName Num.20 Str.270 Str.271;
let Str.115 : U64 = CallByName Num.20 Str.269 Str.114;
let Str.268 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.268 Str.114;
let Str.266 : U64 = CallByName Str.36 Str.113;
let Str.264 : U64 = CallByName Num.51 Str.114 Str.266;
let Str.117 : Str = CallByName Str.37 Str.112 Str.264 Str.115;
let Str.263 : {Str, Str} = Struct {Str.117, Str.116};
let Str.262 : [C {}, C {Str, Str}] = TagId(1) Str.263;
ret Str.262;
procedure Str.38 (Str.210, Str.211):
let Str.393 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.406 : U8 = 1i64;
let Str.407 : U8 = GetTagId Str.393;
let Str.408 : Int1 = lowlevel Eq Str.406 Str.407;
if Str.408 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.393;
let Str.402 : U64 = CallByName Str.36 Str.210;
let Str.403 : U64 = CallByName Str.36 Str.211;
let Str.401 : U64 = CallByName Num.20 Str.402 Str.403;
let Str.213 : U64 = CallByName Num.20 Str.401 Str.212;
let Str.400 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.400 Str.212;
let Str.398 : U64 = CallByName Str.36 Str.211;
let Str.396 : U64 = CallByName Num.51 Str.212 Str.398;
let Str.215 : Str = CallByName Str.37 Str.210 Str.396 Str.213;
let Str.395 : {Str, Str} = Struct {Str.215, Str.214};
let Str.394 : [C {}, C {Str, Str}] = TagId(1) Str.395;
ret Str.394;
else
dec Str.112;
let Str.273 : {} = Struct {};
let Str.272 : [C {}, C {Str, Str}] = TagId(0) Str.273;
ret Str.272;
dec Str.210;
let Str.405 : {} = Struct {};
let Str.404 : [C {}, C {Str, Str}] = TagId(0) Str.405;
ret Str.404;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.342 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.350 : U8 = 1i64;
let Str.351 : U8 = GetTagId Str.342;
let Str.352 : Int1 = lowlevel Eq Str.350 Str.351;
if Str.352 then
let Str.349 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.342;
let Str.95 : Str = StructAtIndex 0 Str.349;
let Str.94 : Str = StructAtIndex 1 Str.349;
let Str.347 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.346 : Str = CallByName Str.20 Str.347;
let Str.345 : Str = CallByName Str.3 Str.346 Str.94;
dec Str.94;
let Str.344 : Str = CallByName Str.3 Str.345 Str.93;
let Str.343 : Str = CallByName Str.56 Str.344 Str.95 Str.92 Str.93;
ret Str.343;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.474 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.482 : U8 = 1i64;
let Str.483 : U8 = GetTagId Str.474;
let Str.484 : Int1 = lowlevel Eq Str.482 Str.483;
if Str.484 then
let Str.481 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.474;
let Str.193 : Str = StructAtIndex 0 Str.481;
let Str.192 : Str = StructAtIndex 1 Str.481;
let Str.479 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.478 : Str = CallByName Str.20 Str.479;
let Str.477 : Str = CallByName Str.3 Str.478 Str.192;
dec Str.192;
let Str.476 : Str = CallByName Str.3 Str.477 Str.191;
let Str.475 : Str = CallByName Str.61 Str.476 Str.193 Str.190 Str.191;
ret Str.475;
else
dec Str.342;
ret Str.91;
dec Str.474;
ret Str.189;
procedure Str.56 (#Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
joinpoint Str.251 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.252 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.258 : U8 = 1i64;
let Str.259 : U8 = GetTagId Str.252;
let Str.260 : Int1 = lowlevel Eq Str.258 Str.259;
if Str.260 then
dec Str.97;
let Str.257 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.252;
let Str.101 : Str = StructAtIndex 0 Str.257;
let Str.100 : Str = StructAtIndex 1 Str.257;
let Str.255 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.254 : Str = CallByName Str.3 Str.255 Str.99;
jump Str.251 Str.254 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44):
joinpoint Str.383 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.384 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.390 : U8 = 1i64;
let Str.391 : U8 = GetTagId Str.384;
let Str.392 : Int1 = lowlevel Eq Str.390 Str.391;
if Str.392 then
dec Str.195;
let Str.389 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.384;
let Str.199 : Str = StructAtIndex 0 Str.389;
let Str.198 : Str = StructAtIndex 1 Str.389;
let Str.387 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.386 : Str = CallByName Str.3 Str.387 Str.197;
jump Str.383 Str.386 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.252;
dec Str.99;
let Str.256 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.256;
dec Str.384;
dec Str.196;
dec Str.197;
let Str.388 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.388;
in
inc #Derived_gen.29;
inc #Derived_gen.30;
jump Str.251 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
inc #Derived_gen.44;
inc #Derived_gen.43;
jump Str.383 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.278 : U64 = 0i64;
let Str.277 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.278 Str.125;
ret Str.277;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.410 : U64 = 0i64;
let Str.409 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.410 Str.223;
ret Str.409;
procedure Str.58 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36):
joinpoint Str.279 Str.126 Str.127 Str.128 Str.129:
let Str.281 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.281 then
let Str.285 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.285 then
dec Str.127;
dec Str.126;
let Str.286 : [C , C U64] = TagId(1) Str.128;
ret Str.286;
procedure Str.63 (#Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28):
joinpoint Str.411 Str.224 Str.225 Str.226 Str.227:
let Str.413 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.413 then
let Str.417 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.417 then
dec Str.224;
dec Str.225;
let Str.418 : [C , C U64] = TagId(1) Str.226;
ret Str.418;
else
let Str.284 : U64 = 1i64;
let Str.283 : U64 = CallByName Num.51 Str.128 Str.284;
jump Str.279 Str.126 Str.127 Str.283 Str.129;
let Str.416 : U64 = 1i64;
let Str.415 : U64 = CallByName Num.51 Str.226 Str.416;
jump Str.411 Str.224 Str.225 Str.415 Str.227;
else
dec Str.127;
dec Str.126;
let Str.280 : [C , C U64] = TagId(0) ;
ret Str.280;
dec Str.224;
dec Str.225;
let Str.412 : [C , C U64] = TagId(0) ;
ret Str.412;
in
inc #Derived_gen.34;
inc #Derived_gen.33;
jump Str.279 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
inc #Derived_gen.25;
inc #Derived_gen.26;
jump Str.411 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
procedure Str.61 (Str.152, Str.153):
let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.309 then
ret Str.152;
procedure Str.66 (Str.250, Str.251):
let Str.441 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.441 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.307 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.307 Str.157;
let Str.306 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.288 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.306, Str.158};
let Str.287 : Int1 = CallByName Str.63 Str.288;
ret Str.287;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.439 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.439 Str.255;
let Str.438 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.420 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.438, Str.256};
let Str.419 : Int1 = CallByName Str.68 Str.420;
ret Str.419;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.302 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.303 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.302 Str.303;
let Str.292 : U64 = StructAtIndex 0 Str.160;
let Str.293 : Str = StructAtIndex 1 Str.160;
let Str.295 : Str = StructAtIndex 3 Str.160;
let Str.297 : U64 = StructAtIndex 5 Str.160;
let Str.301 : U64 = 1i64;
let Str.299 : U64 = CallByName Num.51 Str.164 Str.301;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.162 Str.300;
let Str.291 : {U64, Str, U64, Str, U64, U64} = Struct {Str.292, Str.293, Str.298, Str.295, Str.299, Str.297};
let Str.170 : Int1 = CallByName Str.63 Str.291;
let Str.290 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.290;
let Str.434 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.435 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.434 Str.435;
let Str.424 : U64 = StructAtIndex 0 Str.258;
let Str.425 : Str = StructAtIndex 1 Str.258;
let Str.427 : Str = StructAtIndex 3 Str.258;
let Str.429 : U64 = StructAtIndex 5 Str.258;
let Str.433 : U64 = 1i64;
let Str.431 : U64 = CallByName Num.51 Str.262 Str.433;
let Str.432 : U64 = 1i64;
let Str.430 : U64 = CallByName Num.51 Str.260 Str.432;
let Str.423 : {U64, Str, U64, Str, U64, U64} = Struct {Str.424, Str.425, Str.430, Str.427, Str.431, Str.429};
let Str.268 : Int1 = CallByName Str.68 Str.423;
let Str.422 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.422;
procedure Test.0 ():
let Test.4 : Str = "bar";

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

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

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

@ -220,181 +220,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.445;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.378;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.435;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.398;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.396;
procedure Str.38 (Str.112, Str.113):
let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.273 : U8 = 1i64;
let Str.274 : U8 = GetTagId Str.260;
let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
if Str.275 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
let Str.269 : U64 = CallByName Str.36 Str.112;
let Str.270 : U64 = CallByName Str.36 Str.113;
let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
let Str.267 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
let Str.265 : U64 = CallByName Str.36 Str.113;
let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
ret Str.261;
procedure Str.38 (Str.210, Str.211):
let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.405 : U8 = 1i64;
let Str.406 : U8 = GetTagId Str.392;
let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
if Str.407 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
let Str.401 : U64 = CallByName Str.36 Str.210;
let Str.402 : U64 = CallByName Str.36 Str.211;
let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
let Str.399 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
let Str.397 : U64 = CallByName Str.36 Str.211;
let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
ret Str.393;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
dec Str.210;
let Str.404 : {} = Struct {};
let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
ret Str.403;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.481 : U8 = 1i64;
let Str.482 : U8 = GetTagId Str.473;
let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
if Str.483 then
let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
let Str.193 : Str = StructAtIndex 0 Str.480;
let Str.192 : Str = StructAtIndex 1 Str.480;
let Str.478 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.477 : Str = CallByName Str.20 Str.478;
let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
dec Str.192;
let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
ret Str.474;
else
dec Str.341;
ret Str.91;
dec Str.473;
ret Str.189;
procedure Str.56 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.257 : U8 = 1i64;
let Str.258 : U8 = GetTagId Str.251;
let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
if Str.259 then
dec Str.97;
let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
let Str.101 : Str = StructAtIndex 0 Str.256;
let Str.100 : Str = StructAtIndex 1 Str.256;
let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
jump Str.250 Str.253 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.389 : U8 = 1i64;
let Str.390 : U8 = GetTagId Str.383;
let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
if Str.391 then
dec Str.195;
let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
let Str.199 : Str = StructAtIndex 0 Str.388;
let Str.198 : Str = StructAtIndex 1 Str.388;
let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
jump Str.382 Str.385 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.251;
dec Str.99;
let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.255;
dec Str.196;
dec Str.383;
dec Str.197;
let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.387;
in
inc #Derived_gen.27;
inc #Derived_gen.25;
inc #Derived_gen.26;
jump Str.250 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
jump Str.382 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.277 : U64 = 0i64;
let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
ret Str.276;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.409 : U64 = 0i64;
let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
ret Str.408;
procedure Str.58 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.280 then
let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.284 then
dec Str.127;
dec Str.126;
let Str.285 : [C , C U64] = TagId(1) Str.128;
ret Str.285;
procedure Str.63 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.412 then
let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.416 then
dec Str.224;
dec Str.225;
let Str.417 : [C , C U64] = TagId(1) Str.226;
ret Str.417;
else
let Str.283 : U64 = 1i64;
let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
jump Str.278 Str.126 Str.127 Str.282 Str.129;
let Str.415 : U64 = 1i64;
let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
jump Str.410 Str.224 Str.225 Str.414 Str.227;
else
dec Str.127;
dec Str.126;
let Str.279 : [C , C U64] = TagId(0) ;
ret Str.279;
dec Str.224;
dec Str.225;
let Str.411 : [C , C U64] = TagId(0) ;
ret Str.411;
in
inc #Derived_gen.20;
inc #Derived_gen.21;
jump Str.278 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
inc #Derived_gen.19;
jump Str.410 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
ret Str.152;
procedure Str.66 (Str.250, Str.251):
let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.440 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
let Str.437 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
let Str.418 : Int1 = CallByName Str.68 Str.419;
ret Str.418;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
let Str.423 : U64 = StructAtIndex 0 Str.258;
let Str.424 : Str = StructAtIndex 1 Str.258;
let Str.426 : Str = StructAtIndex 3 Str.258;
let Str.428 : U64 = StructAtIndex 5 Str.258;
let Str.432 : U64 = 1i64;
let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
let Str.431 : U64 = 1i64;
let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
let Str.268 : Int1 = CallByName Str.68 Str.422;
let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.421;
procedure Test.0 ():
let Test.3 : Str = "foo";

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

@ -227,181 +227,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.445;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.378;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.435;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.398;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.396;
procedure Str.38 (Str.112, Str.113):
let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.273 : U8 = 1i64;
let Str.274 : U8 = GetTagId Str.260;
let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
if Str.275 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
let Str.269 : U64 = CallByName Str.36 Str.112;
let Str.270 : U64 = CallByName Str.36 Str.113;
let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
let Str.267 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
let Str.265 : U64 = CallByName Str.36 Str.113;
let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
ret Str.261;
procedure Str.38 (Str.210, Str.211):
let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.405 : U8 = 1i64;
let Str.406 : U8 = GetTagId Str.392;
let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
if Str.407 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
let Str.401 : U64 = CallByName Str.36 Str.210;
let Str.402 : U64 = CallByName Str.36 Str.211;
let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
let Str.399 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
let Str.397 : U64 = CallByName Str.36 Str.211;
let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
ret Str.393;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
dec Str.210;
let Str.404 : {} = Struct {};
let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
ret Str.403;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.393 : U8 = 1i64;
let Str.394 : U8 = GetTagId Str.385;
let Str.395 : Int1 = lowlevel Eq Str.393 Str.394;
if Str.395 then
let Str.392 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385;
let Str.95 : Str = StructAtIndex 0 Str.392;
let Str.94 : Str = StructAtIndex 1 Str.392;
let Str.390 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.389 : Str = CallByName Str.20 Str.390;
let Str.388 : Str = CallByName Str.3 Str.389 Str.94;
dec Str.94;
let Str.387 : Str = CallByName Str.3 Str.388 Str.93;
let Str.386 : Str = CallByName Str.56 Str.387 Str.95 Str.92 Str.93;
ret Str.386;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.517 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.525 : U8 = 1i64;
let Str.526 : U8 = GetTagId Str.517;
let Str.527 : Int1 = lowlevel Eq Str.525 Str.526;
if Str.527 then
let Str.524 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.517;
let Str.193 : Str = StructAtIndex 0 Str.524;
let Str.192 : Str = StructAtIndex 1 Str.524;
let Str.522 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.521 : Str = CallByName Str.20 Str.522;
let Str.520 : Str = CallByName Str.3 Str.521 Str.192;
dec Str.192;
let Str.519 : Str = CallByName Str.3 Str.520 Str.191;
let Str.518 : Str = CallByName Str.61 Str.519 Str.193 Str.190 Str.191;
ret Str.518;
else
dec Str.385;
ret Str.91;
dec Str.517;
ret Str.189;
procedure Str.56 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30, #Derived_gen.31):
joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.257 : U8 = 1i64;
let Str.258 : U8 = GetTagId Str.251;
let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
if Str.259 then
dec Str.97;
let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
let Str.101 : Str = StructAtIndex 0 Str.256;
let Str.100 : Str = StructAtIndex 1 Str.256;
let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
jump Str.250 Str.253 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.389 : U8 = 1i64;
let Str.390 : U8 = GetTagId Str.383;
let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
if Str.391 then
dec Str.195;
let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
let Str.199 : Str = StructAtIndex 0 Str.388;
let Str.198 : Str = StructAtIndex 1 Str.388;
let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
jump Str.382 Str.385 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.251;
dec Str.99;
let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.255;
dec Str.196;
dec Str.383;
dec Str.197;
let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.387;
in
inc #Derived_gen.29;
inc #Derived_gen.30;
inc #Derived_gen.31;
jump Str.250 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31;
jump Str.382 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.277 : U64 = 0i64;
let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
ret Str.276;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.409 : U64 = 0i64;
let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
ret Str.408;
procedure Str.58 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.280 then
let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.284 then
dec Str.127;
dec Str.126;
let Str.285 : [C , C U64] = TagId(1) Str.128;
ret Str.285;
procedure Str.63 (#Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.412 then
let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.416 then
dec Str.224;
dec Str.225;
let Str.417 : [C , C U64] = TagId(1) Str.226;
ret Str.417;
else
let Str.283 : U64 = 1i64;
let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
jump Str.278 Str.126 Str.127 Str.282 Str.129;
let Str.415 : U64 = 1i64;
let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
jump Str.410 Str.224 Str.225 Str.414 Str.227;
else
dec Str.127;
dec Str.126;
let Str.279 : [C , C U64] = TagId(0) ;
ret Str.279;
dec Str.224;
dec Str.225;
let Str.411 : [C , C U64] = TagId(0) ;
ret Str.411;
in
inc #Derived_gen.24;
inc #Derived_gen.25;
jump Str.278 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
inc #Derived_gen.23;
jump Str.410 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
ret Str.152;
procedure Str.66 (Str.250, Str.251):
let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.440 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
let Str.437 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
let Str.418 : Int1 = CallByName Str.68 Str.419;
ret Str.418;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
let Str.423 : U64 = StructAtIndex 0 Str.258;
let Str.424 : Str = StructAtIndex 1 Str.258;
let Str.426 : Str = StructAtIndex 3 Str.258;
let Str.428 : U64 = StructAtIndex 5 Str.258;
let Str.432 : U64 = 1i64;
let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
let Str.431 : U64 = 1i64;
let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
let Str.268 : Int1 = CallByName Str.68 Str.422;
let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.421;
procedure Test.0 ():
let Test.3 : Str = "foo";

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

@ -100,181 +100,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.445;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.378;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.435;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.398;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.396;
procedure Str.38 (Str.112, Str.113):
let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.273 : U8 = 1i64;
let Str.274 : U8 = GetTagId Str.260;
let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
if Str.275 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
let Str.269 : U64 = CallByName Str.36 Str.112;
let Str.270 : U64 = CallByName Str.36 Str.113;
let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
let Str.267 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
let Str.265 : U64 = CallByName Str.36 Str.113;
let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
ret Str.261;
procedure Str.38 (Str.210, Str.211):
let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.405 : U8 = 1i64;
let Str.406 : U8 = GetTagId Str.392;
let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
if Str.407 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
let Str.401 : U64 = CallByName Str.36 Str.210;
let Str.402 : U64 = CallByName Str.36 Str.211;
let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
let Str.399 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
let Str.397 : U64 = CallByName Str.36 Str.211;
let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
ret Str.393;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
dec Str.210;
let Str.404 : {} = Struct {};
let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
ret Str.403;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.481 : U8 = 1i64;
let Str.482 : U8 = GetTagId Str.473;
let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
if Str.483 then
let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
let Str.193 : Str = StructAtIndex 0 Str.480;
let Str.192 : Str = StructAtIndex 1 Str.480;
let Str.478 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.477 : Str = CallByName Str.20 Str.478;
let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
dec Str.192;
let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
ret Str.474;
else
dec Str.341;
ret Str.91;
dec Str.473;
ret Str.189;
procedure Str.56 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.257 : U8 = 1i64;
let Str.258 : U8 = GetTagId Str.251;
let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
if Str.259 then
dec Str.97;
let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
let Str.101 : Str = StructAtIndex 0 Str.256;
let Str.100 : Str = StructAtIndex 1 Str.256;
let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
jump Str.250 Str.253 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.389 : U8 = 1i64;
let Str.390 : U8 = GetTagId Str.383;
let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
if Str.391 then
dec Str.195;
let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
let Str.199 : Str = StructAtIndex 0 Str.388;
let Str.198 : Str = StructAtIndex 1 Str.388;
let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
jump Str.382 Str.385 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.251;
dec Str.99;
let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.255;
dec Str.196;
dec Str.383;
dec Str.197;
let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.387;
in
inc #Derived_gen.7;
inc #Derived_gen.8;
jump Str.250 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.277 : U64 = 0i64;
let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
ret Str.276;
procedure Str.58 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.280 then
let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.284 then
dec Str.127;
dec Str.126;
let Str.285 : [C , C U64] = TagId(1) Str.128;
ret Str.285;
else
let Str.283 : U64 = 1i64;
let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
jump Str.278 Str.126 Str.127 Str.282 Str.129;
else
dec Str.127;
dec Str.126;
let Str.279 : [C , C U64] = TagId(0) ;
ret Str.279;
in
inc #Derived_gen.1;
inc #Derived_gen.3;
inc #Derived_gen.2;
jump Str.278 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
jump Str.382 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
ret Str.152;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.409 : U64 = 0i64;
let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
ret Str.408;
procedure Str.63 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.412 then
let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.416 then
dec Str.224;
dec Str.225;
let Str.417 : [C , C U64] = TagId(1) Str.226;
ret Str.417;
else
let Str.415 : U64 = 1i64;
let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
jump Str.410 Str.224 Str.225 Str.414 Str.227;
else
dec Str.224;
dec Str.225;
let Str.411 : [C , C U64] = TagId(0) ;
ret Str.411;
in
inc #Derived_gen.5;
inc #Derived_gen.4;
jump Str.410 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
procedure Str.66 (Str.250, Str.251):
let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.440 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
let Str.437 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
let Str.418 : Int1 = CallByName Str.68 Str.419;
ret Str.418;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
let Str.423 : U64 = StructAtIndex 0 Str.258;
let Str.424 : Str = StructAtIndex 1 Str.258;
let Str.426 : Str = StructAtIndex 3 Str.258;
let Str.428 : U64 = StructAtIndex 5 Str.258;
let Str.432 : U64 = 1i64;
let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
let Str.431 : U64 = 1i64;
let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
let Str.268 : Int1 = CallByName Str.68 Str.422;
let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.421;
procedure Test.0 ():
let Test.2 : Str = "abc";

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

@ -162,7 +162,7 @@ procedure List.1 (List.119):
let List.687 : Int1 = CallByName Bool.11 List.688 List.689;
ret List.687;
procedure List.101 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
procedure List.101 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
joinpoint List.678 List.175 List.176 List.177 List.178 List.179:
let List.680 : Int1 = CallByName Num.22 List.178 List.179;
if List.680 then
@ -177,8 +177,8 @@ procedure List.101 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_
dec List.175;
ret List.176;
in
inc #Derived_gen.11;
jump List.678 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
inc #Derived_gen.10;
jump List.678 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
procedure List.18 (List.172, List.173, List.174):
let List.676 : U64 = 0i64;
@ -223,181 +223,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.445;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.378;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.435;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.398;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.396;
procedure Str.38 (Str.112, Str.113):
let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.273 : U8 = 1i64;
let Str.274 : U8 = GetTagId Str.260;
let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
if Str.275 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
let Str.269 : U64 = CallByName Str.36 Str.112;
let Str.270 : U64 = CallByName Str.36 Str.113;
let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
let Str.267 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
let Str.265 : U64 = CallByName Str.36 Str.113;
let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
ret Str.261;
procedure Str.38 (Str.210, Str.211):
let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.405 : U8 = 1i64;
let Str.406 : U8 = GetTagId Str.392;
let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
if Str.407 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
let Str.401 : U64 = CallByName Str.36 Str.210;
let Str.402 : U64 = CallByName Str.36 Str.211;
let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
let Str.399 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
let Str.397 : U64 = CallByName Str.36 Str.211;
let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
ret Str.393;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
dec Str.210;
let Str.404 : {} = Struct {};
let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
ret Str.403;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.341 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.349 : U8 = 1i64;
let Str.350 : U8 = GetTagId Str.341;
let Str.351 : Int1 = lowlevel Eq Str.349 Str.350;
if Str.351 then
let Str.348 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.341;
let Str.95 : Str = StructAtIndex 0 Str.348;
let Str.94 : Str = StructAtIndex 1 Str.348;
let Str.346 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.345 : Str = CallByName Str.20 Str.346;
let Str.344 : Str = CallByName Str.3 Str.345 Str.94;
dec Str.94;
let Str.343 : Str = CallByName Str.3 Str.344 Str.93;
let Str.342 : Str = CallByName Str.56 Str.343 Str.95 Str.92 Str.93;
ret Str.342;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.473 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.481 : U8 = 1i64;
let Str.482 : U8 = GetTagId Str.473;
let Str.483 : Int1 = lowlevel Eq Str.481 Str.482;
if Str.483 then
let Str.480 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.473;
let Str.193 : Str = StructAtIndex 0 Str.480;
let Str.192 : Str = StructAtIndex 1 Str.480;
let Str.478 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.477 : Str = CallByName Str.20 Str.478;
let Str.476 : Str = CallByName Str.3 Str.477 Str.192;
dec Str.192;
let Str.475 : Str = CallByName Str.3 Str.476 Str.191;
let Str.474 : Str = CallByName Str.61 Str.475 Str.193 Str.190 Str.191;
ret Str.474;
else
dec Str.341;
ret Str.91;
dec Str.473;
ret Str.189;
procedure Str.56 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27):
joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.257 : U8 = 1i64;
let Str.258 : U8 = GetTagId Str.251;
let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
if Str.259 then
dec Str.97;
let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
let Str.101 : Str = StructAtIndex 0 Str.256;
let Str.100 : Str = StructAtIndex 1 Str.256;
let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
jump Str.250 Str.253 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24):
joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.389 : U8 = 1i64;
let Str.390 : U8 = GetTagId Str.383;
let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
if Str.391 then
dec Str.195;
let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
let Str.199 : Str = StructAtIndex 0 Str.388;
let Str.198 : Str = StructAtIndex 1 Str.388;
let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
jump Str.382 Str.385 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.251;
dec Str.99;
let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.255;
dec Str.196;
dec Str.383;
dec Str.197;
let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.387;
in
inc #Derived_gen.27;
inc #Derived_gen.26;
jump Str.250 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
inc #Derived_gen.23;
inc #Derived_gen.24;
jump Str.382 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.277 : U64 = 0i64;
let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
ret Str.276;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.409 : U64 = 0i64;
let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
ret Str.408;
procedure Str.58 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.280 then
let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.284 then
dec Str.127;
dec Str.126;
let Str.285 : [C , C U64] = TagId(1) Str.128;
ret Str.285;
procedure Str.63 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.412 then
let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.416 then
dec Str.224;
dec Str.225;
let Str.417 : [C , C U64] = TagId(1) Str.226;
ret Str.417;
else
let Str.283 : U64 = 1i64;
let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
jump Str.278 Str.126 Str.127 Str.282 Str.129;
let Str.415 : U64 = 1i64;
let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
jump Str.410 Str.224 Str.225 Str.414 Str.227;
else
dec Str.127;
dec Str.126;
let Str.279 : [C , C U64] = TagId(0) ;
ret Str.279;
dec Str.224;
dec Str.225;
let Str.411 : [C , C U64] = TagId(0) ;
ret Str.411;
in
inc #Derived_gen.17;
inc #Derived_gen.18;
inc #Derived_gen.19;
jump Str.278 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
jump Str.410 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
ret Str.152;
procedure Str.66 (Str.250, Str.251):
let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.440 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
let Str.437 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
let Str.418 : Int1 = CallByName Str.68 Str.419;
ret Str.418;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
let Str.423 : U64 = StructAtIndex 0 Str.258;
let Str.424 : Str = StructAtIndex 1 Str.258;
let Str.426 : Str = StructAtIndex 3 Str.258;
let Str.428 : U64 = StructAtIndex 5 Str.258;
let Str.432 : U64 = 1i64;
let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
let Str.431 : U64 = 1i64;
let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
let Str.268 : Int1 = CallByName Str.68 Str.422;
let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.421;
procedure Test.0 ():
let Test.4 : Str = "foo";

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

@ -226,181 +226,181 @@ procedure Num.77 (#Attr.2, #Attr.3):
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
let Str.445 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.445;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
let Str.378 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.378;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
let Str.435 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.435;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
let Str.398 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.398;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
let Str.396 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.396;
procedure Str.38 (Str.112, Str.113):
let Str.260 : [C , C U64] = CallByName Str.57 Str.112 Str.113;
let Str.273 : U8 = 1i64;
let Str.274 : U8 = GetTagId Str.260;
let Str.275 : Int1 = lowlevel Eq Str.273 Str.274;
if Str.275 then
let Str.114 : U64 = UnionAtIndex (Id 1) (Index 0) Str.260;
let Str.269 : U64 = CallByName Str.36 Str.112;
let Str.270 : U64 = CallByName Str.36 Str.113;
let Str.268 : U64 = CallByName Num.20 Str.269 Str.270;
let Str.115 : U64 = CallByName Num.20 Str.268 Str.114;
let Str.267 : U64 = 0i64;
inc Str.112;
let Str.116 : Str = CallByName Str.37 Str.112 Str.267 Str.114;
let Str.265 : U64 = CallByName Str.36 Str.113;
let Str.263 : U64 = CallByName Num.51 Str.114 Str.265;
let Str.117 : Str = CallByName Str.37 Str.112 Str.263 Str.115;
let Str.262 : {Str, Str} = Struct {Str.117, Str.116};
let Str.261 : [C {}, C {Str, Str}] = TagId(1) Str.262;
ret Str.261;
procedure Str.38 (Str.210, Str.211):
let Str.392 : [C , C U64] = CallByName Str.62 Str.210 Str.211;
let Str.405 : U8 = 1i64;
let Str.406 : U8 = GetTagId Str.392;
let Str.407 : Int1 = lowlevel Eq Str.405 Str.406;
if Str.407 then
let Str.212 : U64 = UnionAtIndex (Id 1) (Index 0) Str.392;
let Str.401 : U64 = CallByName Str.36 Str.210;
let Str.402 : U64 = CallByName Str.36 Str.211;
let Str.400 : U64 = CallByName Num.20 Str.401 Str.402;
let Str.213 : U64 = CallByName Num.20 Str.400 Str.212;
let Str.399 : U64 = 0i64;
inc Str.210;
let Str.214 : Str = CallByName Str.37 Str.210 Str.399 Str.212;
let Str.397 : U64 = CallByName Str.36 Str.211;
let Str.395 : U64 = CallByName Num.51 Str.212 Str.397;
let Str.215 : Str = CallByName Str.37 Str.210 Str.395 Str.213;
let Str.394 : {Str, Str} = Struct {Str.215, Str.214};
let Str.393 : [C {}, C {Str, Str}] = TagId(1) Str.394;
ret Str.393;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
dec Str.210;
let Str.404 : {} = Struct {};
let Str.403 : [C {}, C {Str, Str}] = TagId(0) Str.404;
ret Str.403;
procedure Str.45 (Str.91, Str.92, Str.93):
inc Str.91;
let Str.385 : [C {}, C {Str, Str}] = CallByName Str.38 Str.91 Str.92;
let Str.393 : U8 = 1i64;
let Str.394 : U8 = GetTagId Str.385;
let Str.395 : Int1 = lowlevel Eq Str.393 Str.394;
if Str.395 then
let Str.392 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.385;
let Str.95 : Str = StructAtIndex 0 Str.392;
let Str.94 : Str = StructAtIndex 1 Str.392;
let Str.390 : U64 = CallByName Str.36 Str.91;
dec Str.91;
let Str.389 : Str = CallByName Str.20 Str.390;
let Str.388 : Str = CallByName Str.3 Str.389 Str.94;
dec Str.94;
let Str.387 : Str = CallByName Str.3 Str.388 Str.93;
let Str.386 : Str = CallByName Str.56 Str.387 Str.95 Str.92 Str.93;
ret Str.386;
procedure Str.45 (Str.189, Str.190, Str.191):
inc Str.189;
let Str.517 : [C {}, C {Str, Str}] = CallByName Str.38 Str.189 Str.190;
let Str.525 : U8 = 1i64;
let Str.526 : U8 = GetTagId Str.517;
let Str.527 : Int1 = lowlevel Eq Str.525 Str.526;
if Str.527 then
let Str.524 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.517;
let Str.193 : Str = StructAtIndex 0 Str.524;
let Str.192 : Str = StructAtIndex 1 Str.524;
let Str.522 : U64 = CallByName Str.36 Str.189;
dec Str.189;
let Str.521 : Str = CallByName Str.20 Str.522;
let Str.520 : Str = CallByName Str.3 Str.521 Str.192;
dec Str.192;
let Str.519 : Str = CallByName Str.3 Str.520 Str.191;
let Str.518 : Str = CallByName Str.61 Str.519 Str.193 Str.190 Str.191;
ret Str.518;
else
dec Str.385;
ret Str.91;
dec Str.517;
ret Str.189;
procedure Str.56 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
inc Str.97;
let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
let Str.257 : U8 = 1i64;
let Str.258 : U8 = GetTagId Str.251;
let Str.259 : Int1 = lowlevel Eq Str.257 Str.258;
if Str.259 then
dec Str.97;
let Str.256 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.251;
let Str.101 : Str = StructAtIndex 0 Str.256;
let Str.100 : Str = StructAtIndex 1 Str.256;
let Str.254 : Str = CallByName Str.3 Str.96 Str.100;
dec Str.100;
let Str.253 : Str = CallByName Str.3 Str.254 Str.99;
jump Str.250 Str.253 Str.101 Str.98 Str.99;
procedure Str.61 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
joinpoint Str.382 Str.194 Str.195 Str.196 Str.197:
inc Str.195;
let Str.383 : [C {}, C {Str, Str}] = CallByName Str.38 Str.195 Str.196;
let Str.389 : U8 = 1i64;
let Str.390 : U8 = GetTagId Str.383;
let Str.391 : Int1 = lowlevel Eq Str.389 Str.390;
if Str.391 then
dec Str.195;
let Str.388 : {Str, Str} = UnionAtIndex (Id 1) (Index 0) Str.383;
let Str.199 : Str = StructAtIndex 0 Str.388;
let Str.198 : Str = StructAtIndex 1 Str.388;
let Str.386 : Str = CallByName Str.3 Str.194 Str.198;
dec Str.198;
let Str.385 : Str = CallByName Str.3 Str.386 Str.197;
jump Str.382 Str.385 Str.199 Str.196 Str.197;
else
dec Str.98;
dec Str.251;
dec Str.99;
let Str.255 : Str = CallByName Str.3 Str.96 Str.97;
dec Str.97;
ret Str.255;
dec Str.196;
dec Str.383;
dec Str.197;
let Str.387 : Str = CallByName Str.3 Str.194 Str.195;
dec Str.195;
ret Str.387;
in
inc #Derived_gen.23;
inc #Derived_gen.22;
jump Str.250 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
inc #Derived_gen.16;
inc #Derived_gen.17;
jump Str.382 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
procedure Str.57 (Str.121, Str.122):
let Str.123 : U64 = CallByName Str.36 Str.121;
let Str.124 : U64 = CallByName Str.36 Str.122;
let Str.125 : U64 = CallByName Num.77 Str.123 Str.124;
let Str.277 : U64 = 0i64;
let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
ret Str.276;
procedure Str.62 (Str.219, Str.220):
let Str.221 : U64 = CallByName Str.36 Str.219;
let Str.222 : U64 = CallByName Str.36 Str.220;
let Str.223 : U64 = CallByName Num.77 Str.221 Str.222;
let Str.409 : U64 = 0i64;
let Str.408 : [C , C U64] = CallByName Str.63 Str.219 Str.220 Str.409 Str.223;
ret Str.408;
procedure Str.58 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
if Str.280 then
let Str.284 : Int1 = CallByName Str.62 Str.126 Str.128 Str.127;
if Str.284 then
dec Str.127;
dec Str.126;
let Str.285 : [C , C U64] = TagId(1) Str.128;
ret Str.285;
procedure Str.63 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
joinpoint Str.410 Str.224 Str.225 Str.226 Str.227:
let Str.412 : Int1 = CallByName Num.23 Str.226 Str.227;
if Str.412 then
let Str.416 : Int1 = CallByName Str.67 Str.224 Str.226 Str.225;
if Str.416 then
dec Str.224;
dec Str.225;
let Str.417 : [C , C U64] = TagId(1) Str.226;
ret Str.417;
else
let Str.283 : U64 = 1i64;
let Str.282 : U64 = CallByName Num.51 Str.128 Str.283;
jump Str.278 Str.126 Str.127 Str.282 Str.129;
let Str.415 : U64 = 1i64;
let Str.414 : U64 = CallByName Num.51 Str.226 Str.415;
jump Str.410 Str.224 Str.225 Str.414 Str.227;
else
dec Str.127;
dec Str.126;
let Str.279 : [C , C U64] = TagId(0) ;
ret Str.279;
dec Str.224;
dec Str.225;
let Str.411 : [C , C U64] = TagId(0) ;
ret Str.411;
in
inc #Derived_gen.14;
inc #Derived_gen.13;
jump Str.278 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
inc #Derived_gen.20;
inc #Derived_gen.21;
jump Str.410 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
procedure Str.61 (Str.152, Str.153):
let Str.308 : Int1 = CallByName Num.22 Str.152 Str.153;
if Str.308 then
ret Str.152;
procedure Str.66 (Str.250, Str.251):
let Str.440 : Int1 = CallByName Num.22 Str.250 Str.251;
if Str.440 then
ret Str.250;
else
ret Str.153;
ret Str.251;
procedure Str.62 (Str.154, Str.155, Str.156):
let Str.157 : U64 = CallByName Str.36 Str.154;
let Str.158 : U64 = CallByName Str.36 Str.156;
let Str.306 : U64 = CallByName Num.53 Str.155 Str.158;
let Str.159 : U64 = CallByName Str.61 Str.306 Str.157;
let Str.305 : U64 = 0i64;
inc Str.156;
inc Str.154;
let Str.287 : {U64, Str, U64, Str, U64, U64} = Struct {Str.159, Str.154, Str.155, Str.156, Str.305, Str.158};
let Str.286 : Int1 = CallByName Str.63 Str.287;
ret Str.286;
procedure Str.67 (Str.252, Str.253, Str.254):
let Str.255 : U64 = CallByName Str.36 Str.252;
let Str.256 : U64 = CallByName Str.36 Str.254;
let Str.438 : U64 = CallByName Num.53 Str.253 Str.256;
let Str.257 : U64 = CallByName Str.66 Str.438 Str.255;
let Str.437 : U64 = 0i64;
inc Str.252;
inc Str.254;
let Str.419 : {U64, Str, U64, Str, U64, U64} = Struct {Str.257, Str.252, Str.253, Str.254, Str.437, Str.256};
let Str.418 : Int1 = CallByName Str.68 Str.419;
ret Str.418;
procedure Str.63 (Str.160):
let Str.166 : U64 = StructAtIndex 0 Str.160;
let Str.161 : Str = StructAtIndex 1 Str.160;
let Str.162 : U64 = StructAtIndex 2 Str.160;
let Str.163 : Str = StructAtIndex 3 Str.160;
let Str.164 : U64 = StructAtIndex 4 Str.160;
let Str.165 : U64 = StructAtIndex 5 Str.160;
let Str.167 : Int1 = CallByName Num.25 Str.162 Str.166;
if Str.167 then
dec Str.163;
dec Str.161;
let Str.168 : Int1 = CallByName Bool.11 Str.164 Str.165;
ret Str.168;
procedure Str.68 (Str.258):
let Str.264 : U64 = StructAtIndex 0 Str.258;
let Str.259 : Str = StructAtIndex 1 Str.258;
let Str.260 : U64 = StructAtIndex 2 Str.258;
let Str.261 : Str = StructAtIndex 3 Str.258;
let Str.262 : U64 = StructAtIndex 4 Str.258;
let Str.263 : U64 = StructAtIndex 5 Str.258;
let Str.265 : Int1 = CallByName Num.25 Str.260 Str.264;
if Str.265 then
dec Str.259;
dec Str.261;
let Str.266 : Int1 = CallByName Bool.11 Str.262 Str.263;
ret Str.266;
else
let Str.301 : U8 = CallByName Str.35 Str.161 Str.162;
let Str.302 : U8 = CallByName Str.35 Str.163 Str.164;
let Str.169 : Int1 = CallByName Bool.11 Str.301 Str.302;
let Str.291 : U64 = StructAtIndex 0 Str.160;
let Str.292 : Str = StructAtIndex 1 Str.160;
let Str.294 : Str = StructAtIndex 3 Str.160;
let Str.296 : U64 = StructAtIndex 5 Str.160;
let Str.300 : U64 = 1i64;
let Str.298 : U64 = CallByName Num.51 Str.164 Str.300;
let Str.299 : U64 = 1i64;
let Str.297 : U64 = CallByName Num.51 Str.162 Str.299;
let Str.290 : {U64, Str, U64, Str, U64, U64} = Struct {Str.291, Str.292, Str.297, Str.294, Str.298, Str.296};
let Str.170 : Int1 = CallByName Str.63 Str.290;
let Str.289 : Int1 = CallByName Bool.3 Str.169 Str.170;
ret Str.289;
let Str.433 : U8 = CallByName Str.35 Str.259 Str.260;
let Str.434 : U8 = CallByName Str.35 Str.261 Str.262;
let Str.267 : Int1 = CallByName Bool.11 Str.433 Str.434;
let Str.423 : U64 = StructAtIndex 0 Str.258;
let Str.424 : Str = StructAtIndex 1 Str.258;
let Str.426 : Str = StructAtIndex 3 Str.258;
let Str.428 : U64 = StructAtIndex 5 Str.258;
let Str.432 : U64 = 1i64;
let Str.430 : U64 = CallByName Num.51 Str.262 Str.432;
let Str.431 : U64 = 1i64;
let Str.429 : U64 = CallByName Num.51 Str.260 Str.431;
let Str.422 : {U64, Str, U64, Str, U64, U64} = Struct {Str.423, Str.424, Str.429, Str.426, Str.430, Str.428};
let Str.268 : Int1 = CallByName Str.68 Str.422;
let Str.421 : Int1 = CallByName Bool.3 Str.267 Str.268;
ret Str.421;
procedure Test.0 ():
let Test.5 : Str = "foo";

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

@ -45,27 +45,27 @@ procedure Num.22 (#Attr.2, #Attr.3):
let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.283;
procedure Str.27 (Str.84):
let Str.246 : [C Int1, C I64] = CallByName Str.66 Str.84;
ret Str.246;
procedure Str.27 (Str.182):
let Str.378 : [C Int1, C I64] = CallByName Str.71 Str.182;
ret Str.378;
procedure Str.42 (#Attr.2):
let Str.254 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.254;
let Str.386 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.386;
procedure Str.66 (Str.191):
let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
if Str.249 then
let Str.251 : I64 = StructAtIndex 0 Str.192;
let Str.250 : [C Int1, C I64] = TagId(1) Str.251;
ret Str.250;
procedure Str.71 (Str.289):
let Str.290 : {I64, U8} = CallByName Str.42 Str.289;
let Str.384 : U8 = StructAtIndex 1 Str.290;
let Str.385 : U8 = 0i64;
let Str.381 : Int1 = CallByName Bool.11 Str.384 Str.385;
if Str.381 then
let Str.383 : I64 = StructAtIndex 0 Str.290;
let Str.382 : [C Int1, C I64] = TagId(1) Str.383;
ret Str.382;
else
let Str.248 : Int1 = false;
let Str.247 : [C Int1, C I64] = TagId(0) Str.248;
ret Str.247;
let Str.380 : Int1 = false;
let Str.379 : [C Int1, C I64] = TagId(0) Str.380;
ret Str.379;
procedure Test.0 ():
let Test.3 : Int1 = CallByName Bool.2;

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

@ -19,30 +19,30 @@ procedure Decode.26 (Decode.109, Decode.110):
ret Decode.126;
procedure Str.12 (#Attr.2):
let Str.255 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.255;
let Str.387 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.387;
procedure Str.27 (Str.84):
let Str.246 : [C {}, C I64] = CallByName Str.66 Str.84;
ret Str.246;
procedure Str.27 (Str.182):
let Str.378 : [C {}, C I64] = CallByName Str.71 Str.182;
ret Str.378;
procedure Str.42 (#Attr.2):
let Str.254 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.254;
let Str.386 : {I64, U8} = lowlevel StrToNum #Attr.2;
ret Str.386;
procedure Str.66 (Str.191):
let Str.192 : {I64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
if Str.249 then
let Str.251 : I64 = StructAtIndex 0 Str.192;
let Str.250 : [C {}, C I64] = TagId(1) Str.251;
ret Str.250;
procedure Str.71 (Str.289):
let Str.290 : {I64, U8} = CallByName Str.42 Str.289;
let Str.384 : U8 = StructAtIndex 1 Str.290;
let Str.385 : U8 = 0i64;
let Str.381 : Int1 = CallByName Bool.11 Str.384 Str.385;
if Str.381 then
let Str.383 : I64 = StructAtIndex 0 Str.290;
let Str.382 : [C {}, C I64] = TagId(1) Str.383;
ret Str.382;
else
let Str.248 : {} = Struct {};
let Str.247 : [C {}, C I64] = TagId(0) Str.248;
ret Str.247;
let Str.380 : {} = Struct {};
let Str.379 : [C {}, C I64] = TagId(0) Str.380;
ret Str.379;
procedure Test.103 ():
let Test.101 : [C Str, C {List U8, I64}] = CallByName Test.19;

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

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

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

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

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

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

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

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

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

@ -3,8 +3,8 @@ procedure Bool.11 (#Attr.2, #Attr.3):
ret Bool.23;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
let Str.379 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.379;
procedure Test.2 (Test.7):
let Test.24 : Str = ".trace(\"";

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

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

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

@ -2,27 +2,27 @@ procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Str.26 (Str.83):
let Str.246 : [C {}, C U64] = CallByName Str.66 Str.83;
ret Str.246;
procedure Str.26 (Str.181):
let Str.378 : [C {}, C U64] = CallByName Str.71 Str.181;
ret Str.378;
procedure Str.42 (#Attr.2):
let Str.254 : {U64, U8} = lowlevel StrToNum #Attr.2;
ret Str.254;
let Str.386 : {U64, U8} = lowlevel StrToNum #Attr.2;
ret Str.386;
procedure Str.66 (Str.191):
let Str.192 : {U64, U8} = CallByName Str.42 Str.191;
let Str.252 : U8 = StructAtIndex 1 Str.192;
let Str.253 : U8 = 0i64;
let Str.249 : Int1 = CallByName Bool.11 Str.252 Str.253;
if Str.249 then
let Str.251 : U64 = StructAtIndex 0 Str.192;
let Str.250 : [C {}, C U64] = TagId(1) Str.251;
ret Str.250;
procedure Str.71 (Str.289):
let Str.290 : {U64, U8} = CallByName Str.42 Str.289;
let Str.384 : U8 = StructAtIndex 1 Str.290;
let Str.385 : U8 = 0i64;
let Str.381 : Int1 = CallByName Bool.11 Str.384 Str.385;
if Str.381 then
let Str.383 : U64 = StructAtIndex 0 Str.290;
let Str.382 : [C {}, C U64] = TagId(1) Str.383;
ret Str.382;
else
let Str.248 : {} = Struct {};
let Str.247 : [C {}, C U64] = TagId(0) Str.248;
ret Str.247;
let Str.380 : {} = Struct {};
let Str.379 : [C {}, C U64] = TagId(0) Str.380;
ret Str.379;
procedure Test.1 (Test.2):
joinpoint Test.11 Test.3:

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

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

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

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