Merge remote-tracking branch 'remote/main' into str-dropping

crates/compiler/test_mono/generated/as_pattern_in_closure_arg.txt

@@ -0,0 +1,31 @@
+procedure Num.19 (#Attr.2, #Attr.3):
+    let Num.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.282;
+
+procedure Test.1 (Test.12):
+    let Test.6 : I64 = StructAtIndex 0 Test.12;
+    let Test.5 : I64 = StructAtIndex 1 Test.12;
+    let Test.3 : I64 = StructAtIndex 2 Test.12;
+    let Test.4 : I64 = StructAtIndex 3 Test.12;
+    let Test.18 : I64 = CallByName Num.19 Test.3 Test.5;
+    let Test.19 : I64 = CallByName Num.19 Test.4 Test.6;
+    let Test.17 : {I64, I64} = Struct {Test.18, Test.19};
+    ret Test.17;
+
+procedure Test.2 (Test.9):
+    let Test.7 : I64 = StructAtIndex 2 Test.9;
+    let Test.8 : I64 = StructAtIndex 3 Test.9;
+    let Test.16 : {I64, I64} = CallByName Test.1 Test.9;
+    let Test.10 : I64 = StructAtIndex 0 Test.16;
+    let Test.11 : I64 = StructAtIndex 1 Test.16;
+    let Test.15 : {I64, I64, I64, I64} = Struct {Test.7, Test.8, Test.10, Test.11};
+    ret Test.15;
+
+procedure Test.0 ():
+    let Test.20 : I64 = 4i64;
+    let Test.21 : I64 = 3i64;
+    let Test.22 : I64 = 1i64;
+    let Test.23 : I64 = 2i64;
+    let Test.14 : {I64, I64, I64, I64} = Struct {Test.20, Test.21, Test.22, Test.23};
+    let Test.13 : {I64, I64, I64, I64} = CallByName Test.2 Test.14;
+    ret Test.13;

crates/compiler/test_mono/generated/capture_void_layout_task.txt

@@ -38,8 +38,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
 
 procedure Test.10 (Test.69, #Attr.12):
     let Test.72 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    let #Derived_gen.18 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-    if #Derived_gen.18 then
+    let #Derived_gen.20 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+    if #Derived_gen.20 then
         free #Attr.12;
         ret Test.72;
     else
@@ -53,7 +53,7 @@ procedure Test.10 (Test.69, #Attr.12):
 procedure Test.14 (Test.45, #Attr.12):
     let Test.55 : {{}, []} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
     let Test.54 : [<r>C {}, C *self {{}, []}] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-    joinpoint #Derived_gen.19:
+    joinpoint #Derived_gen.18:
         let Test.50 : {} = Struct {};
         let Test.51 : U8 = GetTagId Test.54;
         joinpoint Test.52 Test.15:
@@ -80,14 +80,14 @@ procedure Test.14 (Test.45, #Attr.12):
                 jump Test.52 Test.53;
         
     in
-    let #Derived_gen.20 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-    if #Derived_gen.20 then
+    let #Derived_gen.19 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+    if #Derived_gen.19 then
         free #Attr.12;
-        jump #Derived_gen.19;
+        jump #Derived_gen.18;
     else
         inc Test.54;
         decref #Attr.12;
-        jump #Derived_gen.19;
+        jump #Derived_gen.18;
 
 procedure Test.20 (Test.21, Test.18):
     let Test.23 : [C {}, C []] = CallByName Test.32 Test.21 Test.18;

crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt

@@ -47,11 +47,11 @@ procedure Str.3 (#Attr.2, #Attr.3):
 procedure Test.1 (Test.5):
     ret Test.5;
 
-procedure Test.11 (#Derived_gen.10, #Derived_gen.11):
+procedure Test.11 (#Derived_gen.3, #Derived_gen.4):
     joinpoint Test.27 Test.12 #Attr.12:
         let Test.34 : Int1 = UnionAtIndex (Id 2) (Index 1) #Attr.12;
         let Test.33 : [<rnw><null>, C *self Int1, C *self Int1] = UnionAtIndex (Id 2) (Index 0) #Attr.12;
-        joinpoint #Derived_gen.14:
+        joinpoint #Derived_gen.12:
             joinpoint Test.31 Test.29:
                 let Test.30 : U8 = GetTagId Test.33;
                 switch Test.30:
@@ -78,16 +78,16 @@ procedure Test.11 (#Derived_gen.10, #Derived_gen.11):
                     jump Test.31 Test.32;
             
         in
-        let #Derived_gen.15 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-        if #Derived_gen.15 then
+        let #Derived_gen.13 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+        if #Derived_gen.13 then
             free #Attr.12;
-            jump #Derived_gen.14;
+            jump #Derived_gen.12;
         else
             inc Test.33;
             decref #Attr.12;
-            jump #Derived_gen.14;
+            jump #Derived_gen.12;
     in
-    jump Test.27 #Derived_gen.10 #Derived_gen.11;
+    jump Test.27 #Derived_gen.3 #Derived_gen.4;
 
 procedure Test.2 (Test.13):
     ret Test.13;
@@ -118,7 +118,7 @@ procedure Test.6 (Test.7, Test.8, Test.5):
 procedure Test.9 (Test.10, #Attr.12):
     let Test.43 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
     let Test.42 : [<rnw><null>, C *self Int1, C *self Int1] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-    joinpoint #Derived_gen.12:
+    joinpoint #Derived_gen.14:
         let Test.39 : U8 = GetTagId Test.42;
         joinpoint Test.40 Test.38:
             switch Test.43:
@@ -146,14 +146,14 @@ procedure Test.9 (Test.10, #Attr.12):
                 jump Test.40 Test.41;
         
     in
-    let #Derived_gen.13 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-    if #Derived_gen.13 then
+    let #Derived_gen.15 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+    if #Derived_gen.15 then
         free #Attr.12;
-        jump #Derived_gen.12;
+        jump #Derived_gen.14;
     else
         inc Test.42;
         decref #Attr.12;
-        jump #Derived_gen.12;
+        jump #Derived_gen.14;
 
 procedure Test.0 ():
     let Test.45 : Int1 = false;

crates/compiler/test_mono/generated/dbg_expr.txt

@@ -0,0 +1,56 @@
+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.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;
+    ret Inspect.307;
+
+procedure Inspect.57 (Inspect.277):
+    let Inspect.313 : I64 = CallByName Inspect.30 Inspect.277;
+    ret Inspect.313;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.320 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.320;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure Num.19 (#Attr.2, #Attr.3):
+    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
+
+procedure Num.96 (#Attr.2):
+    let Num.282 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.282;
+
+procedure Str.3 (#Attr.2, #Attr.3):
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
+
+procedure Test.0 ():
+    let Test.5 : I64 = 1i64;
+    let Test.2 : I64 = 2i64;
+    let Test.3 : Str = CallByName Inspect.33 Test.2;
+    dbg Test.3;
+    dec Test.3;
+    let Test.4 : I64 = CallByName Num.19 Test.5 Test.2;
+    ret Test.4;

crates/compiler/test_mono/generated/dbg_inside_string.txt

@@ -0,0 +1,58 @@
+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;
+
+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;
+    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.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure Str.3 (#Attr.2, #Attr.3):
+    let Str.238 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.238;
+
+procedure Test.0 ():
+    let Test.5 : Str = "Hello ";
+    let Test.2 : Str = "world";
+    inc Test.2;
+    let Test.3 : Str = CallByName Inspect.33 Test.2;
+    dbg Test.3;
+    dec Test.3;
+    let Test.8 : Str = "!";
+    let Test.6 : Str = CallByName Str.3 Test.2 Test.8;
+    dec Test.8;
+    let Test.4 : Str = CallByName Str.3 Test.5 Test.6;
+    dec Test.6;
+    ret Test.4;

crates/compiler/test_mono/generated/dbg_nested_expr.txt

@@ -0,0 +1,56 @@
+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.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;
+
+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;
+    ret Inspect.307;
+
+procedure Inspect.57 (Inspect.277):
+    let Inspect.313 : I64 = CallByName Inspect.30 Inspect.277;
+    ret Inspect.313;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.320 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.320;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure Num.96 (#Attr.2):
+    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.281;
+
+procedure Str.3 (#Attr.2, #Attr.3):
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
+
+procedure Test.0 ():
+    let Test.6 : I64 = 1i64;
+    let Test.7 : Str = CallByName Inspect.33 Test.6;
+    dbg Test.7;
+    dec Test.7;
+    let Test.8 : Str = CallByName Inspect.33 Test.6;
+    dbg Test.8;
+    dec Test.8;
+    let Test.9 : Str = CallByName Inspect.33 Test.6;
+    dbg Test.9;
+    dec Test.9;
+    ret Test.6;

crates/compiler/test_mono/generated/dict.txt

@@ -1,29 +1,29 @@
-procedure Dict.1 (Dict.730):
-    let Dict.739 : List {U32, U32} = Array [];
-    let Dict.740 : List {[], []} = Array [];
-    let Dict.741 : U64 = 0i64;
+procedure Dict.1 (Dict.731):
+    let Dict.740 : List {U32, U32} = Array [];
+    let Dict.741 : List {[], []} = Array [];
+    let Dict.742 : U64 = 0i64;
     let Dict.51 : Float32 = CallByName Dict.51;
     let Dict.52 : U8 = CallByName Dict.52;
-    let Dict.738 : {List {U32, U32}, List {[], []}, U64, Float32, U8} = Struct {Dict.739, Dict.740, Dict.741, Dict.51, Dict.52};
+    let Dict.739 : {List {U32, U32}, List {[], []}, U64, Float32, U8} = Struct {Dict.740, Dict.741, Dict.742, Dict.51, Dict.52};
+    ret Dict.739;
+
+procedure Dict.4 (Dict.737):
+    let Dict.163 : List {[], []} = StructAtIndex 1 Dict.737;
+    let #Derived_gen.0 : List {U32, U32} = StructAtIndex 0 Dict.737;
+    dec #Derived_gen.0;
+    let Dict.738 : U64 = CallByName List.6 Dict.163;
+    dec Dict.163;
     ret Dict.738;
 
-procedure Dict.4 (Dict.736):
-    let Dict.163 : List {[], []} = StructAtIndex 1 Dict.736;
-    let #Derived_gen.0 : List {U32, U32} = StructAtIndex 0 Dict.736;
-    dec #Derived_gen.0;
-    let Dict.737 : U64 = CallByName List.6 Dict.163;
-    dec Dict.163;
-    ret Dict.737;
-
 procedure Dict.51 ():
-    let Dict.745 : Float32 = 0.8f64;
-    ret Dict.745;
+    let Dict.746 : Float32 = 0.8f64;
+    ret Dict.746;
 
 procedure Dict.52 ():
-    let Dict.743 : U8 = 64i64;
-    let Dict.744 : U8 = 3i64;
-    let Dict.742 : U8 = CallByName Num.75 Dict.743 Dict.744;
-    ret Dict.742;
+    let Dict.744 : U8 = 64i64;
+    let Dict.745 : U8 = 3i64;
+    let Dict.743 : U8 = CallByName Num.75 Dict.744 Dict.745;
+    ret Dict.743;
 
 procedure List.6 (#Attr.2):
     let List.625 : U64 = lowlevel ListLenU64 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt

@@ -76,7 +76,7 @@ procedure List.8 (#Attr.2, #Attr.3):
     let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
     ret List.649;
 
-procedure List.95 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
+procedure List.95 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
     joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
         let List.630 : Int1 = CallByName Num.22 List.172 List.173;
         if List.630 then
@@ -90,8 +90,8 @@ procedure List.95 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_g
             dec List.169;
             ret List.170;
     in
-    inc #Derived_gen.10;
-    jump List.628 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
+    inc #Derived_gen.13;
+    jump List.628 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
 
 procedure Num.127 (#Attr.2):
     let Num.282 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/inline_return_joinpoints_in_union_lambda_set.txt

@@ -17,7 +17,7 @@ procedure Test.4 (Test.5, #Attr.12):
     let Test.16 : I64 = CallByName Num.19 Test.5 Test.17;
     ret Test.16;
 
-procedure Test.0 (#Derived_gen.0):
+procedure Test.0 (#Derived_gen.2):
     joinpoint Test.7 Test.1:
         let Test.21 : I64 = 1i64;
         let Test.9 : I64 = CallByName Num.19 Test.1 Test.21;
@@ -33,4 +33,4 @@ procedure Test.0 (#Derived_gen.0):
                 ret Test.8;
         
     in
-    jump Test.7 #Derived_gen.0;
+    jump Test.7 #Derived_gen.2;

crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt

@@ -91,8 +91,8 @@ procedure Test.19 ():
             let Test.120 : [C Str, C {List U8, I64}] = TagId(0) Test.122;
             ret Test.120;
     else
-        dec Test.92;
         dec Test.93;
+        dec Test.92;
         let Test.128 : Str = "not a number";
         let Test.126 : [C Str, C {List U8, I64}] = TagId(0) Test.128;
         ret Test.126;

crates/compiler/test_mono/generated/list_map_take_capturing_or_noncapturing.txt

@@ -108,8 +108,8 @@ procedure Test.0 ():
     else
         let Test.22 : Str = "B";
         let Test.23 : Int1 = lowlevel Eq Test.22 Test.12;
-        dec Test.22;
         dec Test.12;
+        dec Test.22;
         if Test.23 then
             let Test.17 : [C U8, C U8, C ] = TagId(1) Test.2;
             jump Test.13 Test.17;

crates/compiler/test_mono/generated/opaque_as_pattern_in_closure_arg.txt

@@ -0,0 +1,18 @@
+procedure Num.21 (#Attr.2, #Attr.3):
+    let Num.281 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.281;
+
+procedure Test.2 (Test.8):
+    let Test.14 : U64 = 2i64;
+    let Test.13 : U64 = CallByName Num.21 Test.8 Test.14;
+    ret Test.13;
+
+procedure Test.3 (Test.7):
+    let Test.12 : U64 = CallByName Test.2 Test.7;
+    let Test.11 : {U64, U64} = Struct {Test.7, Test.12};
+    ret Test.11;
+
+procedure Test.0 ():
+    let Test.10 : U64 = 42i64;
+    let Test.9 : {U64, U64} = CallByName Test.3 Test.10;
+    ret Test.9;

crates/compiler/test_mono/generated/pattern_as_toplevel.txt

@@ -20,9 +20,9 @@ procedure Test.0 ():
     if Test.13 then
         let Test.6 : {I64, Str} = CallByName Test.1;
         let Test.5 : Int1 = CallByName Bool.11 Test.6 Test.4;
-        dec Test.6;
         let #Derived_gen.0 : Str = StructAtIndex 1 Test.4;
         dec #Derived_gen.0;
+        dec Test.6;
         ret Test.5;
     else
         let #Derived_gen.1 : Str = StructAtIndex 1 Test.4;

crates/compiler/test_mono/generated/pizza_dbg.txt

@@ -0,0 +1,59 @@
+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.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;
+
+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;
+    ret Inspect.307;
+
+procedure Inspect.57 (Inspect.277):
+    let Inspect.313 : I64 = CallByName Inspect.30 Inspect.277;
+    ret Inspect.313;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.320 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.320;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure Num.19 (#Attr.2, #Attr.3):
+    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
+
+procedure Num.96 (#Attr.2):
+    let Num.282 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.282;
+
+procedure Str.3 (#Attr.2, #Attr.3):
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
+
+procedure Test.0 ():
+    let Test.4 : I64 = 1i64;
+    let Test.5 : Str = CallByName Inspect.33 Test.4;
+    dbg Test.5;
+    dec Test.5;
+    let Test.9 : I64 = 2i64;
+    let Test.3 : I64 = CallByName Num.19 Test.4 Test.9;
+    let Test.6 : Str = CallByName Inspect.33 Test.3;
+    dbg Test.6;
+    dec Test.6;
+    ret Test.3;

crates/compiler/test_mono/generated/record_as_pattern_in_closure_arg.txt

@@ -0,0 +1,31 @@
+procedure Num.19 (#Attr.2, #Attr.3):
+    let Num.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.282;
+
+procedure Test.1 (Test.12):
+    let Test.6 : I64 = StructAtIndex 0 Test.12;
+    let Test.5 : I64 = StructAtIndex 1 Test.12;
+    let Test.3 : I64 = StructAtIndex 2 Test.12;
+    let Test.4 : I64 = StructAtIndex 3 Test.12;
+    let Test.18 : I64 = CallByName Num.19 Test.3 Test.5;
+    let Test.19 : I64 = CallByName Num.19 Test.4 Test.6;
+    let Test.17 : {I64, I64} = Struct {Test.18, Test.19};
+    ret Test.17;
+
+procedure Test.2 (Test.9):
+    let Test.7 : I64 = StructAtIndex 2 Test.9;
+    let Test.8 : I64 = StructAtIndex 3 Test.9;
+    let Test.16 : {I64, I64} = CallByName Test.1 Test.9;
+    let Test.10 : I64 = StructAtIndex 0 Test.16;
+    let Test.11 : I64 = StructAtIndex 1 Test.16;
+    let Test.15 : {I64, I64, I64, I64} = Struct {Test.7, Test.8, Test.10, Test.11};
+    ret Test.15;
+
+procedure Test.0 ():
+    let Test.20 : I64 = 4i64;
+    let Test.21 : I64 = 3i64;
+    let Test.22 : I64 = 1i64;
+    let Test.23 : I64 = 2i64;
+    let Test.14 : {I64, I64, I64, I64} = Struct {Test.20, Test.21, Test.22, Test.23};
+    let Test.13 : {I64, I64, I64, I64} = CallByName Test.2 Test.14;
+    ret Test.13;

crates/compiler/test_mono/generated/recursive_function_and_union_with_inference_hole.txt

@@ -31,7 +31,7 @@ procedure List.71 (#Attr.2, #Attr.3):
     let List.643 : List [<rnnu>C List *self] = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
     ret List.643;
 
-procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.95 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
     joinpoint List.631 List.169 List.170 List.171 List.172 List.173:
         let List.633 : Int1 = CallByName Num.22 List.172 List.173;
         if List.633 then
@@ -45,8 +45,8 @@ procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
             dec List.169;
             ret List.170;
     in
-    inc #Derived_gen.0;
-    jump List.631 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    inc #Derived_gen.1;
+    jump List.631 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/recursive_lambda_set_resolved_only_upon_specialization.txt

@@ -10,7 +10,7 @@ procedure Num.21 (#Attr.2, #Attr.3):
     let Num.281 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
     ret Num.281;
 
-procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
+procedure Test.1 (#Derived_gen.2, #Derived_gen.3):
     joinpoint Test.11 Test.2 Test.3:
         let Test.26 : U8 = 0i64;
         let Test.22 : Int1 = CallByName Bool.11 Test.2 Test.26;
@@ -33,9 +33,9 @@ procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
             let Test.14 : [<rnu><null>, C *self U8] = TagId(0) Test.3 Test.2;
             jump Test.11 Test.13 Test.14;
     in
-    jump Test.11 #Derived_gen.0 #Derived_gen.1;
+    jump Test.11 #Derived_gen.2 #Derived_gen.3;
 
-procedure Test.4 (#Derived_gen.2, #Derived_gen.3):
+procedure Test.4 (#Derived_gen.0, #Derived_gen.1):
     joinpoint Test.15 Test.5 #Attr.12:
         let Test.20 : U8 = UnionAtIndex (Id 0) (Index 1) #Attr.12;
         let Test.19 : [<rnu><null>, C *self U8] = UnionAtIndex (Id 0) (Index 0) #Attr.12;
@@ -61,7 +61,7 @@ procedure Test.4 (#Derived_gen.2, #Derived_gen.3):
             decref #Attr.12;
             jump #Derived_gen.4;
     in
-    jump Test.15 #Derived_gen.2 #Derived_gen.3;
+    jump Test.15 #Derived_gen.0 #Derived_gen.1;
 
 procedure Test.6 (Test.7):
     ret Test.7;

crates/compiler/test_mono/generated/recursively_build_effect.txt

@@ -8,8 +8,8 @@ procedure Str.3 (#Attr.2, #Attr.3):
 
 procedure Test.11 (Test.29, #Attr.12):
     let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    let #Derived_gen.9 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-    if #Derived_gen.9 then
+    let #Derived_gen.11 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+    if #Derived_gen.11 then
         free #Attr.12;
         ret Test.32;
     else
@@ -19,11 +19,11 @@ procedure Test.11 (Test.29, #Attr.12):
 procedure Test.11 (Test.29, Test.10):
     ret Test.10;
 
-procedure Test.14 (#Derived_gen.7, #Derived_gen.8):
+procedure Test.14 (#Derived_gen.0, #Derived_gen.1):
     joinpoint Test.38 Test.37 #Attr.12:
         let Test.46 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
         let Test.45 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-        joinpoint #Derived_gen.10:
+        joinpoint #Derived_gen.9:
             let Test.44 : {} = Struct {};
             let Test.43 : {} = CallByName Test.11 Test.44 Test.46;
             let Test.39 : [<r>C {}, C I64 {}] = CallByName Test.9 Test.43 Test.45;
@@ -38,15 +38,15 @@ procedure Test.14 (#Derived_gen.7, #Derived_gen.8):
                     jump Test.38 Test.41 Test.39;
             
         in
-        let #Derived_gen.11 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-        if #Derived_gen.11 then
+        let #Derived_gen.10 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+        if #Derived_gen.10 then
             free #Attr.12;
-            jump #Derived_gen.10;
+            jump #Derived_gen.9;
         else
             decref #Attr.12;
-            jump #Derived_gen.10;
+            jump #Derived_gen.9;
     in
-    jump Test.38 #Derived_gen.7 #Derived_gen.8;
+    jump Test.38 #Derived_gen.0 #Derived_gen.1;
 
 procedure Test.2 ():
     let Test.6 : Str = "Hello";

crates/compiler/test_mono/generated/specialize_after_match.txt

@@ -23,7 +23,7 @@ procedure Test.2 (Test.9, Test.10):
             let Test.29 : U64 = CallByName Test.3 Test.9;
             ret Test.29;
         else
-            joinpoint #Derived_gen.4:
+            joinpoint #Derived_gen.1:
                 let Test.13 : Str = UnionAtIndex (Id 0) (Index 0) Test.10;
                 let Test.14 : [<rnu><null>, C Str *self] = UnionAtIndex (Id 0) (Index 1) Test.10;
                 let Test.33 : U64 = CallByName Test.3 Test.12;
@@ -36,15 +36,15 @@ procedure Test.2 (Test.9, Test.10):
                 else
                     ret Test.16;
             in
-            let #Derived_gen.5 : Int1 = lowlevel RefCountIsUnique Test.9;
-            if #Derived_gen.5 then
+            let #Derived_gen.2 : Int1 = lowlevel RefCountIsUnique Test.9;
+            if #Derived_gen.2 then
                 dec Test.11;
                 free Test.9;
-                jump #Derived_gen.4;
+                jump #Derived_gen.1;
             else
                 inc Test.12;
                 decref Test.9;
-                jump #Derived_gen.4;
+                jump #Derived_gen.1;
 
 procedure Test.3 (Test.17):
     let Test.26 : U8 = 1i64;
@@ -55,22 +55,22 @@ procedure Test.3 (Test.17):
         ret Test.22;
     else
         let Test.18 : [<rnu><null>, C Str *self] = UnionAtIndex (Id 0) (Index 1) Test.17;
-        joinpoint #Derived_gen.1:
+        joinpoint #Derived_gen.3:
             let Test.24 : U64 = 1i64;
             let Test.25 : U64 = CallByName Test.3 Test.18;
             let Test.23 : U64 = CallByName Num.19 Test.24 Test.25;
             ret Test.23;
         in
-        let #Derived_gen.3 : Int1 = lowlevel RefCountIsUnique Test.17;
-        if #Derived_gen.3 then
-            let #Derived_gen.2 : Str = UnionAtIndex (Id 0) (Index 0) Test.17;
-            dec #Derived_gen.2;
+        let #Derived_gen.5 : Int1 = lowlevel RefCountIsUnique Test.17;
+        if #Derived_gen.5 then
+            let #Derived_gen.4 : Str = UnionAtIndex (Id 0) (Index 0) Test.17;
+            dec #Derived_gen.4;
             free Test.17;
-            jump #Derived_gen.1;
+            jump #Derived_gen.3;
         else
             inc Test.18;
             decref Test.17;
-            jump #Derived_gen.1;
+            jump #Derived_gen.3;
 
 procedure Test.0 ():
     let Test.5 : [<rnu><null>, C Str *self] = TagId(1) ;

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt

@@ -65,7 +65,7 @@ procedure List.8 (#Attr.2, #Attr.3):
     let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
     ret List.649;
 
-procedure List.95 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13):
+procedure List.95 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16):
     joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
         let List.630 : Int1 = CallByName Num.22 List.172 List.173;
         if List.630 then
@@ -79,8 +79,8 @@ procedure List.95 (#Derived_gen.9, #Derived_gen.10, #Derived_gen.11, #Derived_ge
             dec List.169;
             ret List.170;
     in
-    inc #Derived_gen.9;
-    jump List.628 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13;
+    inc #Derived_gen.12;
+    jump List.628 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
 
 procedure Num.127 (#Attr.2):
     let Num.282 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt

@@ -141,7 +141,7 @@ procedure List.8 (#Attr.2, #Attr.3):
     let List.676 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
     ret List.676;
 
-procedure List.95 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
+procedure List.95 (#Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38, #Derived_gen.39):
     joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
         let List.630 : Int1 = CallByName Num.22 List.172 List.173;
         if List.630 then
@@ -155,10 +155,10 @@ procedure List.95 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_g
             dec List.169;
             ret List.170;
     in
-    inc #Derived_gen.26;
-    jump List.628 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
+    inc #Derived_gen.35;
+    jump List.628 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39;
 
-procedure List.95 (#Derived_gen.34, #Derived_gen.35, #Derived_gen.36, #Derived_gen.37, #Derived_gen.38):
+procedure List.95 (#Derived_gen.49, #Derived_gen.50, #Derived_gen.51, #Derived_gen.52, #Derived_gen.53):
     joinpoint List.655 List.169 List.170 List.171 List.172 List.173:
         let List.657 : Int1 = CallByName Num.22 List.172 List.173;
         if List.657 then
@@ -172,8 +172,8 @@ procedure List.95 (#Derived_gen.34, #Derived_gen.35, #Derived_gen.36, #Derived_g
             dec List.169;
             ret List.170;
     in
-    inc #Derived_gen.34;
-    jump List.655 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36 #Derived_gen.37 #Derived_gen.38;
+    inc #Derived_gen.49;
+    jump List.655 #Derived_gen.49 #Derived_gen.50 #Derived_gen.51 #Derived_gen.52 #Derived_gen.53;
 
 procedure Num.127 (#Attr.2):
     let Num.286 : U8 = lowlevel NumIntCast #Attr.2;

crates/compiler/test_mono/src/tests.rs

@@ -657,6 +657,31 @@ fn record_optional_field_function_use_default() {
     "
 }
 
+#[mono_test]
+fn record_as_pattern_in_closure_arg() {
+    r"
+    f = \{x, y, w, h} -> (x + w, y + h)
+
+    g = \({ x, y } as box) ->
+        (right, bottom) = f box
+        (x, y, right, bottom)
+
+    g { x: 1, y: 2, w: 3, h: 4 }
+    "
+}
+
+#[mono_test]
+fn opaque_as_pattern_in_closure_arg() {
+    r"
+    Opaque := U64
+
+    f = \(@Opaque x) -> x * 2
+    g = \(@Opaque x as s) -> (x, f s)
+
+    g (@Opaque 42)
+    "
+}
+
 #[mono_test]
 fn quicksort_help() {
     // do we still need with_larger_debug_stack?
@@ -3243,6 +3268,45 @@ fn dbg_str_followed_by_number() {
     )
 }
 
+#[mono_test]
+fn dbg_expr() {
+    indoc!(
+        r#"
+        1 + (dbg 2)
+        "#
+    )
+}
+
+#[mono_test]
+fn dbg_nested_expr() {
+    indoc!(
+        r#"
+        dbg (dbg (dbg 1))
+        "#
+    )
+}
+
+#[mono_test]
+fn dbg_inside_string() {
+    indoc!(
+        r#"
+        "Hello $(dbg "world")!"
+        "#
+    )
+}
+
+#[mono_test]
+fn pizza_dbg() {
+    indoc!(
+        r#"
+        1
+        |> dbg
+        |> Num.add 2
+        |> dbg
+        "#
+    )
+}
+
 #[mono_test]
 fn linked_list_reverse() {
     indoc!(
@@ -3319,9 +3383,9 @@ fn capture_void_layout_task() {
 
         Fx a : {} -> a
 
-        Task ok err : Fx (Result ok err)
+        OtherTask ok err : Fx (Result ok err)
 
-        succeed : ok -> Task ok *
+        succeed : ok -> OtherTask ok *
         succeed = \ok -> \{} -> Ok ok
 
         after : Fx a, (a -> Fx b) -> Fx b
@@ -3333,7 +3397,7 @@ fn capture_void_layout_task() {
 
             afterInner
 
-        await : Task a err, (a -> Task b err) -> Task b err
+        await : OtherTask a err, (a -> OtherTask b err) -> OtherTask b err
         await = \fx, toNext ->
             inner = after fx \result ->
                 when result is
@@ -3343,12 +3407,12 @@ fn capture_void_layout_task() {
                     Err e -> (\{} -> Err e)
             inner
 
-        forEach : List a, (a -> Task {} err) -> Task {} err
+        forEach : List a, (a -> OtherTask {} err) -> OtherTask {} err
         forEach = \list, fromElem ->
             List.walk list (succeed {}) \task, elem ->
                 await task \{} -> fromElem elem
 
-        main : Task {} []
+        main : OtherTask {} []
         main =
             forEach [] \_ -> succeed {}
         "#
@@ -3389,8 +3453,8 @@ fn inspect_custom_type() {
 
         myToInspector : HelloWorld -> Inspector f where f implements InspectFormatter
         myToInspector = \@HellowWorld {} ->
-            fmt <- Inspect.custom
-            Inspect.apply (Inspect.str "Hello, World!\n") fmt
+            Inspect.custom \fmt ->
+                Inspect.apply (Inspect.str "Hello, World!\n") fmt
 
         main =
             Inspect.inspect (@HelloWorld {})