Merge pull request #2987 from rtfeldman/issue-2793/u8-signed-comparison

Issue 2793/u8 signed comparison

compiler/can/src/builtins.rs

@@ -2506,7 +2506,10 @@ fn list_take_last(symbol: Symbol, var_store: &mut VarStore) -> Def {
 
     let get_sub = RunLowLevel {
         op: LowLevel::NumSubWrap,
-        args: vec![(len_var, get_list_len), (len_var, Var(Symbol::ARG_2))],
+        args: vec![
+            (len_var, get_list_len.clone()),
+            (len_var, Var(Symbol::ARG_2)),
+        ],
         ret_var: len_var,
     };
 
@@ -2516,7 +2519,7 @@ fn list_take_last(symbol: Symbol, var_store: &mut VarStore) -> Def {
         branches: vec![(
             no_region(RunLowLevel {
                 op: LowLevel::NumGt,
-                args: vec![(len_var, get_sub.clone()), (len_var, zero.clone())],
+                args: vec![(len_var, get_list_len), (len_var, Var(Symbol::ARG_2))],
                 ret_var: bool_var,
             }),
             no_region(get_sub),

compiler/gen_llvm/src/llvm/build.rs

@@ -6671,10 +6671,34 @@ fn build_int_binop<'a, 'ctx, 'env>(
             &LLVM_MUL_WITH_OVERFLOW[int_width],
             &[lhs.into(), rhs.into()],
         ),
-        NumGt => bd.build_int_compare(SGT, lhs, rhs, "int_gt").into(),
+        NumGt => {
-        NumGte => bd.build_int_compare(SGE, lhs, rhs, "int_gte").into(),
+            if int_width.is_signed() {
-        NumLt => bd.build_int_compare(SLT, lhs, rhs, "int_lt").into(),
+                bd.build_int_compare(SGT, lhs, rhs, "gt_int").into()
-        NumLte => bd.build_int_compare(SLE, lhs, rhs, "int_lte").into(),
+            } else {
+                bd.build_int_compare(UGT, lhs, rhs, "gt_uint").into()
+            }
+        }
+        NumGte => {
+            if int_width.is_signed() {
+                bd.build_int_compare(SGE, lhs, rhs, "gte_int").into()
+            } else {
+                bd.build_int_compare(UGE, lhs, rhs, "gte_uint").into()
+            }
+        }
+        NumLt => {
+            if int_width.is_signed() {
+                bd.build_int_compare(SLT, lhs, rhs, "lt_int").into()
+            } else {
+                bd.build_int_compare(ULT, lhs, rhs, "lt_uint").into()
+            }
+        }
+        NumLte => {
+            if int_width.is_signed() {
+                bd.build_int_compare(SLE, lhs, rhs, "lte_int").into()
+            } else {
+                bd.build_int_compare(ULE, lhs, rhs, "lte_uint").into()
+            }
+        }
         NumRemUnchecked => {
             if int_width.is_signed() {
                 bd.build_int_signed_rem(lhs, rhs, "rem_int").into()

compiler/gen_wasm/src/low_level.rs

@@ -116,6 +116,13 @@ impl From<&StoredValue> for CodeGenNumType {
     }
 }
 
+fn integer_symbol_is_signed(backend: &WasmBackend<'_>, symbol: Symbol) -> bool {
+    return match backend.storage.symbol_layouts[&symbol] {
+        Layout::Builtin(Builtin::Int(int_width)) => int_width.is_signed(),
+        x => internal_error!("Expected integer, found {:?}", x),
+    };
+}
+
 pub struct LowLevelCall<'a> {
     pub lowlevel: LowLevel,
     pub arguments: &'a [Symbol],
@@ -377,8 +384,20 @@ impl<'a> LowLevelCall<'a> {
             NumGt => {
                 self.load_args(backend);
                 match CodeGenNumType::for_symbol(backend, self.arguments[0]) {
-                    I32 => backend.code_builder.i32_gt_s(),
+                    I32 => {
-                    I64 => backend.code_builder.i64_gt_s(),
+                        if integer_symbol_is_signed(backend, self.arguments[0]) {
+                            backend.code_builder.i32_gt_s()
+                        } else {
+                            backend.code_builder.i32_gt_u()
+                        }
+                    }
+                    I64 => {
+                        if integer_symbol_is_signed(backend, self.arguments[0]) {
+                            backend.code_builder.i64_gt_s()
+                        } else {
+                            backend.code_builder.i64_gt_u()
+                        }
+                    }
                     F32 => backend.code_builder.f32_gt(),
                     F64 => backend.code_builder.f64_gt(),
                     x => todo!("{:?} for {:?}", self.lowlevel, x),
@@ -387,8 +406,20 @@ impl<'a> LowLevelCall<'a> {
             NumGte => {
                 self.load_args(backend);
                 match CodeGenNumType::for_symbol(backend, self.arguments[0]) {
-                    I32 => backend.code_builder.i32_ge_s(),
+                    I32 => {
-                    I64 => backend.code_builder.i64_ge_s(),
+                        if integer_symbol_is_signed(backend, self.arguments[0]) {
+                            backend.code_builder.i32_ge_s()
+                        } else {
+                            backend.code_builder.i32_ge_u()
+                        }
+                    }
+                    I64 => {
+                        if integer_symbol_is_signed(backend, self.arguments[0]) {
+                            backend.code_builder.i64_ge_s()
+                        } else {
+                            backend.code_builder.i64_ge_u()
+                        }
+                    }
                     F32 => backend.code_builder.f32_ge(),
                     F64 => backend.code_builder.f64_ge(),
                     x => todo!("{:?} for {:?}", self.lowlevel, x),
@@ -397,8 +428,20 @@ impl<'a> LowLevelCall<'a> {
             NumLt => {
                 self.load_args(backend);
                 match CodeGenNumType::for_symbol(backend, self.arguments[0]) {
-                    I32 => backend.code_builder.i32_lt_s(),
+                    I32 => {
-                    I64 => backend.code_builder.i64_lt_s(),
+                        if integer_symbol_is_signed(backend, self.arguments[0]) {
+                            backend.code_builder.i32_lt_s()
+                        } else {
+                            backend.code_builder.i32_lt_u()
+                        }
+                    }
+                    I64 => {
+                        if integer_symbol_is_signed(backend, self.arguments[0]) {
+                            backend.code_builder.i64_lt_s()
+                        } else {
+                            backend.code_builder.i64_lt_u()
+                        }
+                    }
                     F32 => backend.code_builder.f32_lt(),
                     F64 => backend.code_builder.f64_lt(),
                     x => todo!("{:?} for {:?}", self.lowlevel, x),
@@ -407,8 +450,20 @@ impl<'a> LowLevelCall<'a> {
             NumLte => {
                 self.load_args(backend);
                 match CodeGenNumType::for_symbol(backend, self.arguments[0]) {
-                    I32 => backend.code_builder.i32_le_s(),
+                    I32 => {
-                    I64 => backend.code_builder.i64_le_s(),
+                        if integer_symbol_is_signed(backend, self.arguments[0]) {
+                            backend.code_builder.i32_le_s()
+                        } else {
+                            backend.code_builder.i32_le_u()
+                        }
+                    }
+                    I64 => {
+                        if integer_symbol_is_signed(backend, self.arguments[0]) {
+                            backend.code_builder.i64_le_s()
+                        } else {
+                            backend.code_builder.i64_le_u()
+                        }
+                    }
                     F32 => backend.code_builder.f32_le(),
                     F64 => backend.code_builder.f64_le(),
                     x => todo!("{:?} for {:?}", self.lowlevel, x),

compiler/mono/src/code_gen_help/mod.rs

@@ -83,7 +83,7 @@ pub struct CodeGenHelp<'a> {
 
 impl<'a> CodeGenHelp<'a> {
     pub fn new(arena: &'a Bump, target_info: TargetInfo, home: ModuleId) -> Self {
-        let layout_isize = Layout::usize(target_info);
+        let layout_isize = Layout::isize(target_info);
 
         // Refcount is a boxed isize. TODO: use the new Box layout when dev backends support it
         let union_refcount = UnionLayout::NonNullableUnwrapped(arena.alloc([layout_isize]));

compiler/test_gen/src/gen_num.rs

@@ -1210,6 +1210,86 @@ fn bitwise_or() {
     assert_evals_to!("Num.bitwiseOr 1 2", 3, i64);
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+fn lt_u8() {
+    assert_evals_to!("1u8 < 2u8", true, bool);
+    assert_evals_to!("1u8 < 1u8", false, bool);
+    assert_evals_to!("2u8 < 1u8", false, bool);
+    assert_evals_to!("0u8 < 0u8", false, bool);
+    assert_evals_to!("128u8 < 0u8", false, bool);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+fn lte_u8() {
+    assert_evals_to!("1u8 <= 1u8", true, bool);
+    assert_evals_to!("2u8 <= 1u8", false, bool);
+    assert_evals_to!("1u8 <= 2u8", true, bool);
+    assert_evals_to!("0u8 <= 0u8", true, bool);
+    assert_evals_to!("128u8 <= 0u8", false, bool);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+fn gt_u8() {
+    assert_evals_to!("2u8 > 1u8", true, bool);
+    assert_evals_to!("2u8 > 2u8", false, bool);
+    assert_evals_to!("1u8 > 1u8", false, bool);
+    assert_evals_to!("0u8 > 0u8", false, bool);
+    assert_evals_to!("0u8 > 128u8", false, bool);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+fn gte_u8() {
+    assert_evals_to!("1u8 >= 1u8", true, bool);
+    assert_evals_to!("1u8 >= 2u8", false, bool);
+    assert_evals_to!("2u8 >= 1u8", true, bool);
+    assert_evals_to!("0u8 >= 0u8", true, bool);
+    assert_evals_to!("0u8 >= 128u8", false, bool);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+fn lt_u64() {
+    assert_evals_to!("1u64 < 2u64", true, bool);
+    assert_evals_to!("1u64 < 1u64", false, bool);
+    assert_evals_to!("2u64 < 1u64", false, bool);
+    assert_evals_to!("0u64 < 0u64", false, bool);
+    assert_evals_to!("9223372036854775808u64 < 0u64", false, bool);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+fn lte_u64() {
+    assert_evals_to!("1u64 <= 1u64", true, bool);
+    assert_evals_to!("2u64 <= 1u64", false, bool);
+    assert_evals_to!("1u64 <= 2u64", true, bool);
+    assert_evals_to!("0u64 <= 0u64", true, bool);
+    assert_evals_to!("9223372036854775808u64 <= 0u64", false, bool);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+fn gt_u64() {
+    assert_evals_to!("2u64 > 1u64", true, bool);
+    assert_evals_to!("2u64 > 2u64", false, bool);
+    assert_evals_to!("1u64 > 1u64", false, bool);
+    assert_evals_to!("0u64 > 0u64", false, bool);
+    assert_evals_to!("0u64 > 9223372036854775808u64", false, bool);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
+fn gte_u64() {
+    assert_evals_to!("1u64 >= 1u64", true, bool);
+    assert_evals_to!("1u64 >= 2u64", false, bool);
+    assert_evals_to!("2u64 >= 1u64", true, bool);
+    assert_evals_to!("0u64 >= 0u64", true, bool);
+    assert_evals_to!("0u64 >= 9223372036854775808u64", false, bool);
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
 fn lt_i64() {

compiler/test_mono/generated/factorial.txt

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

compiler/test_mono/generated/has_none.txt

@@ -1,30 +1,30 @@
-procedure Test.3 (Test.29):
+procedure Test.4 (Test.30):
-    joinpoint Test.13 Test.4:
+    joinpoint Test.14 Test.5:
-        let Test.23 : Int1 = 1i64;
+        let Test.24 : Int1 = 1i64;
-        let Test.24 : Int1 = GetTagId Test.4;
+        let Test.25 : Int1 = GetTagId Test.5;
-        let Test.25 : Int1 = lowlevel Eq Test.23 Test.24;
+        let Test.26 : Int1 = lowlevel Eq Test.24 Test.25;
-        if Test.25 then
+        if Test.26 then
-            let Test.14 : Int1 = false;
+            let Test.15 : Int1 = false;
-            ret Test.14;
-        else
-            let Test.19 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.4;
-            let Test.20 : U8 = 1i64;
-            let Test.21 : U8 = GetTagId Test.19;
-            let Test.22 : Int1 = lowlevel Eq Test.20 Test.21;
-            if Test.22 then
-                let Test.15 : Int1 = true;
             ret Test.15;
         else
-                let Test.7 : [<rnu><null>, C [C I64, C ] *self] = UnionAtIndex (Id 0) (Index 1) Test.4;
+            let Test.20 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.5;
-                jump Test.13 Test.7;
+            let Test.21 : U8 = 1i64;
+            let Test.22 : U8 = GetTagId Test.20;
+            let Test.23 : Int1 = lowlevel Eq Test.21 Test.22;
+            if Test.23 then
+                let Test.16 : Int1 = true;
+                ret Test.16;
+            else
+                let Test.8 : [<rnu><null>, C [C I64, C ] *self] = UnionAtIndex (Id 0) (Index 1) Test.5;
+                jump Test.14 Test.8;
     in
-    jump Test.13 Test.29;
+    jump Test.14 Test.30;
 
 procedure Test.0 ():
-    let Test.28 : I64 = 3i64;
+    let Test.29 : I64 = 3i64;
-    let Test.26 : [C I64, C ] = Just Test.28;
+    let Test.27 : [C I64, C ] = Just Test.29;
-    let Test.27 : [<rnu><null>, C [C I64, C ] *self] = Nil ;
+    let Test.28 : [<rnu><null>, C [C I64, C ] *self] = Nil ;
-    let Test.12 : [<rnu><null>, C [C I64, C ] *self] = Cons Test.26 Test.27;
+    let Test.13 : [<rnu><null>, C [C I64, C ] *self] = Cons Test.27 Test.28;
-    let Test.11 : Int1 = CallByName Test.3 Test.12;
+    let Test.12 : Int1 = CallByName Test.4 Test.13;
-    dec Test.12;
+    dec Test.13;
-    ret Test.11;
+    ret Test.12;

compiler/test_mono/generated/ir_int_add.txt

@@ -3,8 +3,8 @@ procedure List.6 (#Attr.2):
     ret List.139;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.230 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.230;
+    ret Num.275;
 
 procedure Test.0 ():
     let Test.8 : U64 = 5i64;

compiler/test_mono/generated/ir_plus.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 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.228 : I64 = lowlevel NumRound #Attr.2;
+    let Num.273 : I64 = lowlevel NumRound #Attr.2;
-    ret Num.228;
+    ret Num.273;
 
 procedure Test.0 ():
     let Test.2 : Float64 = 3.6f64;

compiler/test_mono/generated/ir_two_defs.txt

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

compiler/test_mono/generated/ir_when_idiv.txt

@@ -1,14 +1,14 @@
 procedure Num.40 (#Attr.2, #Attr.3):
-    let Num.233 : I64 = 0i64;
+    let Num.278 : I64 = 0i64;
-    let Num.230 : Int1 = lowlevel NotEq #Attr.3 Num.233;
+    let Num.275 : Int1 = lowlevel NotEq #Attr.3 Num.278;
-    if Num.230 then
+    if Num.275 then
-        let Num.232 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
+        let Num.277 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
-        let Num.231 : [C {}, C I64] = Ok Num.232;
+        let Num.276 : [C {}, C I64] = Ok Num.277;
-        ret Num.231;
+        ret Num.276;
     else
-        let Num.229 : {} = Struct {};
+        let Num.274 : {} = Struct {};
-        let Num.228 : [C {}, C I64] = Err Num.229;
+        let Num.273 : [C {}, C I64] = Err Num.274;
-        ret Num.228;
+        ret Num.273;
 
 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.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 procedure Test.0 ():
     let Test.10 : I64 = 41i64;

compiler/test_mono/generated/is_nil.txt

@@ -1,18 +1,18 @@
-procedure Test.2 (Test.3):
+procedure Test.3 (Test.4):
-    let Test.12 : Int1 = 1i64;
+    let Test.13 : Int1 = 1i64;
-    let Test.13 : Int1 = GetTagId Test.3;
+    let Test.14 : Int1 = GetTagId Test.4;
-    let Test.14 : Int1 = lowlevel Eq Test.12 Test.13;
+    let Test.15 : Int1 = lowlevel Eq Test.13 Test.14;
-    if Test.14 then
+    if Test.15 then
-        let Test.10 : Int1 = true;
+        let Test.11 : Int1 = true;
-        ret Test.10;
-    else
-        let Test.11 : Int1 = false;
         ret Test.11;
+    else
+        let Test.12 : Int1 = false;
+        ret Test.12;
 
 procedure Test.0 ():
-    let Test.15 : I64 = 2i64;
+    let Test.16 : I64 = 2i64;
-    let Test.16 : [<rnu><null>, C I64 *self] = Nil ;
+    let Test.17 : [<rnu><null>, C I64 *self] = Nil ;
-    let Test.9 : [<rnu><null>, C I64 *self] = Cons Test.15 Test.16;
+    let Test.10 : [<rnu><null>, C I64 *self] = Cons Test.16 Test.17;
-    let Test.8 : Int1 = CallByName Test.2 Test.9;
+    let Test.9 : Int1 = CallByName Test.3 Test.10;
-    dec Test.9;
+    dec Test.10;
-    ret Test.8;
+    ret Test.9;

compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt

@@ -14,17 +14,17 @@ procedure List.9 (#Attr.2):
 
 procedure Str.27 (#Attr.2):
     let #Attr.3 : {I64, U8} = lowlevel StrToNum #Attr.2;
-    let Str.69 : U8 = StructAtIndex 1 #Attr.3;
+    let Str.70 : U8 = StructAtIndex 1 #Attr.3;
-    let Str.70 : U8 = 0i64;
+    let Str.71 : U8 = 0i64;
-    let Str.66 : Int1 = lowlevel NumGt Str.69 Str.70;
+    let Str.67 : Int1 = lowlevel NumGt Str.70 Str.71;
-    if Str.66 then
+    if Str.67 then
-        let Str.68 : Int1 = false;
+        let Str.69 : Int1 = false;
-        let Str.67 : [C Int1, C I64] = Err Str.68;
+        let Str.68 : [C Int1, C I64] = Err Str.69;
-        ret Str.67;
+        ret Str.68;
     else
-        let Str.65 : I64 = StructAtIndex 0 #Attr.3;
+        let Str.66 : I64 = StructAtIndex 0 #Attr.3;
-        let Str.64 : [C Int1, C I64] = Ok Str.65;
+        let Str.65 : [C Int1, C I64] = Ok Str.66;
-        ret Str.64;
+        ret Str.65;
 
 procedure Test.0 ():
     let Test.4 : Int1 = true;

compiler/test_mono/generated/issue_2810.txt

@@ -1,6 +1,6 @@
 procedure Test.0 ():
-    let Test.16 : [C [<rnnu>C [C *self, C ]], C ] = SystemTool ;
+    let Test.19 : [C [<rnnu>C [C *self, C ]], C ] = SystemTool ;
-    let Test.14 : [<rnnu>C [C *self, C ]] = Job Test.16;
+    let Test.17 : [<rnnu>C [C *self, C ]] = Job Test.19;
-    let Test.13 : [C [<rnnu>C [C *self, C ]], C ] = FromJob Test.14;
+    let Test.16 : [C [<rnnu>C [C *self, C ]], C ] = FromJob Test.17;
-    let Test.4 : [<rnnu>C [C *self, C ]] = Job Test.13;
+    let Test.7 : [<rnnu>C [C *self, C ]] = Job Test.16;
-    ret Test.4;
+    ret Test.7;

compiler/test_mono/generated/linked_list_length_twice.txt

@@ -1,25 +1,25 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.229;
+    ret Num.274;
 
-procedure Test.3 (Test.5):
+procedure Test.4 (Test.6):
-    let Test.15 : Int1 = 1i64;
+    let Test.16 : Int1 = 1i64;
-    let Test.16 : Int1 = GetTagId Test.5;
+    let Test.17 : Int1 = GetTagId Test.6;
-    let Test.17 : Int1 = lowlevel Eq Test.15 Test.16;
+    let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
-    if Test.17 then
+    if Test.18 then
-        let Test.11 : I64 = 0i64;
+        let Test.12 : I64 = 0i64;
-        ret Test.11;
-    else
-        let Test.6 : [<rnu><null>, C I64 *self] = UnionAtIndex (Id 0) (Index 1) Test.5;
-        let Test.13 : I64 = 1i64;
-        let Test.14 : I64 = CallByName Test.3 Test.6;
-        let Test.12 : I64 = CallByName Num.19 Test.13 Test.14;
         ret Test.12;
+    else
+        let Test.7 : [<rnu><null>, C I64 *self] = UnionAtIndex (Id 0) (Index 1) Test.6;
+        let Test.14 : I64 = 1i64;
+        let Test.15 : I64 = CallByName Test.4 Test.7;
+        let Test.13 : I64 = CallByName Num.19 Test.14 Test.15;
+        ret Test.13;
 
 procedure Test.0 ():
-    let Test.2 : [<rnu><null>, C I64 *self] = Nil ;
+    let Test.3 : [<rnu><null>, C I64 *self] = Nil ;
-    let Test.8 : I64 = CallByName Test.3 Test.2;
+    let Test.9 : I64 = CallByName Test.4 Test.3;
-    let Test.9 : I64 = CallByName Test.3 Test.2;
+    let Test.10 : I64 = CallByName Test.4 Test.3;
-    dec Test.2;
+    dec Test.3;
-    let Test.7 : I64 = CallByName Num.19 Test.8 Test.9;
+    let Test.8 : I64 = CallByName Num.19 Test.9 Test.10;
-    ret Test.7;
+    ret Test.8;

compiler/test_mono/generated/list_cannot_update_inplace.txt

@@ -20,8 +20,8 @@ procedure List.6 (#Attr.2):
     ret List.140;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.228 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 procedure Test.1 ():
     let Test.8 : List I64 = Array [1i64, 2i64, 3i64];

compiler/test_mono/generated/list_len.txt

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

compiler/test_mono/generated/monomorphized_ints_aliased.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.228 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 procedure Test.5 (Test.7, Test.8):
     let Test.17 : U64 = 1i64;

compiler/test_mono/generated/nested_pattern_match.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 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.230 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.275 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.230;
+    ret Num.275;
 
 procedure Test.1 (Test.6):
     let Test.21 : Int1 = false;

compiler/test_mono/generated/peano.txt

@@ -1,6 +1,6 @@
 procedure Test.0 ():
-    let Test.10 : [<rnu><null>, C *self] = Z ;
+    let Test.11 : [<rnu><null>, C *self] = Z ;
+    let Test.10 : [<rnu><null>, C *self] = S Test.11;
     let Test.9 : [<rnu><null>, C *self] = S Test.10;
-    let Test.8 : [<rnu><null>, C *self] = S Test.9;
+    let Test.3 : [<rnu><null>, C *self] = S Test.9;
-    let Test.2 : [<rnu><null>, C *self] = S Test.8;
+    ret Test.3;
-    ret Test.2;

compiler/test_mono/generated/peano1.txt

@@ -1,15 +1,15 @@
 procedure Test.0 ():
-    let Test.14 : [<rnu><null>, C *self] = Z ;
+    let Test.15 : [<rnu><null>, C *self] = Z ;
+    let Test.14 : [<rnu><null>, C *self] = S Test.15;
     let Test.13 : [<rnu><null>, C *self] = S Test.14;
-    let Test.12 : [<rnu><null>, C *self] = S Test.13;
+    let Test.3 : [<rnu><null>, C *self] = S Test.13;
-    let Test.2 : [<rnu><null>, C *self] = S Test.12;
+    let Test.10 : Int1 = 1i64;
-    let Test.9 : Int1 = 1i64;
+    let Test.11 : Int1 = GetTagId Test.3;
-    let Test.10 : Int1 = GetTagId Test.2;
+    dec Test.3;
-    dec Test.2;
+    let Test.12 : Int1 = lowlevel Eq Test.10 Test.11;
-    let Test.11 : Int1 = lowlevel Eq Test.9 Test.10;
+    if Test.12 then
-    if Test.11 then
+        let Test.8 : I64 = 0i64;
-        let Test.7 : I64 = 0i64;
-        ret Test.7;
-    else
-        let Test.8 : I64 = 1i64;
         ret Test.8;
+    else
+        let Test.9 : I64 = 1i64;
+        ret Test.9;

compiler/test_mono/generated/peano2.txt

@@ -1,26 +1,26 @@
 procedure Test.0 ():
-    let Test.20 : [<rnu><null>, C *self] = Z ;
+    let Test.21 : [<rnu><null>, C *self] = Z ;
+    let Test.20 : [<rnu><null>, C *self] = S Test.21;
     let Test.19 : [<rnu><null>, C *self] = S Test.20;
-    let Test.18 : [<rnu><null>, C *self] = S Test.19;
+    let Test.3 : [<rnu><null>, C *self] = S Test.19;
-    let Test.2 : [<rnu><null>, C *self] = S Test.18;
+    let Test.16 : Int1 = 0i64;
-    let Test.15 : Int1 = 0i64;
+    let Test.17 : Int1 = GetTagId Test.3;
-    let Test.16 : Int1 = GetTagId Test.2;
+    let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
-    let Test.17 : Int1 = lowlevel Eq Test.15 Test.16;
+    if Test.18 then
-    if Test.17 then
+        let Test.12 : [<rnu><null>, C *self] = UnionAtIndex (Id 0) (Index 0) Test.3;
-        let Test.11 : [<rnu><null>, C *self] = UnionAtIndex (Id 0) (Index 0) Test.2;
+        inc Test.12;
-        inc Test.11;
+        dec Test.3;
-        dec Test.2;
+        let Test.13 : Int1 = 0i64;
-        let Test.12 : Int1 = 0i64;
+        let Test.14 : Int1 = GetTagId Test.12;
-        let Test.13 : Int1 = GetTagId Test.11;
+        dec Test.12;
-        dec Test.11;
+        let Test.15 : Int1 = lowlevel Eq Test.13 Test.14;
-        let Test.14 : Int1 = lowlevel Eq Test.12 Test.13;
+        if Test.15 then
-        if Test.14 then
+            let Test.8 : I64 = 1i64;
-            let Test.7 : I64 = 1i64;
-            ret Test.7;
-        else
-            let Test.8 : I64 = 0i64;
             ret Test.8;
         else
-        dec Test.2;
             let Test.9 : I64 = 0i64;
             ret Test.9;
+    else
+        dec Test.3;
+        let Test.10 : I64 = 0i64;
+        ret Test.10;

compiler/test_mono/generated/quicksort_help.txt

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

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.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 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,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 procedure Test.1 (Test.4):
     let Test.8 : I64 = 10i64;

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.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 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.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 procedure Test.1 (Test.2):
     let Test.3 : I64 = 10i64;

compiler/test_mono/generated/somehow_drops_definitions.txt

@@ -1,10 +1,10 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.229;
+    ret Num.274;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 procedure Test.1 ():
     let Test.26 : I64 = 1i64;

compiler/test_mono/generated/specialize_ability_call.txt

@@ -1,7 +1,7 @@
-procedure Test.5 (Test.7):
+procedure Test.7 (Test.9):
-    ret Test.7;
+    ret Test.9;
 
 procedure Test.0 ():
-    let Test.9 : U64 = 1234i64;
+    let Test.11 : U64 = 1234i64;
-    let Test.8 : U64 = CallByName Test.5 Test.9;
+    let Test.10 : U64 = CallByName Test.7 Test.11;
-    ret Test.8;
+    ret Test.10;

compiler/test_mono/generated/specialize_closures.txt

@@ -1,10 +1,10 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.229;
+    ret Num.274;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 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.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.229;
+    ret Num.274;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 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.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 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.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 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.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.228;
+    ret Num.273;
 
 procedure Test.0 ():
     let Test.15 : I64 = 3i64;