mono tests update

compiler/test_mono/generated/alias_variable.txt

@@ -1,3 +1,4 @@
 procedure Test.0 ():
+    let Test.1 : I64 = 5i64;
     let Test.3 : I64 = 3i64;
     ret Test.3;

compiler/test_mono/generated/closure_in_list.txt

@@ -1,21 +1,20 @@
 procedure List.6 (#Attr.2):
-    let List.139 : U64 = lowlevel ListLen #Attr.2;
+    let List.140 : U64 = lowlevel ListLen #Attr.2;
-    ret List.139;
+    ret List.140;
 
 procedure Test.1 (Test.5):
     let Test.2 : I64 = 41i64;
-    let Test.11 : {I64} = Struct {Test.2};
+    let Test.10 : {I64} = Struct {Test.2};
-    let Test.10 : List {I64} = Array [Test.11];
+    let Test.9 : List {I64} = Array [Test.10];
-    ret Test.10;
+    ret Test.9;
 
-procedure Test.3 (Test.9, #Attr.12):
+procedure Test.3 (Test.8, #Attr.12):
     let Test.2 : I64 = StructAtIndex 0 #Attr.12;
-    let Test.2 : I64 = 41i64;
     ret Test.2;
 
 procedure Test.0 ():
-    let Test.8 : {} = Struct {};
+    let Test.7 : {} = Struct {};
-    let Test.7 : List {I64} = CallByName Test.1 Test.8;
+    let Test.4 : List {I64} = CallByName Test.1 Test.7;
-    let Test.6 : U64 = CallByName List.6 Test.7;
+    let Test.6 : U64 = CallByName List.6 Test.4;
-    dec Test.7;
+    dec Test.4;
     ret Test.6;

compiler/test_mono/generated/empty_list_of_function_type.txt

@@ -1,20 +1,21 @@
 procedure List.2 (#Attr.2, #Attr.3):
-    let List.144 : U64 = lowlevel ListLen #Attr.2;
+    let List.145 : U64 = lowlevel ListLen #Attr.2;
-    let List.141 : Int1 = lowlevel NumLt #Attr.3 List.144;
+    let List.142 : Int1 = lowlevel NumLt #Attr.3 List.145;
-    if List.141 then
+    if List.142 then
-        let List.143 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+        let List.144 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-        let List.142 : [C {}, C {}] = Ok List.143;
+        let List.143 : [C {}, C {}] = Ok List.144;
-        ret List.142;
+        ret List.143;
     else
-        let List.140 : {} = Struct {};
+        let List.141 : {} = Struct {};
-        let List.139 : [C {}, C {}] = Err List.140;
+        let List.140 : [C {}, C {}] = Err List.141;
-        ret List.139;
+        ret List.140;
 
 procedure Test.2 (Test.6):
     let Test.18 : Str = "bar";
     ret Test.18;
 
 procedure Test.0 ():
+    let Test.1 : List {} = Array [];
     joinpoint Test.16 Test.3:
         let Test.14 : U64 = 0i64;
         let Test.7 : [C {}, C {}] = CallByName List.2 Test.3 Test.14;
@@ -34,9 +35,9 @@ procedure Test.0 ():
     in
     let Test.19 : Int1 = false;
     if Test.19 then
-        let Test.1 : List {} = Array [];
         jump Test.16 Test.1;
     else
+        dec Test.1;
         let Test.17 : {} = Struct {};
         let Test.15 : List {} = Array [Test.17];
         jump Test.16 Test.15;

compiler/test_mono/generated/encode.txt

@@ -0,0 +1,24 @@
+procedure List.4 (#Attr.2, #Attr.3):
+    let List.140 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
+    ret List.140;
+
+procedure Test.20 (Test.22):
+    let Test.34 : {U8} = Struct {Test.22};
+    ret Test.34;
+
+procedure Test.21 (Test.27):
+    let Test.33 : {U8} = CallByName Test.20 Test.27;
+    ret Test.33;
+
+procedure Test.23 (Test.24, Test.35, #Attr.12):
+    let Test.22 : U8 = StructAtIndex 0 #Attr.12;
+    let Test.37 : List U8 = CallByName List.4 Test.24 Test.22;
+    ret Test.37;
+
+procedure Test.0 ():
+    let Test.32 : U8 = 15i64;
+    let Test.28 : {U8} = CallByName Test.21 Test.32;
+    let Test.30 : List U8 = Array [];
+    let Test.31 : {} = Struct {};
+    let Test.29 : List U8 = CallByName Test.23 Test.30 Test.31 Test.28;
+    ret Test.29;

compiler/test_mono/generated/factorial.txt

@@ -1,10 +1,10 @@
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.272 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.274;
+    ret Num.272;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.1 (Test.15, Test.16):
     joinpoint Test.7 Test.2 Test.3:

compiler/test_mono/generated/ir_int_add.txt

@@ -1,19 +1,19 @@
 procedure List.6 (#Attr.2):
-    let List.139 : U64 = lowlevel ListLen #Attr.2;
+    let List.140 : U64 = lowlevel ListLen #Attr.2;
-    ret List.139;
+    ret List.140;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.275;
+    ret Num.273;
 
 procedure Test.0 ():
-    let Test.8 : U64 = 5i64;
+    let Test.1 : List I64 = Array [1i64, 2i64];
-    let Test.9 : U64 = 4i64;
+    let Test.7 : U64 = 5i64;
-    let Test.6 : U64 = CallByName Num.19 Test.8 Test.9;
+    let Test.8 : U64 = 4i64;
-    let Test.7 : U64 = 3i64;
+    let Test.5 : U64 = CallByName Num.19 Test.7 Test.8;
-    let Test.3 : U64 = CallByName Num.19 Test.6 Test.7;
+    let Test.6 : U64 = 3i64;
-    let Test.5 : List I64 = Array [1i64, 2i64];
+    let Test.3 : U64 = CallByName Num.19 Test.5 Test.6;
-    let Test.4 : U64 = CallByName List.6 Test.5;
+    let Test.4 : U64 = CallByName List.6 Test.1;
-    dec Test.5;
+    dec Test.1;
     let Test.2 : U64 = CallByName Num.19 Test.3 Test.4;
     ret Test.2;

compiler/test_mono/generated/ir_plus.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
     let Test.2 : I64 = 1i64;

compiler/test_mono/generated/ir_round.txt

@@ -1,6 +1,6 @@
 procedure Num.45 (#Attr.2):
-    let Num.273 : I64 = lowlevel NumRound #Attr.2;
+    let Num.271 : I64 = lowlevel NumRound #Attr.2;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
     let Test.2 : Float64 = 3.6f64;

compiler/test_mono/generated/ir_two_defs.txt

@@ -1,9 +1,9 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
-    let Test.4 : I64 = 3i64;
+    let Test.1 : I64 = 3i64;
-    let Test.5 : I64 = 4i64;
+    let Test.2 : I64 = 4i64;
-    let Test.3 : I64 = CallByName Num.19 Test.4 Test.5;
+    let Test.3 : I64 = CallByName Num.19 Test.1 Test.2;
     ret Test.3;

compiler/test_mono/generated/ir_when_idiv.txt

@@ -1,14 +1,14 @@
 procedure Num.40 (#Attr.2, #Attr.3):
-    let Num.278 : I64 = 0i64;
+    let Num.276 : I64 = 0i64;
-    let Num.275 : Int1 = lowlevel NotEq #Attr.3 Num.278;
+    let Num.273 : Int1 = lowlevel NotEq #Attr.3 Num.276;
-    if Num.275 then
+    if Num.273 then
-        let Num.277 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
+        let Num.275 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
-        let Num.276 : [C {}, C I64] = Ok Num.277;
+        let Num.274 : [C {}, C I64] = Ok Num.275;
-        ret Num.276;
+        ret Num.274;
     else
-        let Num.274 : {} = Struct {};
+        let Num.272 : {} = Struct {};
-        let Num.273 : [C {}, C I64] = Err Num.274;
+        let Num.271 : [C {}, C I64] = Err Num.272;
-        ret Num.273;
+        ret Num.271;
 
 procedure Test.0 ():
     let Test.8 : I64 = 1000i64;

compiler/test_mono/generated/ir_when_just.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
     let Test.10 : I64 = 41i64;

compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt

@@ -1,16 +1,16 @@
 procedure List.9 (#Attr.2):
-    let List.145 : U64 = 0i64;
+    let List.146 : U64 = 0i64;
-    let List.146 : U64 = lowlevel ListLen #Attr.2;
+    let List.147 : U64 = lowlevel ListLen #Attr.2;
-    let List.141 : Int1 = lowlevel NotEq List.145 List.146;
+    let List.142 : Int1 = lowlevel NotEq List.146 List.147;
-    if List.141 then
+    if List.142 then
-        let List.144 : U64 = 0i64;
+        let List.145 : U64 = 0i64;
-        let List.143 : I64 = lowlevel ListGetUnsafe #Attr.2 List.144;
+        let List.144 : I64 = lowlevel ListGetUnsafe #Attr.2 List.145;
-        let List.142 : [C Int1, C I64] = Ok List.143;
+        let List.143 : [C Int1, C I64] = Ok List.144;
-        ret List.142;
+        ret List.143;
     else
-        let List.140 : Int1 = true;
+        let List.141 : Int1 = true;
-        let List.139 : [C Int1, C I64] = Err List.140;
+        let List.140 : [C Int1, C I64] = Err List.141;
-        ret List.139;
+        ret List.140;
 
 procedure Str.27 (#Attr.2):
     let #Attr.3 : {I64, U8} = lowlevel StrToNum #Attr.2;

compiler/test_mono/generated/let_x_in_x.txt

@@ -1,3 +1,5 @@
 procedure Test.0 ():
+    let Test.1 : I64 = 5i64;
     let Test.2 : I64 = 1337i64;
+    let Test.4 : I64 = 17i64;
     ret Test.2;

compiler/test_mono/generated/let_x_in_x_indirect.txt

@@ -1,6 +1,8 @@
 procedure Test.0 ():
+    let Test.1 : I64 = 5i64;
     let Test.2 : I64 = 1337i64;
     let Test.3 : I64 = 17i64;
+    let Test.5 : I64 = 1i64;
     let Test.7 : {I64, I64} = Struct {Test.2, Test.3};
     let Test.6 : I64 = StructAtIndex 0 Test.7;
     ret Test.6;

compiler/test_mono/generated/list_append.txt

@@ -1,6 +1,6 @@
 procedure List.4 (#Attr.2, #Attr.3):
-    let List.139 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
+    let List.140 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
-    ret List.139;
+    ret List.140;
 
 procedure Test.0 ():
     let Test.2 : List I64 = Array [1i64];

compiler/test_mono/generated/list_append_closure.txt

@@ -1,6 +1,6 @@
 procedure List.4 (#Attr.2, #Attr.3):
-    let List.139 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
+    let List.140 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
-    ret List.139;
+    ret List.140;
 
 procedure Test.1 (Test.2):
     let Test.6 : I64 = 42i64;

compiler/test_mono/generated/list_cannot_update_inplace.txt

@@ -1,27 +1,27 @@
-procedure List.3 (List.63, List.64, List.65):
+procedure List.3 (List.64, List.65, List.66):
-    let List.142 : {List I64, I64} = CallByName List.57 List.63 List.64 List.65;
+    let List.143 : {List I64, I64} = CallByName List.57 List.64 List.65 List.66;
-    let List.141 : List I64 = StructAtIndex 0 List.142;
+    let List.142 : List I64 = StructAtIndex 0 List.143;
-    inc List.141;
+    inc List.142;
-    dec List.142;
+    dec List.143;
-    ret List.141;
+    ret List.142;
 
 procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
-    let List.147 : U64 = lowlevel ListLen #Attr.2;
+    let List.148 : U64 = lowlevel ListLen #Attr.2;
-    let List.145 : Int1 = lowlevel NumLt #Attr.3 List.147;
+    let List.146 : Int1 = lowlevel NumLt #Attr.3 List.148;
-    if List.145 then
+    if List.146 then
-        let List.146 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+        let List.147 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-        ret List.146;
+        ret List.147;
     else
-        let List.144 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
+        let List.145 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
-        ret List.144;
+        ret List.145;
 
 procedure List.6 (#Attr.2):
-    let List.140 : U64 = lowlevel ListLen #Attr.2;
+    let List.141 : U64 = lowlevel ListLen #Attr.2;
-    ret List.140;
+    ret List.141;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.1 ():
     let Test.8 : List I64 = Array [1i64, 2i64, 3i64];

compiler/test_mono/generated/list_get.txt

@@ -1,14 +1,14 @@
 procedure List.2 (#Attr.2, #Attr.3):
-    let List.144 : U64 = lowlevel ListLen #Attr.2;
+    let List.145 : U64 = lowlevel ListLen #Attr.2;
-    let List.141 : Int1 = lowlevel NumLt #Attr.3 List.144;
+    let List.142 : Int1 = lowlevel NumLt #Attr.3 List.145;
-    if List.141 then
+    if List.142 then
-        let List.143 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+        let List.144 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-        let List.142 : [C {}, C I64] = Ok List.143;
+        let List.143 : [C {}, C I64] = Ok List.144;
-        ret List.142;
+        ret List.143;
     else
-        let List.140 : {} = Struct {};
+        let List.141 : {} = Struct {};
-        let List.139 : [C {}, C I64] = Err List.140;
+        let List.140 : [C {}, C I64] = Err List.141;
-        ret List.139;
+        ret List.140;
 
 procedure Test.1 (Test.2):
     let Test.6 : List I64 = Array [1i64, 2i64, 3i64];

compiler/test_mono/generated/list_len.txt

@@ -1,21 +1,21 @@
-procedure List.6 (#Attr.2):
-    let List.139 : U64 = lowlevel ListLen #Attr.2;
-    ret List.139;
-
 procedure List.6 (#Attr.2):
     let List.140 : U64 = lowlevel ListLen #Attr.2;
     ret List.140;
 
+procedure List.6 (#Attr.2):
+    let List.141 : U64 = lowlevel ListLen #Attr.2;
+    ret List.141;
+
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
-    let Test.7 : List I64 = Array [1i64, 2i64, 3i64];
+    let Test.1 : List I64 = Array [1i64, 2i64, 3i64];
-    let Test.4 : U64 = CallByName List.6 Test.7;
+    let Test.2 : List Float64 = Array [1f64];
-    dec Test.7;
+    let Test.4 : U64 = CallByName List.6 Test.1;
-    let Test.6 : List Float64 = Array [1f64];
+    dec Test.1;
-    let Test.5 : U64 = CallByName List.6 Test.6;
+    let Test.5 : U64 = CallByName List.6 Test.2;
-    dec Test.6;
+    dec Test.2;
     let Test.3 : U64 = CallByName Num.19 Test.4 Test.5;
     ret Test.3;

compiler/test_mono/generated/list_pass_to_function.txt

@@ -1,19 +1,19 @@
-procedure List.3 (List.63, List.64, List.65):
+procedure List.3 (List.64, List.65, List.66):
-    let List.140 : {List I64, I64} = CallByName List.57 List.63 List.64 List.65;
+    let List.141 : {List I64, I64} = CallByName List.57 List.64 List.65 List.66;
-    let List.139 : List I64 = StructAtIndex 0 List.140;
+    let List.140 : List I64 = StructAtIndex 0 List.141;
-    inc List.139;
+    inc List.140;
-    dec List.140;
+    dec List.141;
-    ret List.139;
+    ret List.140;
 
 procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
-    let List.145 : U64 = lowlevel ListLen #Attr.2;
+    let List.146 : U64 = lowlevel ListLen #Attr.2;
-    let List.143 : Int1 = lowlevel NumLt #Attr.3 List.145;
+    let List.144 : Int1 = lowlevel NumLt #Attr.3 List.146;
-    if List.143 then
+    if List.144 then
-        let List.144 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+        let List.145 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-        ret List.144;
+        ret List.145;
     else
-        let List.142 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
+        let List.143 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
-        ret List.142;
+        ret List.143;
 
 procedure Test.2 (Test.3):
     let Test.6 : U64 = 0i64;

compiler/test_mono/generated/list_sort_asc.txt

@@ -13,8 +13,8 @@ procedure List.54 (List.98):
     ret List.140;
 
 procedure Num.46 (#Attr.2, #Attr.3):
-    let Num.273 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
+    let Num.271 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
     let Test.2 : List I64 = Array [4i64, 3i64, 2i64, 1i64];

compiler/test_mono/generated/monomorphized_applied_tag.txt

@@ -1,8 +1,8 @@
 procedure Test.2 (Test.4):
-    let Test.11 : U8 = 0i64;
+    let Test.10 : U8 = 0i64;
-    let Test.12 : U8 = GetTagId Test.4;
+    let Test.11 : U8 = GetTagId Test.4;
-    let Test.13 : Int1 = lowlevel Eq Test.11 Test.12;
+    let Test.12 : Int1 = lowlevel Eq Test.10 Test.11;
-    if Test.13 then
+    if Test.12 then
         let Test.5 : Str = UnionAtIndex (Id 0) (Index 0) Test.4;
         inc Test.5;
         dec Test.4;
@@ -14,7 +14,7 @@ procedure Test.2 (Test.4):
         ret Test.6;
 
 procedure Test.0 ():
-    let Test.14 : Str = "A";
+    let Test.13 : Str = "A";
-    let Test.8 : [C Str, C Str] = A Test.14;
+    let Test.1 : [C Str, C Str] = A Test.13;
-    let Test.7 : Str = CallByName Test.2 Test.8;
+    let Test.7 : Str = CallByName Test.2 Test.1;
     ret Test.7;

compiler/test_mono/generated/monomorphized_floats.txt

@@ -1,9 +1,9 @@
 procedure Test.2 (Test.3, Test.4):
-    let Test.8 : U64 = 18i64;
+    let Test.7 : U64 = 18i64;
-    ret Test.8;
+    ret Test.7;
 
 procedure Test.0 ():
-    let Test.6 : Float32 = 100f64;
+    let Test.6 : Float64 = 100f64;
-    let Test.7 : Float64 = 100f64;
+    let Test.1 : Float32 = 100f64;
-    let Test.5 : U64 = CallByName Test.2 Test.6 Test.7;
+    let Test.5 : U64 = CallByName Test.2 Test.1 Test.6;
     ret Test.5;

compiler/test_mono/generated/monomorphized_ints.txt

@@ -1,9 +1,9 @@
 procedure Test.2 (Test.3, Test.4):
-    let Test.8 : U64 = 18i64;
+    let Test.7 : U64 = 18i64;
-    ret Test.8;
+    ret Test.7;
 
 procedure Test.0 ():
-    let Test.6 : U8 = 100i64;
+    let Test.6 : U32 = 100i64;
-    let Test.7 : U32 = 100i64;
+    let Test.1 : U8 = 100i64;
-    let Test.5 : U64 = CallByName Test.2 Test.6 Test.7;
+    let Test.5 : U64 = CallByName Test.2 Test.1 Test.6;
     ret Test.5;

compiler/test_mono/generated/monomorphized_list.txt

@@ -1,11 +1,11 @@
 procedure Test.2 (Test.3, Test.4):
-    let Test.8 : U64 = 18i64;
+    let Test.7 : U64 = 18i64;
-    ret Test.8;
+    ret Test.7;
 
 procedure Test.0 ():
-    let Test.6 : List U8 = Array [1i64, 2i64, 3i64];
+    let Test.6 : List U16 = Array [1i64, 2i64, 3i64];
-    let Test.7 : List U16 = Array [1i64, 2i64, 3i64];
+    let Test.1 : List U8 = Array [1i64, 2i64, 3i64];
-    let Test.5 : U64 = CallByName Test.2 Test.6 Test.7;
+    let Test.5 : U64 = CallByName Test.2 Test.1 Test.6;
-    dec Test.7;
     dec Test.6;
+    dec Test.1;
     ret Test.5;

compiler/test_mono/generated/monomorphized_tag.txt

@@ -1,9 +1,9 @@
 procedure Test.2 (Test.4, Test.5):
-    let Test.9 : U8 = 18i64;
+    let Test.8 : U8 = 18i64;
-    ret Test.9;
+    ret Test.8;
 
 procedure Test.0 ():
-    let Test.7 : Int1 = false;
+    let Test.7 : U8 = 0u8;
-    let Test.8 : U8 = 0u8;
+    let Test.1 : Int1 = false;
-    let Test.6 : U8 = CallByName Test.2 Test.7 Test.8;
+    let Test.6 : U8 = CallByName Test.2 Test.1 Test.7;
     ret Test.6;

compiler/test_mono/generated/monomorphized_tag_with_aliased_args.txt

@@ -1,10 +1,10 @@
 procedure Test.4 (Test.8):
-    let Test.11 : U64 = 1i64;
+    let Test.10 : U64 = 1i64;
-    ret Test.11;
+    ret Test.10;
 
 procedure Test.0 ():
-    let Test.13 : Int1 = false;
+    let Test.1 : Int1 = false;
-    let Test.12 : Int1 = false;
+    let Test.2 : Int1 = false;
-    let Test.10 : {Int1, Int1} = Struct {Test.12, Test.13};
+    let Test.3 : {Int1, Int1} = Struct {Test.1, Test.2};
-    let Test.9 : U64 = CallByName Test.4 Test.10;
+    let Test.9 : U64 = CallByName Test.4 Test.3;
     ret Test.9;

compiler/test_mono/generated/nested_closure.txt

@@ -3,14 +3,13 @@ procedure Test.1 (Test.5):
     let Test.3 : {I64} = Struct {Test.2};
     ret Test.3;
 
-procedure Test.3 (Test.10, #Attr.12):
+procedure Test.3 (Test.9, #Attr.12):
     let Test.2 : I64 = StructAtIndex 0 #Attr.12;
-    let Test.2 : I64 = 42i64;
     ret Test.2;
 
 procedure Test.0 ():
+    let Test.8 : {} = Struct {};
+    let Test.4 : {I64} = CallByName Test.1 Test.8;
     let Test.7 : {} = Struct {};
-    let Test.9 : {} = Struct {};
+    let Test.6 : I64 = CallByName Test.3 Test.7 Test.4;
-    let Test.8 : {I64} = CallByName Test.1 Test.9;
-    let Test.6 : I64 = CallByName Test.3 Test.7 Test.8;
     ret Test.6;

compiler/test_mono/generated/nested_pattern_match.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
     let Test.19 : I64 = 41i64;

compiler/test_mono/generated/optional_when.txt

@@ -1,6 +1,6 @@
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.275 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.275;
+    ret Num.273;
 
 procedure Test.1 (Test.6):
     let Test.21 : Int1 = false;
@@ -13,10 +13,10 @@ procedure Test.1 (Test.6):
         ret Test.10;
 
 procedure Test.1 (Test.6):
-    let Test.29 : Int1 = StructAtIndex 1 Test.6;
+    let Test.27 : Int1 = StructAtIndex 1 Test.6;
-    let Test.30 : Int1 = false;
+    let Test.28 : Int1 = false;
-    let Test.31 : Int1 = lowlevel Eq Test.30 Test.29;
+    let Test.29 : Int1 = lowlevel Eq Test.28 Test.27;
-    if Test.31 then
+    if Test.29 then
         let Test.8 : I64 = StructAtIndex 0 Test.6;
         ret Test.8;
     else
@@ -24,19 +24,19 @@ procedure Test.1 (Test.6):
         ret Test.10;
 
 procedure Test.0 ():
-    let Test.39 : I64 = 7i64;
+    let Test.35 : I64 = 7i64;
-    let Test.40 : Int1 = false;
+    let Test.36 : Int1 = false;
-    let Test.38 : {I64, Int1} = Struct {Test.39, Test.40};
+    let Test.34 : {I64, Int1} = Struct {Test.35, Test.36};
-    let Test.34 : I64 = CallByName Test.1 Test.38;
+    let Test.2 : I64 = CallByName Test.1 Test.34;
-    let Test.37 : Int1 = false;
+    let Test.33 : Int1 = false;
-    let Test.35 : I64 = CallByName Test.1 Test.37;
+    let Test.3 : I64 = CallByName Test.1 Test.33;
-    let Test.24 : I64 = CallByName Num.21 Test.34 Test.35;
+    let Test.30 : I64 = 11i64;
-    let Test.32 : I64 = 11i64;
+    let Test.31 : Int1 = true;
-    let Test.33 : Int1 = true;
+    let Test.24 : {I64, Int1} = Struct {Test.30, Test.31};
-    let Test.26 : {I64, Int1} = Struct {Test.32, Test.33};
+    let Test.4 : I64 = CallByName Test.1 Test.24;
-    let Test.25 : I64 = CallByName Test.1 Test.26;
-    let Test.16 : I64 = CallByName Num.21 Test.24 Test.25;
     let Test.23 : Int1 = true;
-    let Test.17 : I64 = CallByName Test.1 Test.23;
+    let Test.5 : I64 = CallByName Test.1 Test.23;
-    let Test.15 : I64 = CallByName Num.21 Test.16 Test.17;
+    let Test.17 : I64 = CallByName Num.21 Test.2 Test.3;
+    let Test.16 : I64 = CallByName Num.21 Test.17 Test.4;
+    let Test.15 : I64 = CallByName Num.21 Test.16 Test.5;
     ret Test.15;

compiler/test_mono/generated/quicksort_help.txt

@@ -1,14 +1,14 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.272 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.274;
+    ret Num.272;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.275;
+    ret Num.273;
 
 procedure Test.1 (Test.24, Test.25, Test.26):
     joinpoint Test.12 Test.2 Test.3 Test.4:

compiler/test_mono/generated/quicksort_swap.txt

@@ -1,31 +1,31 @@
 procedure List.2 (#Attr.2, #Attr.3):
-    let List.156 : U64 = lowlevel ListLen #Attr.2;
+    let List.157 : U64 = lowlevel ListLen #Attr.2;
-    let List.153 : Int1 = lowlevel NumLt #Attr.3 List.156;
+    let List.154 : Int1 = lowlevel NumLt #Attr.3 List.157;
-    if List.153 then
+    if List.154 then
-        let List.155 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+        let List.156 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-        let List.154 : [C {}, C I64] = Ok List.155;
+        let List.155 : [C {}, C I64] = Ok List.156;
-        ret List.154;
+        ret List.155;
     else
-        let List.152 : {} = Struct {};
+        let List.153 : {} = Struct {};
-        let List.151 : [C {}, C I64] = Err List.152;
+        let List.152 : [C {}, C I64] = Err List.153;
-        ret List.151;
+        ret List.152;
 
-procedure List.3 (List.63, List.64, List.65):
+procedure List.3 (List.64, List.65, List.66):
-    let List.143 : {List I64, I64} = CallByName List.57 List.63 List.64 List.65;
+    let List.144 : {List I64, I64} = CallByName List.57 List.64 List.65 List.66;
-    let List.142 : List I64 = StructAtIndex 0 List.143;
+    let List.143 : List I64 = StructAtIndex 0 List.144;
-    inc List.142;
+    inc List.143;
-    dec List.143;
+    dec List.144;
-    ret List.142;
+    ret List.143;
 
 procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
-    let List.160 : U64 = lowlevel ListLen #Attr.2;
+    let List.161 : U64 = lowlevel ListLen #Attr.2;
-    let List.158 : Int1 = lowlevel NumLt #Attr.3 List.160;
+    let List.159 : Int1 = lowlevel NumLt #Attr.3 List.161;
-    if List.158 then
+    if List.159 then
-        let List.159 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+        let List.160 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-        ret List.159;
+        ret List.160;
     else
-        let List.157 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
+        let List.158 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
-        ret List.157;
+        ret List.158;
 
 procedure Test.1 (Test.2):
     let Test.28 : U64 = 0i64;

compiler/test_mono/generated/record_optional_field_function_no_use_default.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.1 (Test.4):
     let Test.2 : I64 = StructAtIndex 0 Test.4;

compiler/test_mono/generated/record_optional_field_function_use_default.txt

@@ -1,13 +1,13 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.1 (Test.4):
-    let Test.8 : I64 = 10i64;
+    let Test.2 : I64 = 10i64;
-    let Test.7 : I64 = CallByName Num.19 Test.8 Test.4;
+    let Test.7 : I64 = CallByName Num.19 Test.2 Test.4;
     ret Test.7;
 
 procedure Test.0 ():
-    let Test.9 : I64 = 9i64;
+    let Test.8 : I64 = 9i64;
-    let Test.5 : I64 = CallByName Test.1 Test.9;
+    let Test.5 : I64 = CallByName Test.1 Test.8;
     ret Test.5;

compiler/test_mono/generated/record_optional_field_let_no_use_default.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.1 (Test.2):
     let Test.3 : I64 = StructAtIndex 0 Test.2;

compiler/test_mono/generated/record_optional_field_let_use_default.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.1 (Test.2):
     let Test.3 : I64 = 10i64;

compiler/test_mono/generated/rigids.txt

@@ -1,31 +1,31 @@
 procedure List.2 (#Attr.2, #Attr.3):
-    let List.156 : U64 = lowlevel ListLen #Attr.2;
+    let List.157 : U64 = lowlevel ListLen #Attr.2;
-    let List.153 : Int1 = lowlevel NumLt #Attr.3 List.156;
+    let List.154 : Int1 = lowlevel NumLt #Attr.3 List.157;
-    if List.153 then
+    if List.154 then
-        let List.155 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+        let List.156 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-        let List.154 : [C {}, C I64] = Ok List.155;
+        let List.155 : [C {}, C I64] = Ok List.156;
-        ret List.154;
+        ret List.155;
     else
-        let List.152 : {} = Struct {};
+        let List.153 : {} = Struct {};
-        let List.151 : [C {}, C I64] = Err List.152;
+        let List.152 : [C {}, C I64] = Err List.153;
-        ret List.151;
+        ret List.152;
 
-procedure List.3 (List.63, List.64, List.65):
+procedure List.3 (List.64, List.65, List.66):
-    let List.143 : {List I64, I64} = CallByName List.57 List.63 List.64 List.65;
+    let List.144 : {List I64, I64} = CallByName List.57 List.64 List.65 List.66;
-    let List.142 : List I64 = StructAtIndex 0 List.143;
+    let List.143 : List I64 = StructAtIndex 0 List.144;
-    inc List.142;
+    inc List.143;
-    dec List.143;
+    dec List.144;
-    ret List.142;
+    ret List.143;
 
 procedure List.57 (#Attr.2, #Attr.3, #Attr.4):
-    let List.160 : U64 = lowlevel ListLen #Attr.2;
+    let List.161 : U64 = lowlevel ListLen #Attr.2;
-    let List.158 : Int1 = lowlevel NumLt #Attr.3 List.160;
+    let List.159 : Int1 = lowlevel NumLt #Attr.3 List.161;
-    if List.158 then
+    if List.159 then
-        let List.159 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
+        let List.160 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
-        ret List.159;
+        ret List.160;
     else
-        let List.157 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
+        let List.158 : {List I64, I64} = Struct {#Attr.2, #Attr.4};
-        ret List.157;
+        ret List.158;
 
 procedure Test.1 (Test.2, Test.3, Test.4):
     let Test.29 : [C {}, C I64] = CallByName List.2 Test.4 Test.3;
@@ -48,8 +48,8 @@ procedure Test.1 (Test.2, Test.3, Test.4):
             let Test.18 : [C {}, C I64] = StructAtIndex 0 Test.13;
             let Test.6 : I64 = UnionAtIndex (Id 1) (Index 0) Test.18;
             let Test.17 : [C {}, C I64] = StructAtIndex 1 Test.13;
-            let Test.7 : I64 = UnionAtIndex (Id 1) (Index 0) Test.17;
+            let Test.8 : I64 = UnionAtIndex (Id 1) (Index 0) Test.17;
-            let Test.15 : List I64 = CallByName List.3 Test.4 Test.2 Test.7;
+            let Test.15 : List I64 = CallByName List.3 Test.4 Test.2 Test.8;
             let Test.14 : List I64 = CallByName List.3 Test.15 Test.3 Test.6;
             ret Test.14;
         else

compiler/test_mono/generated/specialize_closures.txt

@@ -1,10 +1,10 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.272 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.274;
+    ret Num.272;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.1 (Test.2, Test.3):
     let Test.17 : U8 = GetTagId Test.2;

compiler/test_mono/generated/specialize_lowlevel.txt

@@ -1,10 +1,10 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.272 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.274;
+    ret Num.272;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.6 (Test.8, #Attr.12):
     let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;

compiler/test_mono/generated/when_nested_maybe.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
     let Test.19 : I64 = 41i64;

compiler/test_mono/generated/when_on_record.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
     let Test.5 : I64 = 2i64;

compiler/test_mono/generated/when_on_two_values.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.271 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.273;
+    ret Num.271;
 
 procedure Test.0 ():
     let Test.15 : I64 = 3i64;

repl_wasm/build.rs

@@ -94,8 +94,8 @@ fn build_wasm_libc_compilerrt(out_dir: &str, source_path: &str) -> (String, Stri
     );
 
     (
-        run_command("find", &[&zig_cache_dir, "-name", "libc.a"]),
+        run_command("find", &[&zig_cache_dir, "-name", "libc.a"]).split('\n').next().unwrap().to_string(),
-        run_command("find", &[&zig_cache_dir, "-name", "compiler_rt.o"]),
+        run_command("find", &[&zig_cache_dir, "-name", "compiler_rt.o"]).split('\n').next().unwrap().to_string(),
     )
 }