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

Fixed Issue #6929 Escape unicode when inspecting a Str (#7411)

Browse source 
* Fixed Issue #6929 Escape unicode when inspecting Str

added AUTHORS

improved comment

* update generated mono tests

* fixed formatting

* fixed merge conflicts
This commit is contained in:
Timon 2025-01-06 18:52:50 +01:00 • committed by GitHub
parent 89ef225f5b
commit 716374cfc0
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
19 changed files with 3380 additions and 1070 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -1,38 +1,38 @@
procedure Inspect.278 (Inspect.279, Inspect.277):
let Inspect.318 : Str = CallByName Num.96 Inspect.277;
let Inspect.317 : Str = CallByName Inspect.63 Inspect.279 Inspect.318;
dec Inspect.318;
ret Inspect.317;
procedure Inspect.281 (Inspect.282, Inspect.280):
let Inspect.321 : Str = CallByName Num.96 Inspect.280;
let Inspect.320 : Str = CallByName Inspect.63 Inspect.282 Inspect.321;
dec Inspect.321;
ret Inspect.320;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : I64 = CallByName Inspect.57 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName Inspect.278 Inspect.308 Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.57 (Inspect.277):
let Inspect.313 : I64 = CallByName Inspect.30 Inspect.277;
ret Inspect.313;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.320 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.320;
procedure Inspect.5 (Inspect.150):
let Inspect.315 : I64 = CallByName Inspect.57 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName Inspect.281 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.57 (Inspect.280):
let Inspect.316 : I64 = CallByName Inspect.30 Inspect.280;
ret Inspect.316;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.323 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.323;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;

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

@ -1,52 +1,289 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.24;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.323 : Str = "\"";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
dec Inspect.323;
let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
let Inspect.319 : Str = "\"";
let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
dec Inspect.319;
ret Inspect.317;
let Inspect.340 : Str = "\"";
let Inspect.325 : Str = CallByName Inspect.63 Inspect.251 Inspect.340;
dec Inspect.340;
let Inspect.321 : Str = CallByName Inspect.252 Inspect.325 Inspect.249;
let Inspect.322 : Str = "\"";
let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
dec Inspect.322;
ret Inspect.320;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.338 : Str = "\u{feff}";
let Inspect.339 : Str = "\\u(feff)";
let Inspect.335 : Str = CallByName Str.45 Inspect.249 Inspect.338 Inspect.339;
dec Inspect.338;
dec Inspect.339;
let Inspect.336 : Str = "\u{200b}";
let Inspect.337 : Str = "\\u(200b)";
let Inspect.332 : Str = CallByName Str.45 Inspect.335 Inspect.336 Inspect.337;
dec Inspect.337;
dec Inspect.336;
let Inspect.333 : Str = "\u{200c}";
let Inspect.334 : Str = "\\u(200c)";
let Inspect.329 : Str = CallByName Str.45 Inspect.332 Inspect.333 Inspect.334;
dec Inspect.334;
dec Inspect.333;
let Inspect.330 : Str = "\u{200d}";
let Inspect.331 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.329 Inspect.330 Inspect.331;
dec Inspect.330;
dec Inspect.331;
let Inspect.328 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.328;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.47 (Inspect.249):
let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.313;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
dec Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.321;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.47 (Inspect.249):
let Inspect.316 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.316;
procedure Inspect.5 (Inspect.150):
let Inspect.315 : Str = CallByName Inspect.47 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName Inspect.250 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.324 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.324;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.288;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.290;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.292;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.289;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.286;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
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;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
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;
else
dec Str.341;
ret Str.91;
procedure Str.56 (#Derived_gen.7, #Derived_gen.8, #Derived_gen.9, #Derived_gen.10):
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;
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;
in
inc #Derived_gen.9;
inc #Derived_gen.10;
jump Str.250 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10;
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.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
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.0;
inc #Derived_gen.1;
jump Str.278 #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;
else
ret Str.153;
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.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;
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;
procedure Test.1 ():
let Test.4 : Str = "";
let Test.0 : Str = CallByName Inspect.33 Test.4;

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

@ -1,48 +1,285 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.323 : Str = "\"";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
dec Inspect.323;
let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
let Inspect.319 : Str = "\"";
let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
dec Inspect.319;
ret Inspect.317;
let Inspect.340 : Str = "\"";
let Inspect.325 : Str = CallByName Inspect.63 Inspect.251 Inspect.340;
dec Inspect.340;
let Inspect.321 : Str = CallByName Inspect.252 Inspect.325 Inspect.249;
let Inspect.322 : Str = "\"";
let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
dec Inspect.322;
ret Inspect.320;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.338 : Str = "\u{feff}";
let Inspect.339 : Str = "\\u(feff)";
let Inspect.335 : Str = CallByName Str.45 Inspect.249 Inspect.338 Inspect.339;
dec Inspect.338;
dec Inspect.339;
let Inspect.336 : Str = "\u{200b}";
let Inspect.337 : Str = "\\u(200b)";
let Inspect.332 : Str = CallByName Str.45 Inspect.335 Inspect.336 Inspect.337;
dec Inspect.337;
dec Inspect.336;
let Inspect.333 : Str = "\u{200c}";
let Inspect.334 : Str = "\\u(200c)";
let Inspect.329 : Str = CallByName Str.45 Inspect.332 Inspect.333 Inspect.334;
dec Inspect.334;
dec Inspect.333;
let Inspect.330 : Str = "\u{200d}";
let Inspect.331 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.329 Inspect.330 Inspect.331;
dec Inspect.330;
dec Inspect.331;
let Inspect.328 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.328;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.47 (Inspect.249):
let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.313;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
dec Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.321;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.47 (Inspect.249):
let Inspect.316 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.316;
procedure Inspect.5 (Inspect.150):
let Inspect.315 : Str = CallByName Inspect.47 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName Inspect.250 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.324 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.324;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.288;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.290;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.292;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.289;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.286;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.315 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.315;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.248;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.305 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.305;
procedure Str.36 (#Attr.2):
let Str.268 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.268;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.266 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.266;
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;
else
dec Str.112;
let Str.274 : {} = Struct {};
let Str.273 : [C {}, C {Str, Str}] = TagId(0) Str.274;
ret Str.273;
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;
else
dec Str.343;
ret Str.91;
procedure Str.56 (#Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
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;
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;
in
inc #Derived_gen.8;
inc #Derived_gen.9;
jump Str.252 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
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.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
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.3;
inc #Derived_gen.2;
jump Str.280 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
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;
else
ret Str.153;
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.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;
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;
procedure Test.0 ():
let Test.5 : Str = "Hello ";
let Test.2 : Str = "world";

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

@ -1,38 +1,38 @@
procedure Inspect.278 (Inspect.279, Inspect.277):
let Inspect.318 : Str = CallByName Num.96 Inspect.277;
let Inspect.317 : Str = CallByName Inspect.63 Inspect.279 Inspect.318;
dec Inspect.318;
ret Inspect.317;
procedure Inspect.281 (Inspect.282, Inspect.280):
let Inspect.321 : Str = CallByName Num.96 Inspect.280;
let Inspect.320 : Str = CallByName Inspect.63 Inspect.282 Inspect.321;
dec Inspect.321;
ret Inspect.320;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.33 (Inspect.152):
let Inspect.324 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.323 : Str = CallByName Inspect.64 Inspect.324;
ret Inspect.323;
let Inspect.327 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.326 : Str = CallByName Inspect.64 Inspect.327;
ret Inspect.326;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : I64 = CallByName Inspect.57 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName Inspect.278 Inspect.308 Inspect.312;
ret Inspect.307;
let Inspect.315 : I64 = CallByName Inspect.57 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName Inspect.281 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.57 (Inspect.277):
let Inspect.313 : I64 = CallByName Inspect.30 Inspect.277;
ret Inspect.313;
procedure Inspect.57 (Inspect.280):
let Inspect.316 : I64 = CallByName Inspect.30 Inspect.280;
ret Inspect.316;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.320 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.320;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.323 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.323;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure Num.96 (#Attr.2):
let Num.283 : Str = lowlevel NumToStr #Attr.2;

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

@ -1,48 +1,285 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.323 : Str = "\"";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
dec Inspect.323;
let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
let Inspect.319 : Str = "\"";
let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
dec Inspect.319;
ret Inspect.317;
let Inspect.340 : Str = "\"";
let Inspect.325 : Str = CallByName Inspect.63 Inspect.251 Inspect.340;
dec Inspect.340;
let Inspect.321 : Str = CallByName Inspect.252 Inspect.325 Inspect.249;
let Inspect.322 : Str = "\"";
let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
dec Inspect.322;
ret Inspect.320;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.338 : Str = "\u{feff}";
let Inspect.339 : Str = "\\u(feff)";
let Inspect.335 : Str = CallByName Str.45 Inspect.249 Inspect.338 Inspect.339;
dec Inspect.338;
dec Inspect.339;
let Inspect.336 : Str = "\u{200b}";
let Inspect.337 : Str = "\\u(200b)";
let Inspect.332 : Str = CallByName Str.45 Inspect.335 Inspect.336 Inspect.337;
dec Inspect.337;
dec Inspect.336;
let Inspect.333 : Str = "\u{200c}";
let Inspect.334 : Str = "\\u(200c)";
let Inspect.329 : Str = CallByName Str.45 Inspect.332 Inspect.333 Inspect.334;
dec Inspect.334;
dec Inspect.333;
let Inspect.330 : Str = "\u{200d}";
let Inspect.331 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.329 Inspect.330 Inspect.331;
dec Inspect.330;
dec Inspect.331;
let Inspect.328 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.328;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.47 (Inspect.249):
let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.313;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
dec Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.321;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.47 (Inspect.249):
let Inspect.316 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.316;
procedure Inspect.5 (Inspect.150):
let Inspect.315 : Str = CallByName Inspect.47 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName Inspect.250 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.324 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.324;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.288;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.290;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.292;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.289;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.286;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
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;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
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;
else
dec Str.341;
ret Str.91;
procedure Str.56 (#Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
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;
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;
in
inc #Derived_gen.8;
inc #Derived_gen.9;
jump Str.250 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
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.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
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.3;
inc #Derived_gen.2;
jump Str.278 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
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;
else
ret Str.153;
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.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;
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;
procedure Test.0 ():
let Test.3 : Str = "";
let Test.1 : Str = CallByName Inspect.33 Test.3;

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

@ -11,8 +11,12 @@ procedure Bool.11 (#Attr.2, #Attr.3):
ret Bool.29;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.30 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.30;
let Bool.34 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.34;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.35 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.35;
procedure Bool.12 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel NotEq #Attr.2 #Attr.3;
@ -26,6 +30,10 @@ procedure Bool.2 ():
let Bool.31 : Int1 = true;
ret Bool.31;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.33 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.33;
procedure Bool.7 (Bool.19, Bool.20):
let Bool.25 : Int1 = CallByName Bool.12 Bool.19 Bool.20;
ret Bool.25;
@ -45,8 +53,8 @@ procedure Dict.1 (Dict.731):
procedure Dict.10 (Dict.732, Dict.186, Dict.187):
let Dict.185 : List {Str, I64} = StructAtIndex 1 Dict.732;
let #Derived_gen.67 : List {U32, U32} = StructAtIndex 0 Dict.732;
dec #Derived_gen.67;
let #Derived_gen.78 : List {U32, U32} = StructAtIndex 0 Dict.732;
dec #Derived_gen.78;
let Dict.1109 : {Str, Int1} = CallByName List.18 Dict.185 Dict.186 Dict.187;
dec Dict.185;
ret Dict.1109;
@ -101,10 +109,10 @@ procedure Dict.188 (Dict.189, Dict.1111, Dict.187):
procedure Dict.20 (Dict.728):
let Dict.155 : U64 = StructAtIndex 2 Dict.728;
let #Derived_gen.70 : List {U32, U32} = StructAtIndex 0 Dict.728;
dec #Derived_gen.70;
let #Derived_gen.69 : List {Str, I64} = StructAtIndex 1 Dict.728;
dec #Derived_gen.69;
let #Derived_gen.81 : List {U32, U32} = StructAtIndex 0 Dict.728;
dec #Derived_gen.81;
let #Derived_gen.80 : List {Str, I64} = StructAtIndex 1 Dict.728;
dec #Derived_gen.80;
ret Dict.155;
procedure Dict.22 (#Attr.2, #Attr.3):
@ -125,8 +133,8 @@ procedure Dict.23 (#Attr.2):
procedure Dict.4 (Dict.737):
let Dict.163 : List {Str, I64} = StructAtIndex 1 Dict.737;
let #Derived_gen.66 : List {U32, U32} = StructAtIndex 0 Dict.737;
dec #Derived_gen.66;
let #Derived_gen.77 : List {U32, U32} = StructAtIndex 0 Dict.737;
dec #Derived_gen.77;
let Dict.890 : U64 = CallByName List.6 Dict.163;
dec Dict.163;
ret Dict.890;
@ -145,7 +153,7 @@ procedure Dict.43 (Dict.126):
let Dict.1101 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Inspect.30 Dict.126;
ret Dict.1101;
procedure Dict.45 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_gen.48, #Derived_gen.49, #Derived_gen.50, #Derived_gen.51, #Derived_gen.52, #Derived_gen.53):
procedure Dict.45 (#Derived_gen.50, #Derived_gen.51, #Derived_gen.52, #Derived_gen.53, #Derived_gen.54, #Derived_gen.55, #Derived_gen.56, #Derived_gen.57, #Derived_gen.58):
joinpoint Dict.744 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.791 : U32 = StructAtIndex 1 Dict.237;
@ -188,8 +196,8 @@ procedure Dict.45 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_g
let Dict.246 : U32 = CallByName Dict.55 Dict.231;
jump Dict.744 Dict.228 Dict.229 Dict.245 Dict.246 Dict.232 Dict.233 Dict.234 Dict.235 Dict.236;
in
inc #Derived_gen.49;
jump Dict.744 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53;
inc #Derived_gen.54;
jump Dict.744 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53 #Derived_gen.54 #Derived_gen.55 #Derived_gen.56 #Derived_gen.57 #Derived_gen.58;
procedure Dict.48 ():
let Dict.868 : U32 = 0i64;
@ -239,8 +247,8 @@ procedure Dict.66 (Dict.727):
let Dict.385 : U64 = StructAtIndex 2 Dict.727;
let Dict.386 : Float32 = StructAtIndex 3 Dict.727;
let Dict.387 : U8 = StructAtIndex 4 Dict.727;
let #Derived_gen.68 : List {U32, U32} = StructAtIndex 0 Dict.727;
dec #Derived_gen.68;
let #Derived_gen.79 : List {U32, U32} = StructAtIndex 0 Dict.727;
dec #Derived_gen.79;
let Dict.885 : U64 = CallByName Dict.54;
let Dict.844 : Int1 = CallByName Bool.7 Dict.385 Dict.885;
if Dict.844 then
@ -304,7 +312,7 @@ procedure Dict.72 (Dict.412, Dict.413, Dict.414):
let Dict.854 : {U64, U32} = CallByName Dict.73 Dict.412 Dict.417 Dict.416;
ret Dict.854;
procedure Dict.73 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
procedure Dict.73 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
joinpoint Dict.855 Dict.418 Dict.419 Dict.420:
let Dict.421 : {U32, U32} = CallByName Dict.22 Dict.418 Dict.419;
let Dict.862 : U32 = StructAtIndex 1 Dict.421;
@ -319,10 +327,10 @@ procedure Dict.73 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
let Dict.856 : {U64, U32} = Struct {Dict.419, Dict.420};
ret Dict.856;
in
inc #Derived_gen.16;
jump Dict.855 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
inc #Derived_gen.19;
jump Dict.855 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
procedure Dict.74 (#Derived_gen.54, #Derived_gen.55, #Derived_gen.56):
procedure Dict.74 (#Derived_gen.59, #Derived_gen.60, #Derived_gen.61):
joinpoint Dict.761 Dict.422 Dict.423 Dict.424:
let Dict.425 : {U32, U32} = CallByName Dict.22 Dict.422 Dict.424;
let Dict.771 : U32 = StructAtIndex 1 Dict.425;
@ -341,7 +349,7 @@ procedure Dict.74 (#Derived_gen.54, #Derived_gen.55, #Derived_gen.56):
let Dict.762 : List {U32, U32} = CallByName List.3 Dict.422 Dict.424 Dict.423;
ret Dict.762;
in
jump Dict.761 #Derived_gen.54 #Derived_gen.55 #Derived_gen.56;
jump Dict.761 #Derived_gen.59 #Derived_gen.60 #Derived_gen.61;
procedure Dict.75 (Dict.427, Dict.428):
let Dict.757 : U64 = 1i64;
@ -521,7 +529,7 @@ procedure Dict.89 (Dict.710, Dict.488):
let Dict.925 : {U64, U64, U64} = CallByName Dict.90 Dict.486 Dict.486 Dict.486 Dict.488 Dict.927 Dict.489;
jump Dict.926 Dict.925;
procedure Dict.90 (#Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11):
procedure Dict.90 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
joinpoint Dict.928 Dict.494 Dict.495 Dict.496 Dict.497 Dict.498 Dict.499:
let Dict.1035 : U64 = CallByName Dict.98 Dict.497 Dict.498;
let Dict.1036 : U64 = CallByName Dict.93;
@ -583,10 +591,10 @@ procedure Dict.90 (#Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.
let Dict.929 : {U64, U64, U64} = Struct {Dict.930, Dict.931, Dict.506};
ret Dict.929;
in
inc #Derived_gen.9;
jump Dict.928 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11;
inc #Derived_gen.12;
jump Dict.928 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
procedure Dict.91 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
procedure Dict.91 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
joinpoint Dict.981 Dict.507 Dict.508 Dict.509 Dict.510:
let Dict.1001 : U64 = CallByName Dict.98 Dict.508 Dict.509;
let Dict.1002 : U64 = CallByName Dict.93;
@ -617,8 +625,8 @@ procedure Dict.91 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
else
jump Dict.981 Dict.511 Dict.508 Dict.513 Dict.512;
in
inc #Derived_gen.1;
jump Dict.981 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
inc #Derived_gen.2;
jump Dict.981 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
procedure Dict.92 ():
let Dict.918 : U64 = 11562461410679940143i64;
@ -745,90 +753,114 @@ procedure Inspect.187 (Inspect.188, #Attr.12):
let Inspect.185 : {} = StructAtIndex 2 #Attr.12;
let Inspect.184 : {} = StructAtIndex 1 #Attr.12;
let Inspect.183 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = StructAtIndex 0 #Attr.12;
let Inspect.355 : Str = "{";
let Inspect.328 : Str = CallByName Inspect.63 Inspect.188 Inspect.355;
dec Inspect.355;
let Inspect.329 : {{List {U32, U32}, List {Str, I64}, U64, Float32, U8}, {}, {}, {}} = Struct {Inspect.183, Inspect.184, Inspect.185, Inspect.186};
let Inspect.324 : {Str, Int1} = CallByName Inspect.189 Inspect.328 Inspect.329;
dec Inspect.328;
let Inspect.325 : {} = Struct {};
let Inspect.320 : Str = CallByName Inspect.201 Inspect.324;
let Inspect.321 : Str = "}";
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
dec Inspect.321;
ret Inspect.319;
let Inspect.358 : Str = "{";
let Inspect.331 : Str = CallByName Inspect.63 Inspect.188 Inspect.358;
dec Inspect.358;
let Inspect.332 : {{List {U32, U32}, List {Str, I64}, U64, Float32, U8}, {}, {}, {}} = Struct {Inspect.183, Inspect.184, Inspect.185, Inspect.186};
let Inspect.327 : {Str, Int1} = CallByName Inspect.189 Inspect.331 Inspect.332;
dec Inspect.331;
let Inspect.328 : {} = Struct {};
let Inspect.323 : Str = CallByName Inspect.201 Inspect.327;
let Inspect.324 : Str = "}";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.323 Inspect.324;
dec Inspect.324;
ret Inspect.322;
procedure Inspect.189 (Inspect.190, #Attr.12):
let Inspect.186 : {} = StructAtIndex 3 #Attr.12;
let Inspect.185 : {} = StructAtIndex 2 #Attr.12;
let Inspect.184 : {} = StructAtIndex 1 #Attr.12;
let Inspect.183 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = StructAtIndex 0 #Attr.12;
let Inspect.354 : Int1 = CallByName Bool.1;
let Inspect.357 : Int1 = CallByName Bool.1;
inc Inspect.190;
let Inspect.332 : {Str, Int1} = Struct {Inspect.190, Inspect.354};
let Inspect.333 : {{}, {}} = Struct {Inspect.185, Inspect.186};
let Inspect.331 : {Str, Int1} = CallByName Dict.10 Inspect.183 Inspect.332 Inspect.333;
ret Inspect.331;
let Inspect.335 : {Str, Int1} = Struct {Inspect.190, Inspect.357};
let Inspect.336 : {{}, {}} = Struct {Inspect.185, Inspect.186};
let Inspect.334 : {Str, Int1} = CallByName Dict.10 Inspect.183 Inspect.335 Inspect.336;
ret Inspect.334;
procedure Inspect.191 (Inspect.334, Inspect.194, Inspect.195, #Attr.12):
procedure Inspect.191 (Inspect.337, Inspect.194, Inspect.195, #Attr.12):
let Inspect.186 : {} = StructAtIndex 1 #Attr.12;
let Inspect.185 : {} = StructAtIndex 0 #Attr.12;
let Inspect.192 : Str = StructAtIndex 0 Inspect.334;
let Inspect.193 : Int1 = StructAtIndex 1 Inspect.334;
joinpoint Inspect.352 Inspect.196:
let Inspect.349 : Str = CallByName Inspect.47 Inspect.194;
let Inspect.347 : Str = CallByName Inspect.31 Inspect.349 Inspect.196;
dec Inspect.349;
let Inspect.348 : Str = ": ";
let Inspect.341 : Str = CallByName Inspect.63 Inspect.347 Inspect.348;
dec Inspect.348;
let Inspect.342 : {I64, {}} = Struct {Inspect.195, Inspect.186};
let Inspect.337 : Str = CallByName Inspect.197 Inspect.341 Inspect.342;
let Inspect.338 : {} = Struct {};
let Inspect.336 : {Str, Int1} = CallByName Inspect.199 Inspect.337;
dec Inspect.337;
ret Inspect.336;
let Inspect.192 : Str = StructAtIndex 0 Inspect.337;
let Inspect.193 : Int1 = StructAtIndex 1 Inspect.337;
joinpoint Inspect.355 Inspect.196:
let Inspect.352 : Str = CallByName Inspect.47 Inspect.194;
let Inspect.350 : Str = CallByName Inspect.31 Inspect.352 Inspect.196;
let Inspect.351 : Str = ": ";
let Inspect.344 : Str = CallByName Inspect.63 Inspect.350 Inspect.351;
dec Inspect.351;
let Inspect.345 : {I64, {}} = Struct {Inspect.195, Inspect.186};
let Inspect.340 : Str = CallByName Inspect.197 Inspect.344 Inspect.345;
let Inspect.341 : {} = Struct {};
let Inspect.339 : {Str, Int1} = CallByName Inspect.199 Inspect.340;
dec Inspect.340;
ret Inspect.339;
in
if Inspect.193 then
let Inspect.353 : Str = ", ";
let Inspect.351 : Str = CallByName Inspect.63 Inspect.192 Inspect.353;
dec Inspect.353;
jump Inspect.352 Inspect.351;
let Inspect.356 : Str = ", ";
let Inspect.354 : Str = CallByName Inspect.63 Inspect.192 Inspect.356;
dec Inspect.356;
jump Inspect.355 Inspect.354;
else
jump Inspect.352 Inspect.192;
jump Inspect.355 Inspect.192;
procedure Inspect.197 (Inspect.198, #Attr.12):
let Inspect.186 : {} = StructAtIndex 1 #Attr.12;
let Inspect.195 : I64 = StructAtIndex 0 #Attr.12;
let Inspect.345 : I64 = CallByName Inspect.57 Inspect.195;
let Inspect.344 : Str = CallByName Inspect.31 Inspect.345 Inspect.198;
ret Inspect.344;
let Inspect.348 : I64 = CallByName Inspect.57 Inspect.195;
let Inspect.347 : Str = CallByName Inspect.31 Inspect.348 Inspect.198;
ret Inspect.347;
procedure Inspect.199 (Inspect.200):
let Inspect.340 : Int1 = CallByName Bool.2;
let Inspect.343 : Int1 = CallByName Bool.2;
inc Inspect.200;
let Inspect.339 : {Str, Int1} = Struct {Inspect.200, Inspect.340};
ret Inspect.339;
let Inspect.342 : {Str, Int1} = Struct {Inspect.200, Inspect.343};
ret Inspect.342;
procedure Inspect.201 (Inspect.326):
let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
ret Inspect.327;
procedure Inspect.201 (Inspect.329):
let Inspect.330 : Str = StructAtIndex 0 Inspect.329;
ret Inspect.330;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.370 : Str = "\"";
let Inspect.369 : Str = CallByName Inspect.63 Inspect.251 Inspect.370;
dec Inspect.370;
let Inspect.367 : Str = CallByName Inspect.63 Inspect.369 Inspect.249;
let Inspect.368 : Str = "\"";
let Inspect.366 : Str = CallByName Inspect.63 Inspect.367 Inspect.368;
dec Inspect.368;
ret Inspect.366;
let Inspect.387 : Str = "\"";
let Inspect.372 : Str = CallByName Inspect.63 Inspect.251 Inspect.387;
dec Inspect.387;
let Inspect.370 : Str = CallByName Inspect.252 Inspect.372 Inspect.249;
let Inspect.371 : Str = "\"";
let Inspect.369 : Str = CallByName Inspect.63 Inspect.370 Inspect.371;
dec Inspect.371;
ret Inspect.369;
procedure Inspect.278 (Inspect.279, Inspect.277):
let Inspect.361 : Str = CallByName Num.96 Inspect.277;
let Inspect.360 : Str = CallByName Inspect.63 Inspect.279 Inspect.361;
dec Inspect.361;
ret Inspect.360;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.385 : Str = "\u{feff}";
let Inspect.386 : Str = "\\u(feff)";
let Inspect.382 : Str = CallByName Str.45 Inspect.249 Inspect.385 Inspect.386;
dec Inspect.386;
dec Inspect.385;
let Inspect.383 : Str = "\u{200b}";
let Inspect.384 : Str = "\\u(200b)";
let Inspect.379 : Str = CallByName Str.45 Inspect.382 Inspect.383 Inspect.384;
dec Inspect.384;
dec Inspect.383;
let Inspect.380 : Str = "\u{200c}";
let Inspect.381 : Str = "\\u(200c)";
let Inspect.376 : Str = CallByName Str.45 Inspect.379 Inspect.380 Inspect.381;
dec Inspect.380;
dec Inspect.381;
let Inspect.377 : Str = "\u{200d}";
let Inspect.378 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.376 Inspect.377 Inspect.378;
dec Inspect.377;
dec Inspect.378;
let Inspect.375 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.375;
procedure Inspect.281 (Inspect.282, Inspect.280):
let Inspect.364 : Str = CallByName Num.96 Inspect.280;
let Inspect.363 : Str = CallByName Inspect.63 Inspect.282 Inspect.364;
dec Inspect.364;
ret Inspect.363;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
@ -842,55 +874,55 @@ procedure Inspect.30 (Inspect.147):
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.314 : Str = CallByName Inspect.187 Inspect.149 Inspect.303;
ret Inspect.314;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.317 : Str = CallByName Inspect.187 Inspect.149 Inspect.306;
ret Inspect.317;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.346 : Str = CallByName Inspect.278 Inspect.149 Inspect.303;
ret Inspect.346;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.349 : Str = CallByName Inspect.281 Inspect.149 Inspect.306;
ret Inspect.349;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.350 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
ret Inspect.350;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.353 : Str = CallByName Inspect.250 Inspect.149 Inspect.306;
ret Inspect.353;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.42 (Inspect.183, Inspect.184, Inspect.185, Inspect.186):
let Inspect.316 : {{List {U32, U32}, List {Str, I64}, U64, Float32, U8}, {}, {}, {}} = Struct {Inspect.183, Inspect.184, Inspect.185, Inspect.186};
let Inspect.315 : {{List {U32, U32}, List {Str, I64}, U64, Float32, U8}, {}, {}, {}} = CallByName Inspect.30 Inspect.316;
ret Inspect.315;
procedure Inspect.47 (Inspect.249):
let Inspect.362 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.362;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Dict.43 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName Dict.127 Inspect.308 Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.57 (Inspect.277):
let Inspect.356 : I64 = CallByName Inspect.30 Inspect.277;
ret Inspect.356;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.323;
procedure Inspect.42 (Inspect.183, Inspect.184, Inspect.185, Inspect.186):
let Inspect.319 : {{List {U32, U32}, List {Str, I64}, U64, Float32, U8}, {}, {}, {}} = Struct {Inspect.183, Inspect.184, Inspect.185, Inspect.186};
let Inspect.318 : {{List {U32, U32}, List {Str, I64}, U64, Float32, U8}, {}, {}, {}} = CallByName Inspect.30 Inspect.319;
ret Inspect.318;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.47 (Inspect.249):
let Inspect.365 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.365;
procedure List.100 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44):
procedure Inspect.5 (Inspect.150):
let Inspect.315 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Dict.43 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName Dict.127 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.57 (Inspect.280):
let Inspect.359 : I64 = CallByName Inspect.30 Inspect.280;
ret Inspect.359;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.326 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.326;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure List.100 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_gen.48, #Derived_gen.49):
joinpoint List.732 List.174 List.175 List.176 List.177 List.178:
let List.734 : Int1 = CallByName Num.22 List.177 List.178;
if List.734 then
@ -904,10 +936,10 @@ procedure List.100 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_
dec List.174;
ret List.175;
in
inc #Derived_gen.40;
jump List.732 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
inc #Derived_gen.45;
jump List.732 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49;
procedure List.100 (#Derived_gen.61, #Derived_gen.62, #Derived_gen.63, #Derived_gen.64, #Derived_gen.65):
procedure List.100 (#Derived_gen.72, #Derived_gen.73, #Derived_gen.74, #Derived_gen.75, #Derived_gen.76):
joinpoint List.668 List.174 List.175 List.176 List.177 List.178:
let List.670 : Int1 = CallByName Num.22 List.177 List.178;
if List.670 then
@ -921,10 +953,10 @@ procedure List.100 (#Derived_gen.61, #Derived_gen.62, #Derived_gen.63, #Derived_
dec List.174;
ret List.175;
in
inc #Derived_gen.61;
jump List.668 #Derived_gen.61 #Derived_gen.62 #Derived_gen.63 #Derived_gen.64 #Derived_gen.65;
inc #Derived_gen.72;
jump List.668 #Derived_gen.72 #Derived_gen.73 #Derived_gen.74 #Derived_gen.75 #Derived_gen.76;
procedure List.101 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25):
procedure List.101 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28):
joinpoint List.707 List.183 List.184 List.185 List.186 List.187:
let List.709 : Int1 = CallByName Num.22 List.186 List.187;
if List.709 then
@ -938,8 +970,8 @@ procedure List.101 (#Derived_gen.21, #Derived_gen.22, #Derived_gen.23, #Derived_
dec List.183;
ret List.184;
in
inc #Derived_gen.21;
jump List.707 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25;
inc #Derived_gen.24;
jump List.707 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
procedure List.11 (List.149, List.150):
let List.727 : List {U32, U32} = CallByName List.68 List.150;
@ -966,8 +998,8 @@ procedure List.3 (List.127, List.128, List.129):
procedure List.3 (List.127, List.128, List.129):
let List.693 : {List {Str, I64}, {Str, I64}} = CallByName List.64 List.127 List.128 List.129;
let List.692 : List {Str, I64} = StructAtIndex 0 List.693;
let #Derived_gen.71 : {Str, I64} = StructAtIndex 1 List.693;
dec #Derived_gen.71;
let #Derived_gen.82 : {Str, I64} = StructAtIndex 1 List.693;
dec #Derived_gen.82;
ret List.692;
procedure List.4 (List.135, List.136):
@ -1042,7 +1074,7 @@ procedure List.83 (List.180, List.181, List.182):
let List.704 : List {U32, U32} = CallByName List.101 List.180 List.181 List.182 List.705 List.706;
ret List.704;
procedure List.98 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
procedure List.98 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35):
joinpoint List.716 List.151 List.152 List.153:
let List.724 : U64 = 0i64;
let List.718 : Int1 = CallByName Num.24 List.152 List.724;
@ -1054,7 +1086,7 @@ procedure List.98 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
else
ret List.153;
in
jump List.716 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
jump List.716 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35;
procedure Num.131 (#Attr.2):
let Num.291 : U32 = lowlevel NumIntCast #Attr.2;
@ -1087,6 +1119,10 @@ procedure Num.148 (Num.226, Num.227):
else
ret Num.227;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.446 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.446;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.316 : Float32 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.316;
@ -1096,12 +1132,12 @@ procedure Num.22 (#Attr.2, #Attr.3):
ret Num.313;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.442 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.442;
let Num.453 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.453;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.435 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.435;
let Num.450 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.450;
procedure Num.24 (#Attr.2, #Attr.3):
let Num.297 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
@ -1112,8 +1148,8 @@ procedure Num.24 (#Attr.2, #Attr.3):
ret Num.438;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.439 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.439;
let Num.447 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.447;
procedure Num.50 (#Attr.2):
let Num.315 : U64 = lowlevel NumFloor #Attr.2;
@ -1124,8 +1160,12 @@ procedure Num.51 (#Attr.2, #Attr.3):
ret Num.283;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.441 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.441;
let Num.452 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.452;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.449 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.449;
procedure Num.69 (#Attr.2, #Attr.3):
let Num.305 : U32 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3;
@ -1171,6 +1211,10 @@ procedure Num.75 (#Attr.2, #Attr.3):
let Num.432 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
ret Num.432;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.451 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.451;
procedure Num.78 (#Attr.2, #Attr.3):
let Num.367 : U128 = lowlevel NumMulWrap #Attr.2 #Attr.3;
ret Num.367;
@ -1187,10 +1231,183 @@ procedure Str.12 (#Attr.2):
let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;
ret Str.248;
procedure Str.20 (#Attr.2):
let Str.316 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.316;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.249;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.306 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.306;
procedure Str.36 (#Attr.2):
let Str.269 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.269;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.267 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.267;
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;
else
dec Str.112;
let Str.275 : {} = Struct {};
let Str.274 : [C {}, C {Str, Str}] = TagId(0) Str.275;
ret Str.274;
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;
else
dec Str.344;
ret Str.91;
procedure Str.56 (#Derived_gen.62, #Derived_gen.63, #Derived_gen.64, #Derived_gen.65):
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;
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;
in
inc #Derived_gen.64;
inc #Derived_gen.65;
jump Str.253 #Derived_gen.62 #Derived_gen.63 #Derived_gen.64 #Derived_gen.65;
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.58 (#Derived_gen.68, #Derived_gen.69, #Derived_gen.70, #Derived_gen.71):
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;
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;
else
dec Str.127;
dec Str.126;
let Str.282 : [C , C U64] = TagId(0) ;
ret Str.282;
in
inc #Derived_gen.69;
inc #Derived_gen.68;
jump Str.281 #Derived_gen.68 #Derived_gen.69 #Derived_gen.70 #Derived_gen.71;
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;
else
ret Str.153;
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.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;
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;
procedure Test.0 ():
let Test.8 : Str = "a";
let Test.9 : I64 = 1i64;

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

@ -25,115 +25,115 @@ procedure Inspect.156 (Inspect.157, #Attr.12):
let Inspect.155 : {} = StructAtIndex 2 #Attr.12;
let Inspect.154 : {} = StructAtIndex 1 #Attr.12;
let Inspect.153 : List I64 = StructAtIndex 0 #Attr.12;
let Inspect.347 : Str = "[";
let Inspect.328 : Str = CallByName Inspect.63 Inspect.157 Inspect.347;
dec Inspect.347;
let Inspect.329 : {List I64, {}, {}} = Struct {Inspect.153, Inspect.154, Inspect.155};
let Inspect.324 : {Str, Int1} = CallByName Inspect.158 Inspect.328 Inspect.329;
dec Inspect.328;
let Inspect.325 : {} = Struct {};
let Inspect.320 : Str = CallByName Inspect.167 Inspect.324;
let Inspect.321 : Str = "]";
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
dec Inspect.321;
ret Inspect.319;
let Inspect.350 : Str = "[";
let Inspect.331 : Str = CallByName Inspect.63 Inspect.157 Inspect.350;
dec Inspect.350;
let Inspect.332 : {List I64, {}, {}} = Struct {Inspect.153, Inspect.154, Inspect.155};
let Inspect.327 : {Str, Int1} = CallByName Inspect.158 Inspect.331 Inspect.332;
dec Inspect.331;
let Inspect.328 : {} = Struct {};
let Inspect.323 : Str = CallByName Inspect.167 Inspect.327;
let Inspect.324 : Str = "]";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.323 Inspect.324;
dec Inspect.324;
ret Inspect.322;
procedure Inspect.158 (Inspect.159, #Attr.12):
let Inspect.155 : {} = StructAtIndex 2 #Attr.12;
let Inspect.154 : {} = StructAtIndex 1 #Attr.12;
let Inspect.153 : List I64 = StructAtIndex 0 #Attr.12;
let Inspect.346 : Int1 = CallByName Bool.1;
let Inspect.349 : Int1 = CallByName Bool.1;
inc Inspect.159;
let Inspect.332 : {Str, Int1} = Struct {Inspect.159, Inspect.346};
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.153 Inspect.332 Inspect.155;
let Inspect.335 : {Str, Int1} = Struct {Inspect.159, Inspect.349};
let Inspect.334 : {Str, Int1} = CallByName List.18 Inspect.153 Inspect.335 Inspect.155;
dec Inspect.153;
ret Inspect.331;
ret Inspect.334;
procedure Inspect.160 (Inspect.334, Inspect.163, Inspect.155):
let Inspect.161 : Str = StructAtIndex 0 Inspect.334;
let Inspect.162 : Int1 = StructAtIndex 1 Inspect.334;
joinpoint Inspect.344 Inspect.164:
let Inspect.341 : I64 = CallByName #Derived.3 Inspect.163;
let Inspect.337 : Str = CallByName Inspect.31 Inspect.341 Inspect.164;
let Inspect.338 : {} = Struct {};
let Inspect.336 : {Str, Int1} = CallByName Inspect.165 Inspect.337;
dec Inspect.337;
ret Inspect.336;
procedure Inspect.160 (Inspect.337, Inspect.163, Inspect.155):
let Inspect.161 : Str = StructAtIndex 0 Inspect.337;
let Inspect.162 : Int1 = StructAtIndex 1 Inspect.337;
joinpoint Inspect.347 Inspect.164:
let Inspect.344 : I64 = CallByName #Derived.3 Inspect.163;
let Inspect.340 : Str = CallByName Inspect.31 Inspect.344 Inspect.164;
let Inspect.341 : {} = Struct {};
let Inspect.339 : {Str, Int1} = CallByName Inspect.165 Inspect.340;
dec Inspect.340;
ret Inspect.339;
in
if Inspect.162 then
let Inspect.345 : Str = ", ";
let Inspect.343 : Str = CallByName Inspect.63 Inspect.161 Inspect.345;
dec Inspect.345;
jump Inspect.344 Inspect.343;
let Inspect.348 : Str = ", ";
let Inspect.346 : Str = CallByName Inspect.63 Inspect.161 Inspect.348;
dec Inspect.348;
jump Inspect.347 Inspect.346;
else
jump Inspect.344 Inspect.161;
jump Inspect.347 Inspect.161;
procedure Inspect.165 (Inspect.166):
let Inspect.340 : Int1 = CallByName Bool.2;
let Inspect.343 : Int1 = CallByName Bool.2;
inc Inspect.166;
let Inspect.339 : {Str, Int1} = Struct {Inspect.166, Inspect.340};
ret Inspect.339;
procedure Inspect.167 (Inspect.326):
let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
ret Inspect.327;
procedure Inspect.278 (Inspect.279, Inspect.277):
let Inspect.353 : Str = CallByName Num.96 Inspect.277;
let Inspect.352 : Str = CallByName Inspect.63 Inspect.279 Inspect.353;
dec Inspect.353;
ret Inspect.352;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.314 : Str = CallByName Inspect.156 Inspect.149 Inspect.303;
ret Inspect.314;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.342 : Str = CallByName Inspect.278 Inspect.149 Inspect.303;
let Inspect.342 : {Str, Int1} = Struct {Inspect.166, Inspect.343};
ret Inspect.342;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.167 (Inspect.329):
let Inspect.330 : Str = StructAtIndex 0 Inspect.329;
ret Inspect.330;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.281 (Inspect.282, Inspect.280):
let Inspect.356 : Str = CallByName Num.96 Inspect.280;
let Inspect.355 : Str = CallByName Inspect.63 Inspect.282 Inspect.356;
dec Inspect.356;
ret Inspect.355;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.317 : Str = CallByName Inspect.156 Inspect.149 Inspect.306;
ret Inspect.317;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.345 : Str = CallByName Inspect.281 Inspect.149 Inspect.306;
ret Inspect.345;
procedure Inspect.33 (Inspect.152):
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.40 (Inspect.153, Inspect.154, Inspect.155):
inc Inspect.153;
let Inspect.316 : {List I64, {}, {}} = Struct {Inspect.153, Inspect.154, Inspect.155};
let Inspect.315 : {List I64, {}, {}} = CallByName Inspect.30 Inspect.316;
ret Inspect.315;
let Inspect.319 : {List I64, {}, {}} = Struct {Inspect.153, Inspect.154, Inspect.155};
let Inspect.318 : {List I64, {}, {}} = CallByName Inspect.30 Inspect.319;
ret Inspect.318;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : List I64 = CallByName #Derived.0 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName #Derived.4 Inspect.308 Inspect.312;
dec Inspect.312;
ret Inspect.307;
let Inspect.315 : List I64 = CallByName #Derived.0 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName #Derived.4 Inspect.311 Inspect.315;
dec Inspect.315;
ret Inspect.310;
procedure Inspect.57 (Inspect.277):
let Inspect.348 : I64 = CallByName Inspect.30 Inspect.277;
ret Inspect.348;
procedure Inspect.57 (Inspect.280):
let Inspect.351 : I64 = CallByName Inspect.30 Inspect.280;
ret Inspect.351;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.323;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.326 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.326;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure List.100 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12):
joinpoint List.668 List.174 List.175 List.176 List.177 List.178:

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

@ -30,130 +30,166 @@ procedure Bool.1 ():
let Bool.26 : Int1 = false;
ret Bool.26;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.28 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.28;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.29 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.29;
procedure Bool.2 ():
let Bool.25 : Int1 = true;
ret Bool.25;
procedure Inspect.229 (Inspect.230, Inspect.228):
let Inspect.352 : Str = "{";
let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.352;
dec Inspect.352;
let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
dec Inspect.328;
let Inspect.325 : {} = Struct {};
let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
let Inspect.321 : Str = "}";
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
dec Inspect.321;
ret Inspect.319;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.27 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.27;
procedure Inspect.229 (Inspect.230, Inspect.228):
let Inspect.392 : Str = "{";
let Inspect.368 : Str = CallByName Inspect.63 Inspect.230 Inspect.392;
dec Inspect.392;
let Inspect.364 : {Str, Int1} = CallByName Inspect.231 Inspect.368 Inspect.228;
dec Inspect.368;
let Inspect.365 : {} = Struct {};
let Inspect.360 : Str = CallByName Inspect.243 Inspect.364;
let Inspect.361 : Str = "}";
let Inspect.359 : Str = CallByName Inspect.63 Inspect.360 Inspect.361;
dec Inspect.361;
ret Inspect.359;
let Inspect.355 : Str = "{";
let Inspect.331 : Str = CallByName Inspect.63 Inspect.230 Inspect.355;
dec Inspect.355;
let Inspect.327 : {Str, Int1} = CallByName Inspect.231 Inspect.331 Inspect.228;
dec Inspect.331;
let Inspect.328 : {} = Struct {};
let Inspect.323 : Str = CallByName Inspect.243 Inspect.327;
let Inspect.324 : Str = "}";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.323 Inspect.324;
dec Inspect.324;
ret Inspect.322;
procedure Inspect.229 (Inspect.230, Inspect.228):
let Inspect.395 : Str = "{";
let Inspect.371 : Str = CallByName Inspect.63 Inspect.230 Inspect.395;
dec Inspect.395;
let Inspect.367 : {Str, Int1} = CallByName Inspect.231 Inspect.371 Inspect.228;
dec Inspect.371;
let Inspect.368 : {} = Struct {};
let Inspect.363 : Str = CallByName Inspect.243 Inspect.367;
let Inspect.364 : Str = "}";
let Inspect.362 : Str = CallByName Inspect.63 Inspect.363 Inspect.364;
dec Inspect.364;
ret Inspect.362;
procedure Inspect.231 (Inspect.232, Inspect.228):
let Inspect.351 : Int1 = CallByName Bool.1;
let Inspect.354 : Int1 = CallByName Bool.1;
inc Inspect.232;
let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.351};
let Inspect.333 : {} = Struct {};
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
ret Inspect.331;
let Inspect.335 : {Str, Int1} = Struct {Inspect.232, Inspect.354};
let Inspect.336 : {} = Struct {};
let Inspect.334 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.335 Inspect.336;
ret Inspect.334;
procedure Inspect.231 (Inspect.232, Inspect.228):
let Inspect.391 : Int1 = CallByName Bool.1;
let Inspect.394 : Int1 = CallByName Bool.1;
inc Inspect.232;
let Inspect.372 : {Str, Int1} = Struct {Inspect.232, Inspect.391};
let Inspect.373 : {} = Struct {};
let Inspect.371 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.372 Inspect.373;
ret Inspect.371;
let Inspect.375 : {Str, Int1} = Struct {Inspect.232, Inspect.394};
let Inspect.376 : {} = Struct {};
let Inspect.374 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.375 Inspect.376;
ret Inspect.374;
procedure Inspect.233 (Inspect.334, Inspect.335):
let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
joinpoint Inspect.349 Inspect.238:
let Inspect.346 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
procedure Inspect.233 (Inspect.337, Inspect.338):
let Inspect.236 : Str = StructAtIndex 0 Inspect.338;
let Inspect.237 : Str = StructAtIndex 1 Inspect.338;
let Inspect.234 : Str = StructAtIndex 0 Inspect.337;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.337;
joinpoint Inspect.352 Inspect.238:
let Inspect.349 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
dec Inspect.236;
let Inspect.347 : Str = ": ";
let Inspect.341 : Str = CallByName Inspect.63 Inspect.346 Inspect.347;
dec Inspect.347;
let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
let Inspect.338 : {} = Struct {};
let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
dec Inspect.337;
ret Inspect.336;
in
if Inspect.235 then
let Inspect.350 : Str = ", ";
let Inspect.348 : Str = CallByName Inspect.63 Inspect.234 Inspect.350;
let Inspect.350 : Str = ": ";
let Inspect.344 : Str = CallByName Inspect.63 Inspect.349 Inspect.350;
dec Inspect.350;
jump Inspect.349 Inspect.348;
else
jump Inspect.349 Inspect.234;
procedure Inspect.233 (Inspect.334, Inspect.335):
let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
joinpoint Inspect.389 Inspect.238:
let Inspect.386 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
dec Inspect.236;
let Inspect.387 : Str = ": ";
let Inspect.381 : Str = CallByName Inspect.63 Inspect.386 Inspect.387;
dec Inspect.387;
let Inspect.377 : Str = CallByName Inspect.239 Inspect.381 Inspect.237;
dec Inspect.237;
let Inspect.378 : {} = Struct {};
let Inspect.376 : {Str, Int1} = CallByName Inspect.241 Inspect.377;
dec Inspect.377;
ret Inspect.376;
let Inspect.340 : Str = CallByName Inspect.239 Inspect.344 Inspect.237;
let Inspect.341 : {} = Struct {};
let Inspect.339 : {Str, Int1} = CallByName Inspect.241 Inspect.340;
dec Inspect.340;
ret Inspect.339;
in
if Inspect.235 then
let Inspect.390 : Str = ", ";
let Inspect.388 : Str = CallByName Inspect.63 Inspect.234 Inspect.390;
dec Inspect.390;
jump Inspect.389 Inspect.388;
let Inspect.353 : Str = ", ";
let Inspect.351 : Str = CallByName Inspect.63 Inspect.234 Inspect.353;
dec Inspect.353;
jump Inspect.352 Inspect.351;
else
jump Inspect.389 Inspect.234;
jump Inspect.352 Inspect.234;
procedure Inspect.233 (Inspect.337, Inspect.338):
let Inspect.236 : Str = StructAtIndex 0 Inspect.338;
let Inspect.237 : Str = StructAtIndex 1 Inspect.338;
let Inspect.234 : Str = StructAtIndex 0 Inspect.337;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.337;
joinpoint Inspect.392 Inspect.238:
let Inspect.389 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
dec Inspect.236;
let Inspect.390 : Str = ": ";
let Inspect.384 : Str = CallByName Inspect.63 Inspect.389 Inspect.390;
dec Inspect.390;
let Inspect.380 : Str = CallByName Inspect.239 Inspect.384 Inspect.237;
let Inspect.381 : {} = Struct {};
let Inspect.379 : {Str, Int1} = CallByName Inspect.241 Inspect.380;
dec Inspect.380;
ret Inspect.379;
in
if Inspect.235 then
let Inspect.393 : Str = ", ";
let Inspect.391 : Str = CallByName Inspect.63 Inspect.234 Inspect.393;
dec Inspect.393;
jump Inspect.392 Inspect.391;
else
jump Inspect.392 Inspect.234;
procedure Inspect.239 (Inspect.240, Inspect.237):
let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.344;
let Inspect.347 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.347;
procedure Inspect.239 (Inspect.240, Inspect.237):
let Inspect.384 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.384;
let Inspect.387 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.387;
procedure Inspect.241 (Inspect.242):
let Inspect.380 : Int1 = CallByName Bool.2;
let Inspect.383 : Int1 = CallByName Bool.2;
inc Inspect.242;
let Inspect.379 : {Str, Int1} = Struct {Inspect.242, Inspect.380};
ret Inspect.379;
let Inspect.382 : {Str, Int1} = Struct {Inspect.242, Inspect.383};
ret Inspect.382;
procedure Inspect.243 (Inspect.326):
let Inspect.367 : Str = StructAtIndex 0 Inspect.326;
ret Inspect.367;
procedure Inspect.243 (Inspect.329):
let Inspect.370 : Str = StructAtIndex 0 Inspect.329;
ret Inspect.370;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.401 : Str = "\"";
let Inspect.400 : Str = CallByName Inspect.63 Inspect.251 Inspect.401;
dec Inspect.401;
let Inspect.398 : Str = CallByName Inspect.63 Inspect.400 Inspect.249;
let Inspect.399 : Str = "\"";
let Inspect.397 : Str = CallByName Inspect.63 Inspect.398 Inspect.399;
dec Inspect.399;
ret Inspect.397;
let Inspect.418 : Str = "\"";
let Inspect.403 : Str = CallByName Inspect.63 Inspect.251 Inspect.418;
dec Inspect.418;
let Inspect.401 : Str = CallByName Inspect.252 Inspect.403 Inspect.249;
let Inspect.402 : Str = "\"";
let Inspect.400 : Str = CallByName Inspect.63 Inspect.401 Inspect.402;
dec Inspect.402;
ret Inspect.400;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.416 : Str = "\u{feff}";
let Inspect.417 : Str = "\\u(feff)";
let Inspect.413 : Str = CallByName Str.45 Inspect.249 Inspect.416 Inspect.417;
dec Inspect.416;
dec Inspect.417;
let Inspect.414 : Str = "\u{200b}";
let Inspect.415 : Str = "\\u(200b)";
let Inspect.410 : Str = CallByName Str.45 Inspect.413 Inspect.414 Inspect.415;
dec Inspect.414;
dec Inspect.415;
let Inspect.411 : Str = "\u{200c}";
let Inspect.412 : Str = "\\u(200c)";
let Inspect.407 : Str = CallByName Str.45 Inspect.410 Inspect.411 Inspect.412;
dec Inspect.412;
dec Inspect.411;
let Inspect.408 : Str = "\u{200d}";
let Inspect.409 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.407 Inspect.408 Inspect.409;
dec Inspect.409;
dec Inspect.408;
let Inspect.406 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.406;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
@ -170,58 +206,58 @@ procedure Inspect.30 (Inspect.147):
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
ret Inspect.314;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.317 : Str = CallByName Inspect.229 Inspect.149 Inspect.306;
ret Inspect.317;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.345 : Str = CallByName #Derived.6 Inspect.149 Inspect.303;
ret Inspect.345;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.348 : Str = CallByName #Derived.6 Inspect.149 Inspect.306;
ret Inspect.348;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.354 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
ret Inspect.354;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.357 : Str = CallByName Inspect.229 Inspect.149 Inspect.306;
ret Inspect.357;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.385 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
ret Inspect.385;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.388 : Str = CallByName Inspect.250 Inspect.149 Inspect.306;
ret Inspect.388;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.45 (Inspect.228):
let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.315;
procedure Inspect.45 (Inspect.228):
let Inspect.355 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.355;
procedure Inspect.47 (Inspect.249):
let Inspect.393 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.393;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : Str = CallByName #Derived.0 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.363 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.363;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.45 (Inspect.228):
let Inspect.318 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.318;
procedure List.100 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33, #Derived_gen.34):
procedure Inspect.45 (Inspect.228):
let Inspect.358 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.358;
procedure Inspect.47 (Inspect.249):
let Inspect.396 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.396;
procedure Inspect.5 (Inspect.150):
let Inspect.315 : Str = CallByName #Derived.0 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName #Derived.2 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.366 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.366;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure List.100 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28):
joinpoint List.668 List.174 List.175 List.176 List.177 List.178:
let List.670 : Int1 = CallByName Num.22 List.177 List.178;
if List.670 then
@ -235,10 +271,10 @@ procedure List.100 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_
dec List.174;
ret List.175;
in
inc #Derived_gen.30;
jump List.668 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
inc #Derived_gen.24;
jump List.668 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
procedure List.100 (#Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47):
procedure List.100 (#Derived_gen.54, #Derived_gen.55, #Derived_gen.56, #Derived_gen.57, #Derived_gen.58):
joinpoint List.680 List.174 List.175 List.176 List.177 List.178:
let List.682 : Int1 = CallByName Num.22 List.177 List.178;
if List.682 then
@ -252,8 +288,8 @@ procedure List.100 (#Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_
dec List.174;
ret List.175;
in
inc #Derived_gen.43;
jump List.680 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47;
inc #Derived_gen.54;
jump List.680 #Derived_gen.54 #Derived_gen.55 #Derived_gen.56 #Derived_gen.57 #Derived_gen.58;
procedure List.18 (List.171, List.172, List.173):
let List.666 : U64 = 0i64;
@ -283,18 +319,211 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.687 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.687;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.290 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.290;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.286;
let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.297;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.294 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.294;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.291 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.291;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.285;
let Num.296 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.296;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.293 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.293;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.295 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.295;
procedure Str.20 (#Attr.2):
let Str.314 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.314;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.247;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.304 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.304;
procedure Str.36 (#Attr.2):
let Str.267 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.267;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.265 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.265;
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;
else
dec Str.112;
let Str.273 : {} = Struct {};
let Str.272 : [C {}, C {Str, Str}] = TagId(0) Str.273;
ret Str.272;
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;
else
dec Str.342;
ret Str.91;
procedure Str.56 (#Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_gen.32):
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;
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;
in
inc #Derived_gen.31;
inc #Derived_gen.32;
jump Str.251 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32;
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.58 (#Derived_gen.49, #Derived_gen.50, #Derived_gen.51, #Derived_gen.52):
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;
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;
else
dec Str.127;
dec Str.126;
let Str.280 : [C , C U64] = TagId(0) ;
ret Str.280;
in
inc #Derived_gen.49;
inc #Derived_gen.50;
jump Str.279 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52;
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;
else
ret Str.153;
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.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;
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;
procedure Test.0 ():
let Test.4 : Str = "bar";
let Test.1 : Str = CallByName Inspect.33 Test.4;

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

@ -26,78 +26,78 @@ procedure Bool.2 ():
ret Bool.23;
procedure Inspect.229 (Inspect.230, Inspect.228):
let Inspect.353 : Str = "{";
let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.353;
dec Inspect.353;
let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
dec Inspect.328;
let Inspect.325 : {} = Struct {};
let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
let Inspect.321 : Str = "}";
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
dec Inspect.321;
ret Inspect.319;
let Inspect.356 : Str = "{";
let Inspect.331 : Str = CallByName Inspect.63 Inspect.230 Inspect.356;
dec Inspect.356;
let Inspect.327 : {Str, Int1} = CallByName Inspect.231 Inspect.331 Inspect.228;
dec Inspect.331;
let Inspect.328 : {} = Struct {};
let Inspect.323 : Str = CallByName Inspect.243 Inspect.327;
let Inspect.324 : Str = "}";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.323 Inspect.324;
dec Inspect.324;
ret Inspect.322;
procedure Inspect.231 (Inspect.232, Inspect.228):
let Inspect.352 : Int1 = CallByName Bool.1;
let Inspect.355 : Int1 = CallByName Bool.1;
inc Inspect.232;
let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.352};
let Inspect.333 : {} = Struct {};
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
ret Inspect.331;
let Inspect.335 : {Str, Int1} = Struct {Inspect.232, Inspect.355};
let Inspect.336 : {} = Struct {};
let Inspect.334 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.335 Inspect.336;
ret Inspect.334;
procedure Inspect.233 (Inspect.334, Inspect.335):
let Inspect.237 : [C I64, C Decimal] = StructAtIndex 0 Inspect.335;
let Inspect.236 : Str = StructAtIndex 1 Inspect.335;
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
joinpoint Inspect.350 Inspect.238:
let Inspect.347 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
procedure Inspect.233 (Inspect.337, Inspect.338):
let Inspect.237 : [C I64, C Decimal] = StructAtIndex 0 Inspect.338;
let Inspect.236 : Str = StructAtIndex 1 Inspect.338;
let Inspect.234 : Str = StructAtIndex 0 Inspect.337;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.337;
joinpoint Inspect.353 Inspect.238:
let Inspect.350 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
dec Inspect.236;
let Inspect.348 : Str = ": ";
let Inspect.341 : Str = CallByName Inspect.63 Inspect.347 Inspect.348;
dec Inspect.348;
let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
let Inspect.338 : {} = Struct {};
let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
dec Inspect.337;
ret Inspect.336;
let Inspect.351 : Str = ": ";
let Inspect.344 : Str = CallByName Inspect.63 Inspect.350 Inspect.351;
dec Inspect.351;
let Inspect.340 : Str = CallByName Inspect.239 Inspect.344 Inspect.237;
let Inspect.341 : {} = Struct {};
let Inspect.339 : {Str, Int1} = CallByName Inspect.241 Inspect.340;
dec Inspect.340;
ret Inspect.339;
in
if Inspect.235 then
let Inspect.351 : Str = ", ";
let Inspect.349 : Str = CallByName Inspect.63 Inspect.234 Inspect.351;
dec Inspect.351;
jump Inspect.350 Inspect.349;
let Inspect.354 : Str = ", ";
let Inspect.352 : Str = CallByName Inspect.63 Inspect.234 Inspect.354;
dec Inspect.354;
jump Inspect.353 Inspect.352;
else
jump Inspect.350 Inspect.234;
jump Inspect.353 Inspect.234;
procedure Inspect.239 (Inspect.240, Inspect.237):
let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.344;
let Inspect.347 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.347;
procedure Inspect.241 (Inspect.242):
let Inspect.340 : Int1 = CallByName Bool.2;
let Inspect.343 : Int1 = CallByName Bool.2;
inc Inspect.242;
let Inspect.339 : {Str, Int1} = Struct {Inspect.242, Inspect.340};
ret Inspect.339;
let Inspect.342 : {Str, Int1} = Struct {Inspect.242, Inspect.343};
ret Inspect.342;
procedure Inspect.243 (Inspect.326):
let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
ret Inspect.327;
procedure Inspect.243 (Inspect.329):
let Inspect.330 : Str = StructAtIndex 0 Inspect.329;
ret Inspect.330;
procedure Inspect.278 (Inspect.279, #Attr.12):
let Inspect.366 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.365 : Str = CallByName Num.96 Inspect.366;
let Inspect.364 : Str = CallByName Inspect.63 Inspect.279 Inspect.365;
dec Inspect.365;
ret Inspect.364;
procedure Inspect.281 (Inspect.282, #Attr.12):
let Inspect.369 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.368 : Str = CallByName Num.96 Inspect.369;
let Inspect.367 : Str = CallByName Inspect.63 Inspect.282 Inspect.368;
dec Inspect.368;
ret Inspect.367;
procedure Inspect.293 (Inspect.294, #Attr.12):
let Inspect.360 : Decimal = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.359 : Str = CallByName Num.96 Inspect.360;
let Inspect.358 : Str = CallByName Inspect.63 Inspect.294 Inspect.359;
dec Inspect.359;
ret Inspect.358;
procedure Inspect.296 (Inspect.297, #Attr.12):
let Inspect.363 : Decimal = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.362 : Str = CallByName Num.96 Inspect.363;
let Inspect.361 : Str = CallByName Inspect.63 Inspect.297 Inspect.362;
dec Inspect.362;
ret Inspect.361;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
@ -108,58 +108,58 @@ procedure Inspect.30 (Inspect.147):
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
ret Inspect.314;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.317 : Str = CallByName Inspect.229 Inspect.149 Inspect.306;
ret Inspect.317;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.346 : U8 = GetTagId Inspect.303;
switch Inspect.346:
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.349 : U8 = GetTagId Inspect.306;
switch Inspect.349:
case 0:
let Inspect.345 : Str = CallByName Inspect.278 Inspect.149 Inspect.303;
ret Inspect.345;
let Inspect.348 : Str = CallByName Inspect.281 Inspect.149 Inspect.306;
ret Inspect.348;
default:
let Inspect.345 : Str = CallByName Inspect.293 Inspect.149 Inspect.303;
ret Inspect.345;
let Inspect.348 : Str = CallByName Inspect.296 Inspect.149 Inspect.306;
ret Inspect.348;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.45 (Inspect.228):
let Inspect.315 : List {[C I64, C Decimal], Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.315;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : {Decimal, I64} = CallByName #Derived.0 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.57 (Inspect.277):
let Inspect.362 : [C I64, C Decimal] = TagId(0) Inspect.277;
let Inspect.361 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.362;
ret Inspect.361;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.62 (Inspect.292):
let Inspect.355 : [C I64, C Decimal] = TagId(1) Inspect.292;
let Inspect.354 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.355;
ret Inspect.354;
procedure Inspect.45 (Inspect.228):
let Inspect.318 : List {[C I64, C Decimal], Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.318;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.323;
procedure Inspect.5 (Inspect.150):
let Inspect.315 : {Decimal, I64} = CallByName #Derived.0 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName #Derived.2 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.57 (Inspect.280):
let Inspect.365 : [C I64, C Decimal] = TagId(0) Inspect.280;
let Inspect.364 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.365;
ret Inspect.364;
procedure Inspect.62 (Inspect.295):
let Inspect.358 : [C I64, C Decimal] = TagId(1) Inspect.295;
let Inspect.357 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.358;
ret Inspect.357;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.326 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.326;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure List.100 (#Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
joinpoint List.668 List.174 List.175 List.176 List.177 List.178:

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

@ -16,80 +16,116 @@ procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.27 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.27;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.25;
procedure Inspect.229 (Inspect.230, Inspect.228):
let Inspect.352 : Str = "{";
let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.352;
dec Inspect.352;
let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
dec Inspect.328;
let Inspect.325 : {} = Struct {};
let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
let Inspect.321 : Str = "}";
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
dec Inspect.321;
ret Inspect.319;
let Inspect.355 : Str = "{";
let Inspect.331 : Str = CallByName Inspect.63 Inspect.230 Inspect.355;
dec Inspect.355;
let Inspect.327 : {Str, Int1} = CallByName Inspect.231 Inspect.331 Inspect.228;
dec Inspect.331;
let Inspect.328 : {} = Struct {};
let Inspect.323 : Str = CallByName Inspect.243 Inspect.327;
let Inspect.324 : Str = "}";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.323 Inspect.324;
dec Inspect.324;
ret Inspect.322;
procedure Inspect.231 (Inspect.232, Inspect.228):
let Inspect.351 : Int1 = CallByName Bool.1;
let Inspect.354 : Int1 = CallByName Bool.1;
inc Inspect.232;
let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.351};
let Inspect.333 : {} = Struct {};
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
ret Inspect.331;
let Inspect.335 : {Str, Int1} = Struct {Inspect.232, Inspect.354};
let Inspect.336 : {} = Struct {};
let Inspect.334 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.335 Inspect.336;
ret Inspect.334;
procedure Inspect.233 (Inspect.334, Inspect.335):
let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
joinpoint Inspect.349 Inspect.238:
let Inspect.346 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
procedure Inspect.233 (Inspect.337, Inspect.338):
let Inspect.236 : Str = StructAtIndex 0 Inspect.338;
let Inspect.237 : Str = StructAtIndex 1 Inspect.338;
let Inspect.234 : Str = StructAtIndex 0 Inspect.337;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.337;
joinpoint Inspect.352 Inspect.238:
let Inspect.349 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
dec Inspect.236;
let Inspect.347 : Str = ": ";
let Inspect.341 : Str = CallByName Inspect.63 Inspect.346 Inspect.347;
dec Inspect.347;
let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
dec Inspect.237;
let Inspect.338 : {} = Struct {};
let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
dec Inspect.337;
ret Inspect.336;
let Inspect.350 : Str = ": ";
let Inspect.344 : Str = CallByName Inspect.63 Inspect.349 Inspect.350;
dec Inspect.350;
let Inspect.340 : Str = CallByName Inspect.239 Inspect.344 Inspect.237;
let Inspect.341 : {} = Struct {};
let Inspect.339 : {Str, Int1} = CallByName Inspect.241 Inspect.340;
dec Inspect.340;
ret Inspect.339;
in
if Inspect.235 then
let Inspect.350 : Str = ", ";
let Inspect.348 : Str = CallByName Inspect.63 Inspect.234 Inspect.350;
dec Inspect.350;
jump Inspect.349 Inspect.348;
let Inspect.353 : Str = ", ";
let Inspect.351 : Str = CallByName Inspect.63 Inspect.234 Inspect.353;
dec Inspect.353;
jump Inspect.352 Inspect.351;
else
jump Inspect.349 Inspect.234;
jump Inspect.352 Inspect.234;
procedure Inspect.239 (Inspect.240, Inspect.237):
let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.344;
let Inspect.347 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.347;
procedure Inspect.241 (Inspect.242):
let Inspect.340 : Int1 = CallByName Bool.2;
let Inspect.343 : Int1 = CallByName Bool.2;
inc Inspect.242;
let Inspect.339 : {Str, Int1} = Struct {Inspect.242, Inspect.340};
ret Inspect.339;
let Inspect.342 : {Str, Int1} = Struct {Inspect.242, Inspect.343};
ret Inspect.342;
procedure Inspect.243 (Inspect.326):
let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
ret Inspect.327;
procedure Inspect.243 (Inspect.329):
let Inspect.330 : Str = StructAtIndex 0 Inspect.329;
ret Inspect.330;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.361 : Str = "\"";
let Inspect.360 : Str = CallByName Inspect.63 Inspect.251 Inspect.361;
dec Inspect.361;
let Inspect.358 : Str = CallByName Inspect.63 Inspect.360 Inspect.249;
let Inspect.359 : Str = "\"";
let Inspect.357 : Str = CallByName Inspect.63 Inspect.358 Inspect.359;
dec Inspect.359;
ret Inspect.357;
let Inspect.378 : Str = "\"";
let Inspect.363 : Str = CallByName Inspect.63 Inspect.251 Inspect.378;
dec Inspect.378;
let Inspect.361 : Str = CallByName Inspect.252 Inspect.363 Inspect.249;
let Inspect.362 : Str = "\"";
let Inspect.360 : Str = CallByName Inspect.63 Inspect.361 Inspect.362;
dec Inspect.362;
ret Inspect.360;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.376 : Str = "\u{feff}";
let Inspect.377 : Str = "\\u(feff)";
let Inspect.373 : Str = CallByName Str.45 Inspect.249 Inspect.376 Inspect.377;
dec Inspect.377;
dec Inspect.376;
let Inspect.374 : Str = "\u{200b}";
let Inspect.375 : Str = "\\u(200b)";
let Inspect.370 : Str = CallByName Str.45 Inspect.373 Inspect.374 Inspect.375;
dec Inspect.374;
dec Inspect.375;
let Inspect.371 : Str = "\u{200c}";
let Inspect.372 : Str = "\\u(200c)";
let Inspect.367 : Str = CallByName Str.45 Inspect.370 Inspect.371 Inspect.372;
dec Inspect.372;
dec Inspect.371;
let Inspect.368 : Str = "\u{200d}";
let Inspect.369 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.367 Inspect.368 Inspect.369;
dec Inspect.369;
dec Inspect.368;
let Inspect.366 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.366;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
@ -100,46 +136,46 @@ procedure Inspect.30 (Inspect.147):
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
ret Inspect.314;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.317 : Str = CallByName Inspect.229 Inspect.149 Inspect.306;
ret Inspect.317;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.345 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
ret Inspect.345;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.348 : Str = CallByName Inspect.250 Inspect.149 Inspect.306;
ret Inspect.348;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.45 (Inspect.228):
let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.315;
procedure Inspect.47 (Inspect.249):
let Inspect.353 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.353;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : Str = CallByName #Derived.0 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.323;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.45 (Inspect.228):
let Inspect.318 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.318;
procedure List.100 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
procedure Inspect.47 (Inspect.249):
let Inspect.356 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.356;
procedure Inspect.5 (Inspect.150):
let Inspect.315 : Str = CallByName #Derived.0 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName #Derived.2 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.326 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.326;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure List.100 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
joinpoint List.668 List.174 List.175 List.176 List.177 List.178:
let List.670 : Int1 = CallByName Num.22 List.177 List.178;
if List.670 then
@ -153,8 +189,8 @@ procedure List.100 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_
dec List.174;
ret List.175;
in
inc #Derived_gen.12;
jump List.668 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
inc #Derived_gen.14;
jump List.668 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
procedure List.18 (List.171, List.172, List.173):
let List.666 : U64 = 0i64;
@ -170,18 +206,211 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.675 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.675;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.288;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.284;
let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.295;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.292;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.289;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.283;
let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.294;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
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;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
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;
else
dec Str.341;
ret Str.91;
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;
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;
in
inc #Derived_gen.30;
inc #Derived_gen.31;
jump Str.250 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31;
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.32, #Derived_gen.33, #Derived_gen.34, #Derived_gen.35):
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.33;
inc #Derived_gen.32;
jump Str.278 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35;
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;
else
ret Str.153;
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.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;
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;
procedure Test.0 ():
let Test.3 : Str = "foo";
let Test.1 : Str = CallByName Inspect.33 Test.3;

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

@ -23,80 +23,116 @@ procedure Bool.1 ():
let Bool.24 : Int1 = false;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.27 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.27;
procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.25;
procedure Inspect.229 (Inspect.230, Inspect.228):
let Inspect.352 : Str = "{";
let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.352;
dec Inspect.352;
let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
dec Inspect.328;
let Inspect.325 : {} = Struct {};
let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
let Inspect.321 : Str = "}";
let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
dec Inspect.321;
ret Inspect.319;
let Inspect.355 : Str = "{";
let Inspect.331 : Str = CallByName Inspect.63 Inspect.230 Inspect.355;
dec Inspect.355;
let Inspect.327 : {Str, Int1} = CallByName Inspect.231 Inspect.331 Inspect.228;
dec Inspect.331;
let Inspect.328 : {} = Struct {};
let Inspect.323 : Str = CallByName Inspect.243 Inspect.327;
let Inspect.324 : Str = "}";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.323 Inspect.324;
dec Inspect.324;
ret Inspect.322;
procedure Inspect.231 (Inspect.232, Inspect.228):
let Inspect.351 : Int1 = CallByName Bool.1;
let Inspect.354 : Int1 = CallByName Bool.1;
inc Inspect.232;
let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.351};
let Inspect.333 : {} = Struct {};
let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
ret Inspect.331;
let Inspect.335 : {Str, Int1} = Struct {Inspect.232, Inspect.354};
let Inspect.336 : {} = Struct {};
let Inspect.334 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.335 Inspect.336;
ret Inspect.334;
procedure Inspect.233 (Inspect.334, Inspect.335):
let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
joinpoint Inspect.349 Inspect.238:
let Inspect.346 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
procedure Inspect.233 (Inspect.337, Inspect.338):
let Inspect.236 : Str = StructAtIndex 0 Inspect.338;
let Inspect.237 : Str = StructAtIndex 1 Inspect.338;
let Inspect.234 : Str = StructAtIndex 0 Inspect.337;
let Inspect.235 : Int1 = StructAtIndex 1 Inspect.337;
joinpoint Inspect.352 Inspect.238:
let Inspect.349 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
dec Inspect.236;
let Inspect.347 : Str = ": ";
let Inspect.341 : Str = CallByName Inspect.63 Inspect.346 Inspect.347;
dec Inspect.347;
let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
dec Inspect.237;
let Inspect.338 : {} = Struct {};
let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
dec Inspect.337;
ret Inspect.336;
let Inspect.350 : Str = ": ";
let Inspect.344 : Str = CallByName Inspect.63 Inspect.349 Inspect.350;
dec Inspect.350;
let Inspect.340 : Str = CallByName Inspect.239 Inspect.344 Inspect.237;
let Inspect.341 : {} = Struct {};
let Inspect.339 : {Str, Int1} = CallByName Inspect.241 Inspect.340;
dec Inspect.340;
ret Inspect.339;
in
if Inspect.235 then
let Inspect.350 : Str = ", ";
let Inspect.348 : Str = CallByName Inspect.63 Inspect.234 Inspect.350;
dec Inspect.350;
jump Inspect.349 Inspect.348;
let Inspect.353 : Str = ", ";
let Inspect.351 : Str = CallByName Inspect.63 Inspect.234 Inspect.353;
dec Inspect.353;
jump Inspect.352 Inspect.351;
else
jump Inspect.349 Inspect.234;
jump Inspect.352 Inspect.234;
procedure Inspect.239 (Inspect.240, Inspect.237):
let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.344;
let Inspect.347 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
ret Inspect.347;
procedure Inspect.241 (Inspect.242):
let Inspect.340 : Int1 = CallByName Bool.2;
let Inspect.343 : Int1 = CallByName Bool.2;
inc Inspect.242;
let Inspect.339 : {Str, Int1} = Struct {Inspect.242, Inspect.340};
ret Inspect.339;
let Inspect.342 : {Str, Int1} = Struct {Inspect.242, Inspect.343};
ret Inspect.342;
procedure Inspect.243 (Inspect.326):
let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
ret Inspect.327;
procedure Inspect.243 (Inspect.329):
let Inspect.330 : Str = StructAtIndex 0 Inspect.329;
ret Inspect.330;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.361 : Str = "\"";
let Inspect.360 : Str = CallByName Inspect.63 Inspect.251 Inspect.361;
dec Inspect.361;
let Inspect.358 : Str = CallByName Inspect.63 Inspect.360 Inspect.249;
let Inspect.359 : Str = "\"";
let Inspect.357 : Str = CallByName Inspect.63 Inspect.358 Inspect.359;
dec Inspect.359;
ret Inspect.357;
let Inspect.378 : Str = "\"";
let Inspect.363 : Str = CallByName Inspect.63 Inspect.251 Inspect.378;
dec Inspect.378;
let Inspect.361 : Str = CallByName Inspect.252 Inspect.363 Inspect.249;
let Inspect.362 : Str = "\"";
let Inspect.360 : Str = CallByName Inspect.63 Inspect.361 Inspect.362;
dec Inspect.362;
ret Inspect.360;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.376 : Str = "\u{feff}";
let Inspect.377 : Str = "\\u(feff)";
let Inspect.373 : Str = CallByName Str.45 Inspect.249 Inspect.376 Inspect.377;
dec Inspect.377;
dec Inspect.376;
let Inspect.374 : Str = "\u{200b}";
let Inspect.375 : Str = "\\u(200b)";
let Inspect.370 : Str = CallByName Str.45 Inspect.373 Inspect.374 Inspect.375;
dec Inspect.374;
dec Inspect.375;
let Inspect.371 : Str = "\u{200c}";
let Inspect.372 : Str = "\\u(200c)";
let Inspect.367 : Str = CallByName Str.45 Inspect.370 Inspect.371 Inspect.372;
dec Inspect.372;
dec Inspect.371;
let Inspect.368 : Str = "\u{200d}";
let Inspect.369 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.367 Inspect.368 Inspect.369;
dec Inspect.369;
dec Inspect.368;
let Inspect.366 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.366;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
@ -107,46 +143,46 @@ procedure Inspect.30 (Inspect.147):
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
ret Inspect.314;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.317 : Str = CallByName Inspect.229 Inspect.149 Inspect.306;
ret Inspect.317;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.345 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
ret Inspect.345;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.348 : Str = CallByName Inspect.250 Inspect.149 Inspect.306;
ret Inspect.348;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.45 (Inspect.228):
let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.315;
procedure Inspect.47 (Inspect.249):
let Inspect.362 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.362;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : {Str, Str} = CallByName #Derived.0 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.323;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.45 (Inspect.228):
let Inspect.318 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
ret Inspect.318;
procedure List.100 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20):
procedure Inspect.47 (Inspect.249):
let Inspect.379 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.379;
procedure Inspect.5 (Inspect.150):
let Inspect.315 : {Str, Str} = CallByName #Derived.0 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName #Derived.2 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.326 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.326;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure List.100 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
joinpoint List.668 List.174 List.175 List.176 List.177 List.178:
let List.670 : Int1 = CallByName Num.22 List.177 List.178;
if List.670 then
@ -160,8 +196,8 @@ procedure List.100 (#Derived_gen.16, #Derived_gen.17, #Derived_gen.18, #Derived_
dec List.174;
ret List.175;
in
inc #Derived_gen.16;
jump List.668 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20;
inc #Derived_gen.18;
jump List.668 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
procedure List.18 (List.171, List.172, List.173):
let List.666 : U64 = 0i64;
@ -177,18 +213,211 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.675 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.675;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.288;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.284;
let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.295;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.292;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.289;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.283;
let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.294;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
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;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
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;
else
dec Str.341;
ret Str.91;
procedure Str.56 (#Derived_gen.32, #Derived_gen.33, #Derived_gen.34, #Derived_gen.35):
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;
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;
in
inc #Derived_gen.34;
inc #Derived_gen.35;
jump Str.250 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35;
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.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39):
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.37;
inc #Derived_gen.36;
jump Str.278 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
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;
else
ret Str.153;
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.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;
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;
procedure Test.0 ():
let Test.3 : Str = "foo";
let Test.4 : Str = "bar";

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

@ -1,48 +1,285 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.25 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.25;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.323 : Str = "\"";
let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
dec Inspect.323;
let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
let Inspect.319 : Str = "\"";
let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
dec Inspect.319;
ret Inspect.317;
let Inspect.340 : Str = "\"";
let Inspect.325 : Str = CallByName Inspect.63 Inspect.251 Inspect.340;
dec Inspect.340;
let Inspect.321 : Str = CallByName Inspect.252 Inspect.325 Inspect.249;
let Inspect.322 : Str = "\"";
let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
dec Inspect.322;
ret Inspect.320;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.338 : Str = "\u{feff}";
let Inspect.339 : Str = "\\u(feff)";
let Inspect.335 : Str = CallByName Str.45 Inspect.249 Inspect.338 Inspect.339;
dec Inspect.338;
dec Inspect.339;
let Inspect.336 : Str = "\u{200b}";
let Inspect.337 : Str = "\\u(200b)";
let Inspect.332 : Str = CallByName Str.45 Inspect.335 Inspect.336 Inspect.337;
dec Inspect.337;
dec Inspect.336;
let Inspect.333 : Str = "\u{200c}";
let Inspect.334 : Str = "\\u(200c)";
let Inspect.329 : Str = CallByName Str.45 Inspect.332 Inspect.333 Inspect.334;
dec Inspect.334;
dec Inspect.333;
let Inspect.330 : Str = "\u{200d}";
let Inspect.331 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.329 Inspect.330 Inspect.331;
dec Inspect.330;
dec Inspect.331;
let Inspect.328 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.328;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.47 (Inspect.249):
let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.313;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
dec Inspect.312;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.321;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.47 (Inspect.249):
let Inspect.316 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.316;
procedure Inspect.5 (Inspect.150):
let Inspect.315 : Str = CallByName Inspect.47 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName Inspect.250 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.324 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.324;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.288;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.290;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.292;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.289;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.286;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
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;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
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;
else
dec Str.341;
ret Str.91;
procedure Str.56 (#Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
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;
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;
in
inc #Derived_gen.8;
inc #Derived_gen.9;
jump Str.250 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
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.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
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.3;
inc #Derived_gen.2;
jump Str.278 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
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;
else
ret Str.153;
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.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;
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;
procedure Test.0 ():
let Test.2 : Str = "abc";
let Test.1 : Str = CallByName Inspect.33 Test.2;

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

@ -16,55 +16,88 @@ procedure #Derived.3 (#Derived.4, #Derived.1):
jump #Derived_gen.5 #Derived_gen.6;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.204 (Inspect.205, #Attr.12):
let Inspect.346 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.345 : Str = CallByName Inspect.63 Inspect.205 Inspect.346;
dec Inspect.346;
ret Inspect.345;
let Inspect.349 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.348 : Str = CallByName Inspect.63 Inspect.205 Inspect.349;
dec Inspect.349;
ret Inspect.348;
procedure Inspect.206 (Inspect.207, #Attr.12):
let Inspect.340 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Inspect.339 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.338 : Str = "(";
let Inspect.337 : Str = CallByName Inspect.63 Inspect.207 Inspect.338;
dec Inspect.338;
let Inspect.325 : Str = CallByName Inspect.63 Inspect.337 Inspect.339;
dec Inspect.339;
let Inspect.321 : Str = CallByName Inspect.208 Inspect.325 Inspect.340;
dec Inspect.340;
let Inspect.322 : Str = ")";
let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
dec Inspect.322;
ret Inspect.320;
let Inspect.343 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Inspect.342 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.341 : Str = "(";
let Inspect.340 : Str = CallByName Inspect.63 Inspect.207 Inspect.341;
dec Inspect.341;
let Inspect.328 : Str = CallByName Inspect.63 Inspect.340 Inspect.342;
dec Inspect.342;
let Inspect.324 : Str = CallByName Inspect.208 Inspect.328 Inspect.343;
dec Inspect.343;
let Inspect.325 : Str = ")";
let Inspect.323 : Str = CallByName Inspect.63 Inspect.324 Inspect.325;
dec Inspect.325;
ret Inspect.323;
procedure Inspect.208 (Inspect.209, Inspect.203):
let Inspect.329 : {} = Struct {};
let Inspect.328 : Str = CallByName List.18 Inspect.203 Inspect.209 Inspect.329;
ret Inspect.328;
let Inspect.332 : {} = Struct {};
let Inspect.331 : Str = CallByName List.18 Inspect.203 Inspect.209 Inspect.332;
ret Inspect.331;
procedure Inspect.210 (Inspect.211, Inspect.212):
let Inspect.336 : Str = " ";
let Inspect.331 : Str = CallByName Inspect.63 Inspect.211 Inspect.336;
dec Inspect.336;
let Inspect.330 : Str = CallByName Inspect.213 Inspect.331 Inspect.212;
ret Inspect.330;
let Inspect.339 : Str = " ";
let Inspect.334 : Str = CallByName Inspect.63 Inspect.211 Inspect.339;
dec Inspect.339;
let Inspect.333 : Str = CallByName Inspect.213 Inspect.334 Inspect.212;
ret Inspect.333;
procedure Inspect.213 (Inspect.214, Inspect.212):
let Inspect.334 : Str = CallByName Inspect.31 Inspect.212 Inspect.214;
ret Inspect.334;
let Inspect.337 : Str = CallByName Inspect.31 Inspect.212 Inspect.214;
ret Inspect.337;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.355 : Str = "\"";
let Inspect.354 : Str = CallByName Inspect.63 Inspect.251 Inspect.355;
dec Inspect.355;
let Inspect.352 : Str = CallByName Inspect.63 Inspect.354 Inspect.249;
let Inspect.353 : Str = "\"";
let Inspect.351 : Str = CallByName Inspect.63 Inspect.352 Inspect.353;
dec Inspect.353;
ret Inspect.351;
let Inspect.372 : Str = "\"";
let Inspect.357 : Str = CallByName Inspect.63 Inspect.251 Inspect.372;
dec Inspect.372;
let Inspect.355 : Str = CallByName Inspect.252 Inspect.357 Inspect.249;
let Inspect.356 : Str = "\"";
let Inspect.354 : Str = CallByName Inspect.63 Inspect.355 Inspect.356;
dec Inspect.356;
ret Inspect.354;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.370 : Str = "\u{feff}";
let Inspect.371 : Str = "\\u(feff)";
let Inspect.367 : Str = CallByName Str.45 Inspect.249 Inspect.370 Inspect.371;
dec Inspect.370;
dec Inspect.371;
let Inspect.368 : Str = "\u{200b}";
let Inspect.369 : Str = "\\u(200b)";
let Inspect.364 : Str = CallByName Str.45 Inspect.367 Inspect.368 Inspect.369;
dec Inspect.369;
dec Inspect.368;
let Inspect.365 : Str = "\u{200c}";
let Inspect.366 : Str = "\\u(200c)";
let Inspect.361 : Str = CallByName Str.45 Inspect.364 Inspect.365 Inspect.366;
dec Inspect.365;
dec Inspect.366;
let Inspect.362 : Str = "\u{200d}";
let Inspect.363 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.361 Inspect.362 Inspect.363;
dec Inspect.362;
dec Inspect.363;
let Inspect.360 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.360;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
@ -75,62 +108,62 @@ procedure Inspect.30 (Inspect.147):
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.315 : U8 = GetTagId Inspect.303;
switch Inspect.315:
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.318 : U8 = GetTagId Inspect.306;
switch Inspect.318:
case 0:
let Inspect.314 : Str = CallByName Inspect.204 Inspect.149 Inspect.303;
ret Inspect.314;
let Inspect.317 : Str = CallByName Inspect.204 Inspect.149 Inspect.306;
ret Inspect.317;
default:
let Inspect.314 : Str = CallByName Inspect.206 Inspect.149 Inspect.303;
ret Inspect.314;
let Inspect.317 : Str = CallByName Inspect.206 Inspect.149 Inspect.306;
ret Inspect.317;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.335 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
ret Inspect.335;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.338 : Str = CallByName Inspect.250 Inspect.149 Inspect.306;
ret Inspect.338;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.43 (Inspect.202, Inspect.203):
let Inspect.341 : Int1 = CallByName List.1 Inspect.203;
if Inspect.341 then
let Inspect.344 : Int1 = CallByName List.1 Inspect.203;
if Inspect.344 then
inc Inspect.202;
let Inspect.343 : [C Str, C Str List Str] = TagId(0) Inspect.202;
let Inspect.342 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.343;
ret Inspect.342;
let Inspect.346 : [C Str, C Str List Str] = TagId(0) Inspect.202;
let Inspect.345 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.346;
ret Inspect.345;
else
inc Inspect.203;
inc Inspect.202;
let Inspect.317 : [C Str, C Str List Str] = TagId(1) Inspect.202 Inspect.203;
let Inspect.316 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.317;
ret Inspect.316;
let Inspect.320 : [C Str, C Str List Str] = TagId(1) Inspect.202 Inspect.203;
let Inspect.319 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.320;
ret Inspect.319;
procedure Inspect.47 (Inspect.249):
let Inspect.347 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.347;
let Inspect.350 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.350;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : Str = CallByName #Derived.0 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName #Derived.3 Inspect.308 Inspect.312;
ret Inspect.307;
let Inspect.315 : Str = CallByName #Derived.0 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName #Derived.3 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.324 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.324;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.327 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.327;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure List.1 (List.118):
let List.678 : U64 = CallByName List.6 List.118;
@ -138,14 +171,13 @@ procedure List.1 (List.118):
let List.677 : Int1 = CallByName Bool.11 List.678 List.679;
ret List.677;
procedure List.100 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
procedure List.100 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
joinpoint List.668 List.174 List.175 List.176 List.177 List.178:
let List.670 : Int1 = CallByName Num.22 List.177 List.178;
if List.670 then
let List.674 : Str = CallByName List.66 List.174 List.177;
inc List.674;
let List.179 : Str = CallByName Inspect.210 List.175 List.674;
dec List.674;
let List.673 : U64 = 1i64;
let List.672 : U64 = CallByName Num.51 List.177 List.673;
jump List.668 List.174 List.179 List.176 List.672 List.178;
@ -153,8 +185,8 @@ procedure List.100 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_
dec List.174;
ret List.175;
in
inc #Derived_gen.14;
jump List.668 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
inc #Derived_gen.17;
jump List.668 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
procedure List.18 (List.171, List.172, List.173):
let List.666 : U64 = 0i64;
@ -170,18 +202,211 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.675 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.675;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.288;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.284;
let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.295;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.292;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.289;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.283;
let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.294;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
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;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
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;
else
dec Str.341;
ret Str.91;
procedure Str.56 (#Derived_gen.32, #Derived_gen.33, #Derived_gen.34, #Derived_gen.35):
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;
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;
in
inc #Derived_gen.34;
inc #Derived_gen.35;
jump Str.250 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35;
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.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;
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.24;
inc #Derived_gen.25;
jump Str.278 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
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;
else
ret Str.153;
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.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;
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;
procedure Test.0 ():
let Test.4 : Str = "foo";
let Test.3 : Str = CallByName Inspect.33 Test.4;

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

@ -19,55 +19,88 @@ procedure #Derived.4 (#Derived.5, #Derived.1):
jump #Derived_gen.5 #Derived_gen.6;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24;
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.26 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.26;
procedure Bool.3 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel And #Attr.2 #Attr.3;
ret Bool.23;
procedure Inspect.204 (Inspect.205, #Attr.12):
let Inspect.346 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.345 : Str = CallByName Inspect.63 Inspect.205 Inspect.346;
dec Inspect.346;
ret Inspect.345;
let Inspect.349 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Inspect.348 : Str = CallByName Inspect.63 Inspect.205 Inspect.349;
dec Inspect.349;
ret Inspect.348;
procedure Inspect.206 (Inspect.207, #Attr.12):
let Inspect.340 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Inspect.339 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.338 : Str = "(";
let Inspect.337 : Str = CallByName Inspect.63 Inspect.207 Inspect.338;
dec Inspect.338;
let Inspect.325 : Str = CallByName Inspect.63 Inspect.337 Inspect.339;
dec Inspect.339;
let Inspect.321 : Str = CallByName Inspect.208 Inspect.325 Inspect.340;
dec Inspect.340;
let Inspect.322 : Str = ")";
let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
dec Inspect.322;
ret Inspect.320;
let Inspect.343 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Inspect.342 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Inspect.341 : Str = "(";
let Inspect.340 : Str = CallByName Inspect.63 Inspect.207 Inspect.341;
dec Inspect.341;
let Inspect.328 : Str = CallByName Inspect.63 Inspect.340 Inspect.342;
dec Inspect.342;
let Inspect.324 : Str = CallByName Inspect.208 Inspect.328 Inspect.343;
dec Inspect.343;
let Inspect.325 : Str = ")";
let Inspect.323 : Str = CallByName Inspect.63 Inspect.324 Inspect.325;
dec Inspect.325;
ret Inspect.323;
procedure Inspect.208 (Inspect.209, Inspect.203):
let Inspect.329 : {} = Struct {};
let Inspect.328 : Str = CallByName List.18 Inspect.203 Inspect.209 Inspect.329;
ret Inspect.328;
let Inspect.332 : {} = Struct {};
let Inspect.331 : Str = CallByName List.18 Inspect.203 Inspect.209 Inspect.332;
ret Inspect.331;
procedure Inspect.210 (Inspect.211, Inspect.212):
let Inspect.336 : Str = " ";
let Inspect.331 : Str = CallByName Inspect.63 Inspect.211 Inspect.336;
dec Inspect.336;
let Inspect.330 : Str = CallByName Inspect.213 Inspect.331 Inspect.212;
ret Inspect.330;
let Inspect.339 : Str = " ";
let Inspect.334 : Str = CallByName Inspect.63 Inspect.211 Inspect.339;
dec Inspect.339;
let Inspect.333 : Str = CallByName Inspect.213 Inspect.334 Inspect.212;
ret Inspect.333;
procedure Inspect.213 (Inspect.214, Inspect.212):
let Inspect.334 : Str = CallByName Inspect.31 Inspect.212 Inspect.214;
ret Inspect.334;
let Inspect.337 : Str = CallByName Inspect.31 Inspect.212 Inspect.214;
ret Inspect.337;
procedure Inspect.250 (Inspect.251, Inspect.249):
let Inspect.355 : Str = "\"";
let Inspect.354 : Str = CallByName Inspect.63 Inspect.251 Inspect.355;
dec Inspect.355;
let Inspect.352 : Str = CallByName Inspect.63 Inspect.354 Inspect.249;
let Inspect.353 : Str = "\"";
let Inspect.351 : Str = CallByName Inspect.63 Inspect.352 Inspect.353;
dec Inspect.353;
ret Inspect.351;
let Inspect.372 : Str = "\"";
let Inspect.357 : Str = CallByName Inspect.63 Inspect.251 Inspect.372;
dec Inspect.372;
let Inspect.355 : Str = CallByName Inspect.252 Inspect.357 Inspect.249;
let Inspect.356 : Str = "\"";
let Inspect.354 : Str = CallByName Inspect.63 Inspect.355 Inspect.356;
dec Inspect.356;
ret Inspect.354;
procedure Inspect.252 (Inspect.253, Inspect.249):
let Inspect.370 : Str = "\u{feff}";
let Inspect.371 : Str = "\\u(feff)";
let Inspect.367 : Str = CallByName Str.45 Inspect.249 Inspect.370 Inspect.371;
dec Inspect.370;
dec Inspect.371;
let Inspect.368 : Str = "\u{200b}";
let Inspect.369 : Str = "\\u(200b)";
let Inspect.364 : Str = CallByName Str.45 Inspect.367 Inspect.368 Inspect.369;
dec Inspect.369;
dec Inspect.368;
let Inspect.365 : Str = "\u{200c}";
let Inspect.366 : Str = "\\u(200c)";
let Inspect.361 : Str = CallByName Str.45 Inspect.364 Inspect.365 Inspect.366;
dec Inspect.365;
dec Inspect.366;
let Inspect.362 : Str = "\u{200d}";
let Inspect.363 : Str = "\\u(200d)";
let Inspect.254 : Str = CallByName Str.45 Inspect.361 Inspect.362 Inspect.363;
dec Inspect.362;
dec Inspect.363;
let Inspect.360 : Str = CallByName Inspect.63 Inspect.253 Inspect.254;
dec Inspect.254;
ret Inspect.360;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
@ -78,62 +111,62 @@ procedure Inspect.30 (Inspect.147):
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.315 : U8 = GetTagId Inspect.303;
switch Inspect.315:
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.318 : U8 = GetTagId Inspect.306;
switch Inspect.318:
case 0:
let Inspect.314 : Str = CallByName Inspect.204 Inspect.149 Inspect.303;
ret Inspect.314;
let Inspect.317 : Str = CallByName Inspect.204 Inspect.149 Inspect.306;
ret Inspect.317;
default:
let Inspect.314 : Str = CallByName Inspect.206 Inspect.149 Inspect.303;
ret Inspect.314;
let Inspect.317 : Str = CallByName Inspect.206 Inspect.149 Inspect.306;
ret Inspect.317;
procedure Inspect.31 (Inspect.303, Inspect.149):
let Inspect.335 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
ret Inspect.335;
procedure Inspect.31 (Inspect.306, Inspect.149):
let Inspect.338 : Str = CallByName Inspect.250 Inspect.149 Inspect.306;
ret Inspect.338;
procedure Inspect.33 (Inspect.152):
let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
ret Inspect.304;
let Inspect.308 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.307 : Str = CallByName Inspect.64 Inspect.308;
ret Inspect.307;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.43 (Inspect.202, Inspect.203):
let Inspect.341 : Int1 = CallByName List.1 Inspect.203;
if Inspect.341 then
let Inspect.344 : Int1 = CallByName List.1 Inspect.203;
if Inspect.344 then
inc Inspect.202;
let Inspect.343 : [C Str, C Str List Str] = TagId(0) Inspect.202;
let Inspect.342 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.343;
ret Inspect.342;
let Inspect.346 : [C Str, C Str List Str] = TagId(0) Inspect.202;
let Inspect.345 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.346;
ret Inspect.345;
else
inc Inspect.203;
inc Inspect.202;
let Inspect.317 : [C Str, C Str List Str] = TagId(1) Inspect.202 Inspect.203;
let Inspect.316 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.317;
ret Inspect.316;
let Inspect.320 : [C Str, C Str List Str] = TagId(1) Inspect.202 Inspect.203;
let Inspect.319 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.320;
ret Inspect.319;
procedure Inspect.47 (Inspect.249):
let Inspect.356 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.356;
let Inspect.373 : Str = CallByName Inspect.30 Inspect.249;
ret Inspect.373;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : {Str, Str} = CallByName #Derived.0 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName #Derived.4 Inspect.308 Inspect.312;
ret Inspect.307;
let Inspect.315 : {Str, Str} = CallByName #Derived.0 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName #Derived.4 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.324 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.324;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.327 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.327;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure List.1 (List.118):
let List.678 : U64 = CallByName List.6 List.118;
@ -148,7 +181,6 @@ procedure List.100 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_
let List.674 : Str = CallByName List.66 List.174 List.177;
inc List.674;
let List.179 : Str = CallByName Inspect.210 List.175 List.674;
dec List.674;
let List.673 : U64 = 1i64;
let List.672 : U64 = CallByName Num.51 List.177 List.673;
jump List.668 List.174 List.179 List.176 List.672 List.178;
@ -173,18 +205,211 @@ procedure List.66 (#Attr.2, #Attr.3):
let List.675 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.675;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.288;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.284;
let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.295;
procedure Num.23 (#Attr.2, #Attr.3):
let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
ret Num.292;
procedure Num.25 (#Attr.2, #Attr.3):
let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
ret Num.289;
procedure Num.51 (#Attr.2, #Attr.3):
let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.283;
let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
ret Num.294;
procedure Num.53 (#Attr.2, #Attr.3):
let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
ret Num.291;
procedure Num.77 (#Attr.2, #Attr.3):
let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.293;
procedure Str.20 (#Attr.2):
let Str.313 : Str = lowlevel StrWithCapacity #Attr.2;
ret Str.313;
procedure Str.3 (#Attr.2, #Attr.3):
let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
ret Str.246;
procedure Str.35 (#Attr.2, #Attr.3):
let Str.303 : U8 = lowlevel StrGetUnsafe #Attr.2 #Attr.3;
ret Str.303;
procedure Str.36 (#Attr.2):
let Str.266 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
ret Str.266;
procedure Str.37 (#Attr.2, #Attr.3, #Attr.4):
let Str.264 : Str = lowlevel StrSubstringUnsafe #Attr.2 #Attr.3 #Attr.4;
ret Str.264;
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;
else
dec Str.112;
let Str.272 : {} = Struct {};
let Str.271 : [C {}, C {Str, Str}] = TagId(0) Str.272;
ret Str.271;
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;
else
dec Str.341;
ret Str.91;
procedure Str.56 (#Derived_gen.33, #Derived_gen.34, #Derived_gen.35, #Derived_gen.36):
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;
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;
in
inc #Derived_gen.36;
inc #Derived_gen.35;
jump Str.250 #Derived_gen.33 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
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.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;
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.24;
inc #Derived_gen.25;
jump Str.278 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27;
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;
else
ret Str.153;
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.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;
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;
procedure Test.0 ():
let Test.5 : Str = "foo";
let Test.4 : Str = "foo";

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

@ -1,38 +1,38 @@
procedure Inspect.278 (Inspect.279, Inspect.277):
let Inspect.318 : Str = CallByName Num.96 Inspect.277;
let Inspect.317 : Str = CallByName Inspect.63 Inspect.279 Inspect.318;
dec Inspect.318;
ret Inspect.317;
procedure Inspect.281 (Inspect.282, Inspect.280):
let Inspect.321 : Str = CallByName Num.96 Inspect.280;
let Inspect.320 : Str = CallByName Inspect.63 Inspect.282 Inspect.321;
dec Inspect.321;
ret Inspect.320;
procedure Inspect.30 (Inspect.147):
ret Inspect.147;
procedure Inspect.33 (Inspect.152):
let Inspect.322 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.321 : Str = CallByName Inspect.64 Inspect.322;
ret Inspect.321;
let Inspect.325 : Str = CallByName Inspect.5 Inspect.152;
let Inspect.324 : Str = CallByName Inspect.64 Inspect.325;
ret Inspect.324;
procedure Inspect.39 (Inspect.301):
let Inspect.311 : Str = "";
ret Inspect.311;
procedure Inspect.39 (Inspect.304):
let Inspect.314 : Str = "";
ret Inspect.314;
procedure Inspect.5 (Inspect.150):
let Inspect.312 : I64 = CallByName Inspect.57 Inspect.150;
let Inspect.309 : {} = Struct {};
let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
let Inspect.307 : Str = CallByName Inspect.278 Inspect.308 Inspect.312;
ret Inspect.307;
let Inspect.315 : I64 = CallByName Inspect.57 Inspect.150;
let Inspect.312 : {} = Struct {};
let Inspect.311 : Str = CallByName Inspect.39 Inspect.312;
let Inspect.310 : Str = CallByName Inspect.281 Inspect.311 Inspect.315;
ret Inspect.310;
procedure Inspect.57 (Inspect.277):
let Inspect.313 : I64 = CallByName Inspect.30 Inspect.277;
ret Inspect.313;
procedure Inspect.57 (Inspect.280):
let Inspect.316 : I64 = CallByName Inspect.30 Inspect.280;
ret Inspect.316;
procedure Inspect.63 (Inspect.300, Inspect.296):
let Inspect.320 : Str = CallByName Str.3 Inspect.300 Inspect.296;
ret Inspect.320;
procedure Inspect.63 (Inspect.303, Inspect.299):
let Inspect.323 : Str = CallByName Str.3 Inspect.303 Inspect.299;
ret Inspect.323;
procedure Inspect.64 (Inspect.302):
ret Inspect.302;
procedure Inspect.64 (Inspect.305):
ret Inspect.305;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;