Merge remote-tracking branch 'origin/main' into remove-nat

crates/compiler/builtins/bitcode/src/dec.zig

@@ -24,6 +24,9 @@ pub const RocDec = extern struct {
     pub const one_point_zero_i128: i128 = math.pow(i128, 10, RocDec.decimal_places);
     pub const one_point_zero: RocDec = .{ .num = one_point_zero_i128 };
 
+    pub const two_point_zero: RocDec = RocDec.add(RocDec.one_point_zero, RocDec.one_point_zero);
+    pub const zero_point_five: RocDec = RocDec.div(RocDec.one_point_zero, RocDec.two_point_zero);
+
     pub fn fromU64(num: u64) RocDec {
         return .{ .num = num * one_point_zero_i128 };
     }
@@ -340,6 +343,54 @@ pub const RocDec = extern struct {
         }
     }
 
+    fn trunc(self: RocDec) RocDec {
+        return RocDec.sub(self, self.fract());
+    }
+
+    fn fract(self: RocDec) RocDec {
+        const sign = std.math.sign(self.num);
+        const digits = @mod(sign * self.num, RocDec.one_point_zero.num);
+
+        return RocDec{ .num = sign * digits };
+    }
+
+    // Returns the nearest integer to self. If a value is half-way between two integers, round away from 0.0.
+    fn round(arg1: RocDec) RocDec {
+        // this rounds towards zero
+        const tmp = arg1.trunc();
+
+        const sign = std.math.sign(arg1.num);
+        const abs_fract = sign * arg1.fract().num;
+
+        if (abs_fract >= RocDec.zero_point_five.num) {
+            return RocDec.add(tmp, RocDec{ .num = sign * RocDec.one_point_zero.num });
+        } else {
+            return tmp;
+        }
+    }
+
+    // Returns the largest integer less than or equal to itself
+    fn floor(arg1: RocDec) RocDec {
+        const tmp = arg1.trunc();
+
+        if (arg1.num < 0 and arg1.fract().num != 0) {
+            return RocDec.sub(tmp, RocDec.one_point_zero);
+        } else {
+            return tmp;
+        }
+    }
+
+    // Returns the smallest integer greater than or equal to itself
+    fn ceiling(arg1: RocDec) RocDec {
+        const tmp = arg1.trunc();
+
+        if (arg1.num > 0 and arg1.fract().num != 0) {
+            return RocDec.add(tmp, RocDec.one_point_zero);
+        } else {
+            return tmp;
+        }
+    }
+
     pub fn mul(self: RocDec, other: RocDec) RocDec {
         const answer = RocDec.mulWithOverflow(self, other);
 
@@ -1195,6 +1246,118 @@ test "log: 1" {
     try expectEqual(RocDec.fromU64(0), RocDec.log(RocDec.fromU64(1)));
 }
 
+test "fract: 0" {
+    var roc_str = RocStr.init("0", 1);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = 0 }, dec.fract());
+}
+
+test "fract: 1" {
+    var roc_str = RocStr.init("1", 1);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = 0 }, dec.fract());
+}
+
+test "fract: 123.45" {
+    var roc_str = RocStr.init("123.45", 6);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = 450000000000000000 }, dec.fract());
+}
+
+test "fract: -123.45" {
+    var roc_str = RocStr.init("-123.45", 7);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = -450000000000000000 }, dec.fract());
+}
+
+test "fract: .45" {
+    var roc_str = RocStr.init(".45", 3);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = 450000000000000000 }, dec.fract());
+}
+
+test "fract: -0.00045" {
+    const dec: RocDec = .{ .num = -450000000000000 };
+    const res = dec.fract();
+
+    try expectEqual(dec.num, res.num);
+}
+
+test "trunc: 0" {
+    var roc_str = RocStr.init("0", 1);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = 0 }, dec.trunc());
+}
+
+test "trunc: 1" {
+    var roc_str = RocStr.init("1", 1);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec.one_point_zero, dec.trunc());
+}
+
+test "trunc: 123.45" {
+    var roc_str = RocStr.init("123.45", 6);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = 123000000000000000000 }, dec.trunc());
+}
+
+test "trunc: -123.45" {
+    var roc_str = RocStr.init("-123.45", 7);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = -123000000000000000000 }, dec.trunc());
+}
+
+test "trunc: .45" {
+    var roc_str = RocStr.init(".45", 3);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = 0 }, dec.trunc());
+}
+
+test "trunc: -0.00045" {
+    const dec: RocDec = .{ .num = -450000000000000 };
+    const res = dec.trunc();
+
+    try expectEqual(RocDec{ .num = 0 }, res);
+}
+
+test "round: 123.45" {
+    var roc_str = RocStr.init("123.45", 6);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = 123000000000000000000 }, dec.round());
+}
+
+test "round: -123.45" {
+    var roc_str = RocStr.init("-123.45", 7);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = -123000000000000000000 }, dec.round());
+}
+
+test "round: 0.5" {
+    var roc_str = RocStr.init("0.5", 3);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec.one_point_zero, dec.round());
+}
+
+test "round: -0.5" {
+    var roc_str = RocStr.init("-0.5", 4);
+    var dec = RocDec.fromStr(roc_str).?;
+
+    try expectEqual(RocDec{ .num = -1000000000000000000 }, dec.round());
+}
+
 // exports
 
 pub fn fromStr(arg: RocStr) callconv(.C) num_.NumParseResult(i128) {
@@ -1342,3 +1505,30 @@ pub fn mulOrPanicC(arg1: RocDec, arg2: RocDec) callconv(.C) RocDec {
 pub fn mulSaturatedC(arg1: RocDec, arg2: RocDec) callconv(.C) RocDec {
     return @call(.always_inline, RocDec.mulSaturated, .{ arg1, arg2 });
 }
+
+pub fn exportRound(comptime T: type, comptime name: []const u8) void {
+    comptime var f = struct {
+        fn func(input: RocDec) callconv(.C) T {
+            return @as(T, @intCast(@divFloor(input.round().num, RocDec.one_point_zero_i128)));
+        }
+    }.func;
+    @export(f, .{ .name = name ++ @typeName(T), .linkage = .Strong });
+}
+
+pub fn exportFloor(comptime T: type, comptime name: []const u8) void {
+    comptime var f = struct {
+        fn func(input: RocDec) callconv(.C) T {
+            return @as(T, @intCast(@divFloor(input.floor().num, RocDec.one_point_zero_i128)));
+        }
+    }.func;
+    @export(f, .{ .name = name ++ @typeName(T), .linkage = .Strong });
+}
+
+pub fn exportCeiling(comptime T: type, comptime name: []const u8) void {
+    comptime var f = struct {
+        fn func(input: RocDec) callconv(.C) T {
+            return @as(T, @intCast(@divFloor(input.ceiling().num, RocDec.one_point_zero_i128)));
+        }
+    }.func;
+    @export(f, .{ .name = name ++ @typeName(T), .linkage = .Strong });
+}

crates/compiler/builtins/bitcode/src/main.zig

@@ -52,6 +52,10 @@ comptime {
 
     inline for (INTEGERS) |T| {
         dec.exportFromInt(T, ROC_BUILTINS ++ ".dec.from_int.");
+
+        dec.exportRound(T, ROC_BUILTINS ++ ".dec.round.");
+        dec.exportFloor(T, ROC_BUILTINS ++ ".dec.floor.");
+        dec.exportCeiling(T, ROC_BUILTINS ++ ".dec.ceiling.");
     }
 }
 

crates/compiler/builtins/roc/Num.roc

@@ -924,13 +924,21 @@ divCeilChecked = \a, b ->
 ## Num.divTrunc 8 -3
 ## ```
 divTrunc : Int a, Int a -> Int a
+divTrunc = \a, b ->
+    if Num.isZero b then
+        crash "Integer division by 0!"
+    else
+        Num.divTruncUnchecked a b
 
 divTruncChecked : Int a, Int a -> Result (Int a) [DivByZero]
 divTruncChecked = \a, b ->
     if Num.isZero b then
         Err DivByZero
     else
-        Ok (Num.divTrunc a b)
+        Ok (Num.divTruncUnchecked a b)
+
+## traps (hardware fault) when given zero as the second argument.
+divTruncUnchecked : Int a, Int a -> Int a
 
 ## Obtains the remainder (truncating modulo) from the division of two integers.
 ##
@@ -945,13 +953,21 @@ divTruncChecked = \a, b ->
 ## Num.rem -8 -3
 ## ```
 rem : Int a, Int a -> Int a
+rem = \a, b ->
+    if Num.isZero b then
+        crash "Integer division by 0!"
+    else
+        Num.remUnchecked a b
 
 remChecked : Int a, Int a -> Result (Int a) [DivByZero]
 remChecked = \a, b ->
     if Num.isZero b then
         Err DivByZero
     else
-        Ok (Num.rem a b)
+        Ok (Num.remUnchecked a b)
+
+## traps (hardware fault) when given zero as the second argument.
+remUnchecked : Int a, Int a -> Int a
 
 isMultipleOf : Int a, Int a -> Bool
 

crates/compiler/builtins/src/bitcode.rs

@@ -415,6 +415,9 @@ pub const DEC_SUB_WITH_OVERFLOW: &str = "roc_builtins.dec.sub_with_overflow";
 pub const DEC_TAN: &str = "roc_builtins.dec.tan";
 pub const DEC_TO_I128: &str = "roc_builtins.dec.to_i128";
 pub const DEC_TO_STR: &str = "roc_builtins.dec.to_str";
+pub const DEC_ROUND: IntrinsicName = int_intrinsic!("roc_builtins.dec.round");
+pub const DEC_FLOOR: IntrinsicName = int_intrinsic!("roc_builtins.dec.floor");
+pub const DEC_CEILING: IntrinsicName = int_intrinsic!("roc_builtins.dec.ceiling");
 
 pub const UTILS_DBG_IMPL: &str = "roc_builtins.utils.dbg_impl";
 pub const UTILS_TEST_PANIC: &str = "roc_builtins.utils.test_panic";

crates/compiler/can/src/builtins.rs

@@ -171,9 +171,9 @@ map_symbol_to_lowlevel_and_arity! {
     NumLte; NUM_LTE; 2,
     NumCompare; NUM_COMPARE; 2,
     NumDivFrac; NUM_DIV_FRAC; 2,
-    NumDivTruncUnchecked; NUM_DIV_TRUNC; 2,
+    NumDivTruncUnchecked; NUM_DIV_TRUNC_UNCHECKED; 2,
     NumDivCeilUnchecked; NUM_DIV_CEIL; 2,
-    NumRemUnchecked; NUM_REM; 2,
+    NumRemUnchecked; NUM_REM_UNCHECKED; 2,
     NumIsMultipleOf; NUM_IS_MULTIPLE_OF; 2,
     NumAbs; NUM_ABS; 1,
     NumNeg; NUM_NEG; 1,

crates/compiler/can/src/expr.rs

@@ -2600,10 +2600,38 @@ fn flatten_str_lines<'a>(
 fn desugar_str_segments(var_store: &mut VarStore, segments: Vec<StrSegment>) -> Expr {
     use StrSegment::*;
 
+    let n = segments.len();
     let mut iter = segments.into_iter().rev();
     let mut loc_expr = match iter.next() {
         Some(Plaintext(string)) => Loc::at(Region::zero(), Expr::Str(string)),
-        Some(Interpolation(loc_expr)) => loc_expr,
+        Some(Interpolation(loc_expr)) => {
+            if n == 1 {
+                // We concat with the empty string to ensure a type error when loc_expr is not a string
+                let empty_string = Loc::at(Region::zero(), Expr::Str("".into()));
+
+                let fn_expr = Loc::at(
+                    Region::zero(),
+                    Expr::Var(Symbol::STR_CONCAT, var_store.fresh()),
+                );
+                let expr = Expr::Call(
+                    Box::new((
+                        var_store.fresh(),
+                        fn_expr,
+                        var_store.fresh(),
+                        var_store.fresh(),
+                    )),
+                    vec![
+                        (var_store.fresh(), empty_string),
+                        (var_store.fresh(), loc_expr),
+                    ],
+                    CalledVia::StringInterpolation,
+                );
+
+                Loc::at(Region::zero(), expr)
+            } else {
+                loc_expr
+            }
+        }
         None => {
             // No segments? Empty string!
 

crates/compiler/gen_dev/src/generic64/mod.rs

@@ -3299,7 +3299,7 @@ impl<
         let elem_layout = arg_layouts[1];
 
         // List alignment argument (u32).
-        self.load_layout_alignment(*ret_layout, Symbol::DEV_TMP);
+        self.load_layout_alignment(elem_layout, Symbol::DEV_TMP);
 
         // Have to pass the input element by pointer, so put it on the stack and load it's address.
         self.storage_manager

crates/compiler/gen_dev/src/lib.rs

@@ -1106,30 +1106,36 @@ trait Backend<'a> {
                 self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
             }
 
+            LowLevel::NumRound => {
+                let repr = self.interner().get_repr(*ret_layout);
+                let LayoutRepr::Builtin(Builtin::Int(int_width)) = repr else {
+                    unreachable!("invalid return layout for NumRound")
+                };
+
+                let intrinsic = match arg_layouts[0] {
+                    Layout::F32 => &bitcode::NUM_ROUND_F32[int_width],
+                    Layout::F64 => &bitcode::NUM_ROUND_F64[int_width],
+                    Layout::DEC => &bitcode::DEC_ROUND[int_width],
+                    _ => unreachable!("invalid layout for NumRound"),
+                };
+
+                self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
+            }
+
             LowLevel::NumFloor => {
                 let repr = self.interner().get_repr(*ret_layout);
                 let LayoutRepr::Builtin(Builtin::Int(int_width)) = repr else {
                     unreachable!("invalid return layout for NumFloor")
                 };
 
-                match arg_layouts[0] {
-                    Layout::F32 => self.build_fn_call(
-                        sym,
-                        bitcode::NUM_FLOOR_F32[int_width].to_string(),
-                        args,
-                        arg_layouts,
-                        ret_layout,
-                    ),
-                    Layout::F64 => self.build_fn_call(
-                        sym,
-                        bitcode::NUM_FLOOR_F64[int_width].to_string(),
-                        args,
-                        arg_layouts,
-                        ret_layout,
-                    ),
-                    Layout::DEC => todo!("NumFloor for decimals"),
+                let intrinsic = match arg_layouts[0] {
+                    Layout::F32 => &bitcode::NUM_FLOOR_F32[int_width],
+                    Layout::F64 => &bitcode::NUM_FLOOR_F64[int_width],
+                    Layout::DEC => &bitcode::DEC_FLOOR[int_width],
                     _ => unreachable!("invalid layout for NumFloor"),
-                }
+                };
+
+                self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
             }
 
             LowLevel::NumCeiling => {
@@ -1138,24 +1144,14 @@ trait Backend<'a> {
                     unreachable!("invalid return layout for NumCeiling")
                 };
 
-                match arg_layouts[0] {
-                    Layout::F32 => self.build_fn_call(
-                        sym,
-                        bitcode::NUM_CEILING_F32[int_width].to_string(),
-                        args,
-                        arg_layouts,
-                        ret_layout,
-                    ),
-                    Layout::F64 => self.build_fn_call(
-                        sym,
-                        bitcode::NUM_CEILING_F64[int_width].to_string(),
-                        args,
-                        arg_layouts,
-                        ret_layout,
-                    ),
-                    Layout::DEC => todo!("NumCeiling for decimals"),
+                let intrinsic = match arg_layouts[0] {
+                    Layout::F32 => &bitcode::NUM_CEILING_F32[int_width],
+                    Layout::F64 => &bitcode::NUM_CEILING_F64[int_width],
+                    Layout::DEC => &bitcode::DEC_CEILING[int_width],
                     _ => unreachable!("invalid layout for NumCeiling"),
-                }
+                };
+
+                self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
             }
 
             LowLevel::NumSub => {
@@ -1494,13 +1490,6 @@ trait Backend<'a> {
 
                 self.build_fn_call(sym, intrinsic.to_string(), args, arg_layouts, ret_layout)
             }
-            LowLevel::NumRound => self.build_fn_call(
-                sym,
-                bitcode::NUM_ROUND_F64[IntWidth::I64].to_string(),
-                args,
-                arg_layouts,
-                ret_layout,
-            ),
             LowLevel::ListLen => {
                 debug_assert_eq!(
                     1,

crates/compiler/gen_llvm/src/llvm/lowlevel.rs

@@ -2141,11 +2141,13 @@ fn build_dec_unary_op<'a, 'ctx>(
     _layout_interner: &STLayoutInterner<'a>,
     _parent: FunctionValue<'ctx>,
     arg: BasicValueEnum<'ctx>,
-    _return_layout: InLayout<'a>,
+    return_layout: InLayout<'a>,
     op: LowLevel,
 ) -> BasicValueEnum<'ctx> {
     use roc_module::low_level::LowLevel::*;
 
+    let int_width = || return_layout.to_int_width();
+
     match op {
         NumAbs => dec_unary_op(env, bitcode::DEC_ABS, arg),
         NumAcos => dec_unary_op(env, bitcode::DEC_ACOS, arg),
@@ -2155,6 +2157,10 @@ fn build_dec_unary_op<'a, 'ctx>(
         NumSin => dec_unary_op(env, bitcode::DEC_SIN, arg),
         NumTan => dec_unary_op(env, bitcode::DEC_TAN, arg),
 
+        NumRound => dec_unary_op(env, &bitcode::DEC_ROUND[int_width()], arg),
+        NumFloor => dec_unary_op(env, &bitcode::DEC_FLOOR[int_width()], arg),
+        NumCeiling => dec_unary_op(env, &bitcode::DEC_CEILING[int_width()], arg),
+
         _ => {
             unreachable!("Unrecognized dec unary operation: {:?}", op);
         }
@@ -2636,42 +2642,39 @@ fn build_float_unary_op<'a, 'ctx>(
                 LayoutRepr::Builtin(Builtin::Int(int_width)) => int_width,
                 _ => internal_error!("Ceiling return layout is not int: {:?}", layout),
             };
-            match float_width {
-                FloatWidth::F32 => {
-                    call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_CEILING_F32[int_width])
-                }
-                FloatWidth::F64 => {
-                    call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_CEILING_F64[int_width])
-                }
-            }
+
+            let intrinsic = match float_width {
+                FloatWidth::F32 => &bitcode::NUM_CEILING_F32[int_width],
+                FloatWidth::F64 => &bitcode::NUM_CEILING_F64[int_width],
+            };
+
+            call_bitcode_fn(env, &[arg.into()], intrinsic)
         }
         NumFloor => {
             let int_width = match layout_interner.get_repr(layout) {
                 LayoutRepr::Builtin(Builtin::Int(int_width)) => int_width,
                 _ => internal_error!("Floor return layout is not int: {:?}", layout),
             };
-            match float_width {
-                FloatWidth::F32 => {
-                    call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_FLOOR_F32[int_width])
-                }
-                FloatWidth::F64 => {
-                    call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_FLOOR_F64[int_width])
-                }
-            }
+
+            let intrinsic = match float_width {
+                FloatWidth::F32 => &bitcode::NUM_FLOOR_F32[int_width],
+                FloatWidth::F64 => &bitcode::NUM_FLOOR_F64[int_width],
+            };
+
+            call_bitcode_fn(env, &[arg.into()], intrinsic)
         }
         NumRound => {
             let int_width = match layout_interner.get_repr(layout) {
                 LayoutRepr::Builtin(Builtin::Int(int_width)) => int_width,
                 _ => internal_error!("Round return layout is not int: {:?}", layout),
             };
-            match float_width {
-                FloatWidth::F32 => {
-                    call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_ROUND_F32[int_width])
-                }
-                FloatWidth::F64 => {
-                    call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_ROUND_F64[int_width])
-                }
-            }
+
+            let intrinsic = match float_width {
+                FloatWidth::F32 => &bitcode::NUM_ROUND_F32[int_width],
+                FloatWidth::F64 => &bitcode::NUM_ROUND_F64[int_width],
+            };
+
+            call_bitcode_fn(env, &[arg.into()], intrinsic)
         }
         NumIsNan => call_bitcode_fn(env, &[arg.into()], &bitcode::NUM_IS_NAN[float_width]),
         NumIsInfinite => {

crates/compiler/gen_wasm/src/low_level.rs

@@ -1640,6 +1640,7 @@ impl<'a> LowLevelCall<'a> {
                 match arg_type {
                     F32 => self.load_args_and_call_zig(backend, &bitcode::NUM_ROUND_F32[width]),
                     F64 => self.load_args_and_call_zig(backend, &bitcode::NUM_ROUND_F64[width]),
+                    Decimal => self.load_args_and_call_zig(backend, &bitcode::DEC_ROUND[width]),
                     _ => internal_error!("Invalid argument type for round: {:?}", arg_type),
                 }
             }
@@ -1647,6 +1648,14 @@ impl<'a> LowLevelCall<'a> {
                 self.load_args(backend);
                 let arg_type = CodeGenNumType::for_symbol(backend, self.arguments[0]);
                 let ret_type = CodeGenNumType::from(self.ret_layout);
+
+                let width = match ret_type {
+                    CodeGenNumType::I32 => IntWidth::I32,
+                    CodeGenNumType::I64 => IntWidth::I64,
+                    CodeGenNumType::I128 => todo!("{:?} for I128", self.lowlevel),
+                    _ => internal_error!("Invalid return type for round: {:?}", ret_type),
+                };
+
                 match (arg_type, self.lowlevel) {
                     (F32, NumCeiling) => {
                         backend.code_builder.f32_ceil();
@@ -1654,14 +1663,21 @@ impl<'a> LowLevelCall<'a> {
                     (F64, NumCeiling) => {
                         backend.code_builder.f64_ceil();
                     }
+                    (Decimal, NumCeiling) => {
+                        return self.load_args_and_call_zig(backend, &bitcode::DEC_CEILING[width]);
+                    }
                     (F32, NumFloor) => {
                         backend.code_builder.f32_floor();
                     }
                     (F64, NumFloor) => {
                         backend.code_builder.f64_floor();
                     }
+                    (Decimal, NumFloor) => {
+                        return self.load_args_and_call_zig(backend, &bitcode::DEC_FLOOR[width]);
+                    }
                     _ => internal_error!("Invalid argument type for ceiling: {:?}", arg_type),
                 }
+
                 match (ret_type, arg_type) {
                     // TODO: unsigned truncation
                     (I32, F32) => backend.code_builder.i32_trunc_s_f32(),

crates/compiler/gen_wasm/src/wasm32_sized.rs

@@ -75,19 +75,36 @@ impl Wasm32Sized for isize {
     const ALIGN_OF_WASM: usize = 4;
 }
 
+const fn next_multiple_of(lhs: usize, rhs: usize) -> usize {
+    if lhs == 0 {
+        return lhs;
+    }
+
+    match lhs % rhs {
+        0 => lhs,
+        r => lhs + (rhs - r),
+    }
+}
+
 impl<T: Wasm32Sized, U: Wasm32Sized> Wasm32Sized for (T, U) {
-    const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM;
+    const SIZE_OF_WASM: usize =
+        next_multiple_of(T::SIZE_OF_WASM + U::SIZE_OF_WASM, Self::ALIGN_OF_WASM);
     const ALIGN_OF_WASM: usize = max(&[T::ALIGN_OF_WASM, U::ALIGN_OF_WASM]);
 }
 
 impl<T: Wasm32Sized, U: Wasm32Sized, V: Wasm32Sized> Wasm32Sized for (T, U, V) {
-    const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM;
+    const SIZE_OF_WASM: usize = next_multiple_of(
+        T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM,
+        Self::ALIGN_OF_WASM,
+    );
     const ALIGN_OF_WASM: usize = max(&[T::ALIGN_OF_WASM, U::ALIGN_OF_WASM, V::ALIGN_OF_WASM]);
 }
 
 impl<T: Wasm32Sized, U: Wasm32Sized, V: Wasm32Sized, W: Wasm32Sized> Wasm32Sized for (T, U, V, W) {
-    const SIZE_OF_WASM: usize =
-        T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM + W::SIZE_OF_WASM;
+    const SIZE_OF_WASM: usize = next_multiple_of(
+        T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM + W::SIZE_OF_WASM,
+        Self::ALIGN_OF_WASM,
+    );
     const ALIGN_OF_WASM: usize = max(&[
         T::ALIGN_OF_WASM,
         U::ALIGN_OF_WASM,

crates/compiler/module/src/low_level.rs

@@ -304,8 +304,8 @@ map_symbol_to_lowlevel! {
     NumCompare <= NUM_COMPARE;
     NumDivFrac <= NUM_DIV_FRAC;
     NumDivCeilUnchecked <= NUM_DIV_CEIL;
-    NumDivTruncUnchecked <= NUM_DIV_TRUNC;
-    NumRemUnchecked <= NUM_REM;
+    NumDivTruncUnchecked <= NUM_DIV_TRUNC_UNCHECKED;
+    NumRemUnchecked <= NUM_REM_UNCHECKED;
     NumIsMultipleOf <= NUM_IS_MULTIPLE_OF;
     NumAbs <= NUM_ABS;
     NumNeg <= NUM_NEG;

crates/compiler/module/src/symbol.rs

@@ -1262,6 +1262,12 @@ define_builtins! {
         150 NUM_BITWISE_NOT: "bitwiseNot"
         151 NUM_INT_CAST: "intCast"
         152 NUM_IS_APPROX_EQ: "isApproxEq"
+        153 NUM_BYTES_TO_U16_LOWLEVEL: "bytesToU16Lowlevel"
+        154 NUM_BYTES_TO_U32_LOWLEVEL: "bytesToU32Lowlevel"
+        155 NUM_BYTES_TO_U64_LOWLEVEL: "bytesToU64Lowlevel"
+        156 NUM_BYTES_TO_U128_LOWLEVEL: "bytesToU128Lowlevel"
+        157 NUM_DIV_TRUNC_UNCHECKED: "divTruncUnchecked" // traps on division by zero
+        158 NUM_REM_UNCHECKED: "remUnchecked" // traps on division by zero
     }
     4 BOOL: "Bool" => {
         0 BOOL_BOOL: "Bool" exposed_type=true // the Bool.Bool type alias

crates/compiler/test_gen/src/gen_list.rs

@@ -910,6 +910,25 @@ fn list_prepend_big_list() {
     );
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn list_prepend_record() {
+    assert_evals_to!(
+        indoc!(
+            r"
+            payment1 : { amount: Dec, date: [RD I32] }
+            payment1 = { amount: 1dec, date: (RD 1000) }
+            payment2 : { amount: Dec, date: [RD I32] }
+            payment2 = { amount: 2dec, date: (RD 1001) }
+
+            List.prepend [payment2] payment1
+            "
+        ),
+        RocList::from_slice(&[(RocDec::from(1), 1000i32), (RocDec::from(2), 1001i32),]),
+        RocList<(RocDec, i32)>
+    );
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn list_walk_backwards_empty_all_inline() {

crates/compiler/test_gen/src/gen_num.rs

@@ -1154,19 +1154,20 @@ fn gen_div_u64() {
     assert_evals_to!("1000u64 // 10", 100, u64);
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+#[should_panic(expected = r#"User crash with message: "Integer division by 0!"#)]
+fn gen_div_by_zero_i64() {
+    assert_evals_to!("1i64 // 0", 100, i64);
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn gen_div_checked_i64() {
     assert_evals_to!(
-        indoc!(
-            r"
-                    when Num.divTruncChecked 1000 10 is
-                        Ok val -> val
-                        Err _ -> -1
-                "
-        ),
-        100,
-        i64
+        "Num.divTruncChecked 1000 10",
+        RocResult::ok(100),
+        RocResult<i64, ()>
     );
 }
 
@@ -1174,15 +1175,9 @@ fn gen_div_checked_i64() {
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn gen_div_checked_by_zero_i64() {
     assert_evals_to!(
-        indoc!(
-            r"
-                    when Num.divTruncChecked 1000 0 is
-                        Err DivByZero -> 99
-                        _ -> -24
-                "
-        ),
-        99,
-        i64
+        "Num.divTruncChecked 1000 0",
+        RocResult::err(()),
+        RocResult<i64, ()>
     );
 }
 
@@ -1192,19 +1187,30 @@ fn gen_rem_i64() {
     assert_evals_to!("Num.rem 8 3", 2, i64);
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+#[should_panic(expected = r#"User crash with message: "Integer division by 0!"#)]
+fn gen_rem_div_by_zero_i64() {
+    assert_evals_to!("Num.rem 42 0", 100, i64);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn gen_rem_checked_i64() {
+    assert_evals_to!(
+        "Num.remChecked 42 40",
+        RocResult::ok(2),
+        RocResult<i64, ()>
+    );
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
 fn gen_rem_checked_div_by_zero_i64() {
     assert_evals_to!(
-        indoc!(
-            r"
-            when Num.remChecked 8 0 is
-                Err DivByZero -> 4
-                Ok _ -> -23
-            "
-        ),
-        4,
-        i64
+        "Num.remChecked 8 0",
+        RocResult::err(()),
+        RocResult<i64, ()>
     );
 }
 
@@ -1825,15 +1831,56 @@ fn pow() {
 
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
-fn ceiling() {
-    assert_evals_to!("Num.ceiling 1.1f64", 2, i64);
+fn round_f64() {
+    assert_evals_to!("Num.round 1.9f64", 2, i64);
+    assert_evals_to!("Num.round -1.9f64", -2, i64);
+    assert_evals_to!("Num.round 0.5f64", 1, i64);
+    assert_evals_to!("Num.round -0.5f64", -1, i64);
 }
 
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
-fn floor() {
+fn round_dec() {
+    assert_evals_to!("Num.round 1.9dec", 2, i64);
+    assert_evals_to!("Num.round -1.9dec", -2, i64);
+    assert_evals_to!("Num.round 0.5dec", 1, i64);
+    assert_evals_to!("Num.round -0.5dec", -1, i64);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn ceiling_f64() {
+    assert_evals_to!("Num.ceiling 1.9f64", 2, i64);
+    assert_evals_to!("Num.ceiling -1.9f64", -1, i64);
+    assert_evals_to!("Num.ceiling 0.5f64", 1, i64);
+    assert_evals_to!("Num.ceiling -0.5f64", 0, i64);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn ceiling_dec() {
+    assert_evals_to!("Num.ceiling 1.9dec", 2, i64);
+    assert_evals_to!("Num.ceiling -1.9dec", -1, i64);
+    assert_evals_to!("Num.ceiling 0.5dec", 1, i64);
+    assert_evals_to!("Num.ceiling -0.5dec", 0, i64);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn floor_f64() {
     assert_evals_to!("Num.floor 1.9f64", 1, i64);
     assert_evals_to!("Num.floor -1.9f64", -2, i64);
+    assert_evals_to!("Num.floor 0.5f64", 0, i64);
+    assert_evals_to!("Num.floor -0.5f64", -1, i64);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn floor_dec() {
+    assert_evals_to!("Num.floor 1.9dec", 1, i64);
+    assert_evals_to!("Num.floor -1.9dec", -2, i64);
+    assert_evals_to!("Num.floor 0.5dec", 0, i64);
+    assert_evals_to!("Num.floor -0.5dec", -1, i64);
 }
 
 #[test]

crates/compiler/test_gen/src/helpers/from_wasm32_memory.rs

@@ -91,15 +91,11 @@ impl<T: FromWasm32Memory + Clone> FromWasm32Memory for RocList<T> {
         let capacity =
             <u32 as FromWasm32Memory>::decode(memory, offset + 4 * Builtin::WRAPPER_CAPACITY);
 
-        let mut items = Vec::with_capacity(length as usize);
+        let step = <T as Wasm32Sized>::SIZE_OF_WASM;
 
-        for i in 0..length {
-            let item = <T as FromWasm32Memory>::decode(
-                memory,
-                elements + i * <T as Wasm32Sized>::SIZE_OF_WASM as u32,
-            );
-            items.push(item);
-        }
+        let items: Vec<_> = (0..length)
+            .map(|i| <T as FromWasm32Memory>::decode(memory, elements + i * step as u32))
+            .collect();
 
         let mut list = RocList::with_capacity(capacity as usize);
         list.extend_from_slice(&items);

crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt

@@ -78,16 +78,16 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
     jump List.591 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.260;
+    let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.270;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.258 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Test.1 (Test.2):
     let Test.13 : U64 = 0i64;

crates/compiler/test_mono/generated/binary_tree_fbip.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.4 (Test.27):
     let Test.39 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = TagId(0) ;

crates/compiler/test_mono/generated/capture_void_layout_task.txt

@@ -28,12 +28,12 @@ procedure List.90 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.
     jump List.574 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.10 (Test.69, #Attr.12):
     let Test.72 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;

crates/compiler/test_mono/generated/choose_correct_recursion_var_under_record.txt

@@ -47,8 +47,8 @@ procedure List.9 (List.333):
         ret List.573;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Result.5 (Result.12, Result.13):
     let Result.39 : U8 = 1i64;

crates/compiler/test_mono/generated/choose_i128_layout.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.258 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Test.0 ():
     let Test.6 : I128 = 18446744073709551616i64;

crates/compiler/test_mono/generated/choose_u128_layout.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.0 ():
     let Test.2 : U128 = 170141183460469231731687303715884105728u128;

crates/compiler/test_mono/generated/choose_u64_layout.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.0 ():
     let Test.2 : U64 = 9999999999999999999i64;

crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt

@@ -32,12 +32,12 @@ procedure List.90 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
     jump List.574 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/dict.txt

@@ -30,8 +30,8 @@ procedure List.6 (#Attr.2):
     ret List.571;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.257 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.0 ():
     let Test.3 : {} = Struct {};

crates/compiler/test_mono/generated/empty_list_of_function_type.txt

@@ -25,8 +25,8 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.576;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.2 (Test.5):
     dec Test.5;

crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt

@@ -250,40 +250,40 @@ procedure List.90 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_g
     jump List.629 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49;
 
 procedure Num.127 (#Attr.2):
-    let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.272;
+    let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.282;
 
 procedure Num.137 (#Attr.2, #Attr.3):
-    let Num.277 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
-    ret Num.277;
+    let Num.287 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
+    ret Num.287;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.276 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.276;
-
-procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.273 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.273;
-
-procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.278 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.278;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
-
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    let Num.286 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Num.286;
 
+procedure Num.20 (#Attr.2, #Attr.3):
+    let Num.283 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.283;
+
+procedure Num.21 (#Attr.2, #Attr.3):
+    let Num.288 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.288;
+
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.294;
+
+procedure Num.24 (#Attr.2, #Attr.3):
+    let Num.296 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.296;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.295 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.295;
 
 procedure Str.12 (#Attr.2):
     let Str.261 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt

@@ -193,40 +193,40 @@ procedure List.90 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_g
     jump List.595 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
 
 procedure Num.127 (#Attr.2):
-    let Num.262 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.262;
+    let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.272;
 
 procedure Num.137 (#Attr.2, #Attr.3):
-    let Num.267 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
-    ret Num.267;
+    let Num.277 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
+    ret Num.277;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.266 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.266;
-
-procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.263 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.263;
-
-procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.268 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.268;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.274;
-
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.276 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    let Num.276 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Num.276;
 
+procedure Num.20 (#Attr.2, #Attr.3):
+    let Num.273 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.273;
+
+procedure Num.21 (#Attr.2, #Attr.3):
+    let Num.278 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.278;
+
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.284;
+
+procedure Num.24 (#Attr.2, #Attr.3):
+    let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.286;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.271 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.271;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.275 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.275;
+    let Num.285 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.285;
 
 procedure Str.12 (#Attr.2):
     let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt

@@ -200,40 +200,40 @@ procedure List.90 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_g
     jump List.595 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33 #Derived_gen.34;
 
 procedure Num.127 (#Attr.2):
-    let Num.262 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.262;
+    let Num.272 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.272;
 
 procedure Num.137 (#Attr.2, #Attr.3):
-    let Num.267 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
-    ret Num.267;
+    let Num.277 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
+    ret Num.277;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.266 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.266;
-
-procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.263 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.263;
-
-procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.268 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.268;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.274;
-
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.276 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    let Num.276 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Num.276;
 
+procedure Num.20 (#Attr.2, #Attr.3):
+    let Num.273 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.273;
+
+procedure Num.21 (#Attr.2, #Attr.3):
+    let Num.278 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.278;
+
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.284;
+
+procedure Num.24 (#Attr.2, #Attr.3):
+    let Num.286 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.286;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.271 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.271;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.275 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.275;
+    let Num.285 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.285;
 
 procedure Str.12 (#Attr.2):
     let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_string.txt

@@ -122,32 +122,32 @@ procedure List.90 (#Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen
     jump List.587 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12;
 
 procedure Num.137 (#Attr.2, #Attr.3):
-    let Num.259 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.260 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.260;
+    let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.270;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.264 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.264;
+    let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.274;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.266 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.266;
+    let Num.276 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.276;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.262 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.262;
+    let Num.272 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.272;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.265 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.265;
+    let Num.275 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.275;
 
 procedure Str.12 (#Attr.2):
     let Str.259 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt

@@ -195,40 +195,40 @@ procedure List.90 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_g
     jump List.601 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
 
 procedure Num.127 (#Attr.2):
-    let Num.264 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.264;
+    let Num.274 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.274;
 
 procedure Num.137 (#Attr.2, #Attr.3):
-    let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
-    ret Num.269;
+    let Num.279 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
+    ret Num.279;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.268;
-
-procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.265;
-
-procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.270;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.276;
-
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    let Num.278 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Num.278;
 
+procedure Num.20 (#Attr.2, #Attr.3):
+    let Num.275 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.275;
+
+procedure Num.21 (#Attr.2, #Attr.3):
+    let Num.280 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.280;
+
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.286;
+
+procedure Num.24 (#Attr.2, #Attr.3):
+    let Num.288 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.288;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.273 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.273;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.277 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.277;
+    let Num.287 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.287;
 
 procedure Str.12 (#Attr.2):
     let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt

@@ -198,40 +198,40 @@ procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_g
     jump List.613 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
 
 procedure Num.127 (#Attr.2):
-    let Num.264 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.264;
+    let Num.274 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.274;
 
 procedure Num.137 (#Attr.2, #Attr.3):
-    let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
-    ret Num.269;
+    let Num.279 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
+    ret Num.279;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.268;
-
-procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.265;
-
-procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.270;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.276;
-
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    let Num.278 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Num.278;
 
+procedure Num.20 (#Attr.2, #Attr.3):
+    let Num.275 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.275;
+
+procedure Num.21 (#Attr.2, #Attr.3):
+    let Num.280 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.280;
+
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.286;
+
+procedure Num.24 (#Attr.2, #Attr.3):
+    let Num.288 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.288;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.273 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.273;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.277 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.277;
+    let Num.287 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.287;
 
 procedure Str.12 (#Attr.2):
     let Str.260 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/factorial.txt

@@ -1,10 +1,10 @@
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
     joinpoint Test.7 Test.2 Test.3:

crates/compiler/test_mono/generated/function_specialization_information_in_lambda_set_thunk.txt

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

crates/compiler/test_mono/generated/function_specialization_information_in_lambda_set_thunk_independent_defs.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.258 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Test.1 (Test.9):
     let Test.4 : U8 = 10i64;

crates/compiler/test_mono/generated/inline_return_joinpoints_in_bool_lambda_set.txt

@@ -3,8 +3,8 @@ procedure Bool.1 ():
     ret Bool.23;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.3 (Test.4):
     ret Test.4;

crates/compiler/test_mono/generated/inline_return_joinpoints_in_enum_lambda_set.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.259 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Test.2 (Test.3):
     switch Test.3:

crates/compiler/test_mono/generated/inline_return_joinpoints_in_union_lambda_set.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Test.2 (Test.3, Test.1):
     let Test.18 : Int1 = false;

crates/compiler/test_mono/generated/inspect_derived_dict.txt

@@ -1044,131 +1044,131 @@ procedure List.91 (#Derived_gen.45, #Derived_gen.46, #Derived_gen.47, #Derived_g
     jump List.613 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47 #Derived_gen.48 #Derived_gen.49;
 
 procedure Num.131 (#Attr.2):
-    let Num.265 : U32 = lowlevel NumIntCast #Attr.2;
-    ret Num.265;
+    let Num.275 : U32 = lowlevel NumIntCast #Attr.2;
+    ret Num.275;
 
 procedure Num.133 (#Attr.2):
-    let Num.273 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.273;
+    let Num.283 : U64 = lowlevel NumIntCast #Attr.2;
+    ret Num.283;
 
 procedure Num.133 (#Attr.2):
-    let Num.322 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.322;
+    let Num.332 : U64 = lowlevel NumIntCast #Attr.2;
+    ret Num.332;
 
 procedure Num.133 (#Attr.2):
-    let Num.337 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.337;
+    let Num.347 : U64 = lowlevel NumIntCast #Attr.2;
+    ret Num.347;
 
 procedure Num.135 (#Attr.2):
-    let Num.343 : U128 = lowlevel NumIntCast #Attr.2;
-    ret Num.343;
+    let Num.353 : U128 = lowlevel NumIntCast #Attr.2;
+    ret Num.353;
 
 procedure Num.139 (#Attr.2):
-    let Num.291 : Float32 = lowlevel NumToFloatCast #Attr.2;
-    ret Num.291;
+    let Num.301 : Float32 = lowlevel NumToFloatCast #Attr.2;
+    ret Num.301;
 
-procedure Num.148 (Num.205, Num.206):
-    let Num.293 : Int1 = CallByName Num.22 Num.205 Num.206;
-    if Num.293 then
-        ret Num.205;
+procedure Num.148 (Num.211, Num.212):
+    let Num.303 : Int1 = CallByName Num.22 Num.211 Num.212;
+    if Num.303 then
+        ret Num.211;
     else
-        ret Num.206;
+        ret Num.212;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.290 : Float32 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.290;
+    let Num.300 : Float32 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.300;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.287 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.287;
+    let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.297;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.416 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.416;
+    let Num.426 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.426;
 
 procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.409 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.409;
+    let Num.419 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.419;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.271 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.271;
+    let Num.281 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.412 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.412;
+    let Num.422 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.422;
 
 procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.413 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.413;
+    let Num.423 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.423;
 
 procedure Num.50 (#Attr.2):
-    let Num.289 : U64 = lowlevel NumFloor #Attr.2;
-    ret Num.289;
+    let Num.299 : U64 = lowlevel NumFloor #Attr.2;
+    ret Num.299;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.257 : U32 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.257;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.415 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.415;
-
-procedure Num.69 (#Attr.2, #Attr.3):
-    let Num.279 : U32 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3;
-    ret Num.279;
-
-procedure Num.70 (#Attr.2, #Attr.3):
-    let Num.320 : U64 = lowlevel NumBitwiseXor #Attr.2 #Attr.3;
-    ret Num.320;
-
-procedure Num.71 (#Attr.2, #Attr.3):
-    let Num.278 : U32 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
-    ret Num.278;
-
-procedure Num.71 (#Attr.2, #Attr.3):
-    let Num.357 : U64 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
-    ret Num.357;
-
-procedure Num.72 (#Attr.2, #Attr.3):
-    let Num.260 : U32 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
-    ret Num.260;
-
-procedure Num.72 (#Attr.2, #Attr.3):
-    let Num.372 : U64 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
-    ret Num.372;
-
-procedure Num.74 (#Attr.2, #Attr.3):
-    let Num.338 : U128 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
-    ret Num.338;
-
-procedure Num.74 (#Attr.2, #Attr.3):
-    let Num.340 : U64 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
-    ret Num.340;
-
-procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.267 : U32 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    let Num.267 : U32 = lowlevel NumAddWrap #Attr.2 #Attr.3;
     ret Num.267;
 
-procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.270 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.425 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.425;
+
+procedure Num.69 (#Attr.2, #Attr.3):
+    let Num.289 : U32 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3;
+    ret Num.289;
+
+procedure Num.70 (#Attr.2, #Attr.3):
+    let Num.330 : U64 = lowlevel NumBitwiseXor #Attr.2 #Attr.3;
+    ret Num.330;
+
+procedure Num.71 (#Attr.2, #Attr.3):
+    let Num.288 : U32 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
+    ret Num.288;
+
+procedure Num.71 (#Attr.2, #Attr.3):
+    let Num.367 : U64 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
+    ret Num.367;
+
+procedure Num.72 (#Attr.2, #Attr.3):
+    let Num.270 : U32 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
     ret Num.270;
 
+procedure Num.72 (#Attr.2, #Attr.3):
+    let Num.382 : U64 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
+    ret Num.382;
+
+procedure Num.74 (#Attr.2, #Attr.3):
+    let Num.348 : U128 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
+    ret Num.348;
+
+procedure Num.74 (#Attr.2, #Attr.3):
+    let Num.350 : U64 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
+    ret Num.350;
+
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.406 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.406;
+    let Num.277 : U32 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.277;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.280 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.280;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.416 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.416;
 
 procedure Num.78 (#Attr.2, #Attr.3):
-    let Num.341 : U128 = lowlevel NumMulWrap #Attr.2 #Attr.3;
-    ret Num.341;
+    let Num.351 : U128 = lowlevel NumMulWrap #Attr.2 #Attr.3;
+    ret Num.351;
 
 procedure Num.96 (#Attr.2):
-    let Num.286 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.286;
+    let Num.296 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.296;
 
 procedure Num.96 (#Attr.2):
-    let Num.414 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.414;
+    let Num.424 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.424;
 
 procedure Str.12 (#Attr.2):
     let Str.251 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_list.txt

@@ -155,16 +155,16 @@ procedure List.90 (#Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_g
     jump List.574 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.258 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.96 (#Attr.2):
-    let Num.257 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.257;
+    let Num.267 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.267;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt

@@ -261,12 +261,12 @@ procedure List.90 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_g
     jump List.574 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.260;
+    let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.270;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record.txt

@@ -181,20 +181,20 @@ procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_g
     jump List.574 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.260;
+    let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.270;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Num.96 (#Attr.2):
-    let Num.257 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.257;
+    let Num.267 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.267;
 
 procedure Num.96 (#Attr.2):
-    let Num.258 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.258;
+    let Num.268 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.268;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt

@@ -158,12 +158,12 @@ procedure List.90 (#Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_g
     jump List.574 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt

@@ -165,12 +165,12 @@ procedure List.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_g
     jump List.574 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt

@@ -160,12 +160,12 @@ procedure List.90 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_g
     jump List.574 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt

@@ -163,12 +163,12 @@ procedure List.90 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_g
     jump List.574 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/ir_int_add.txt

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

crates/compiler/test_mono/generated/ir_plus.txt

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

crates/compiler/test_mono/generated/ir_round.txt

@@ -1,6 +1,6 @@
 procedure Num.45 (#Attr.2):
-    let Num.257 : I64 = lowlevel NumRound #Attr.2;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumRound #Attr.2;
+    ret Num.267;
 
 procedure Test.0 ():
     let Test.2 : Decimal = 3.6dec;

crates/compiler/test_mono/generated/ir_two_defs.txt

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

crates/compiler/test_mono/generated/ir_when_idiv.txt

@@ -1,22 +1,22 @@
+procedure Num.157 (#Attr.2, #Attr.3):
+    let Num.269 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
+    ret Num.269;
+
 procedure Num.30 (#Attr.2):
-    let Num.264 : I64 = 0i64;
-    let Num.263 : Int1 = lowlevel Eq #Attr.2 Num.264;
-    ret Num.263;
+    let Num.274 : I64 = 0i64;
+    let Num.273 : Int1 = lowlevel Eq #Attr.2 Num.274;
+    ret Num.273;
 
-procedure Num.39 (#Attr.2, #Attr.3):
-    let Num.259 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
-    ret Num.259;
-
-procedure Num.40 (Num.227, Num.228):
-    let Num.260 : Int1 = CallByName Num.30 Num.228;
-    if Num.260 then
-        let Num.262 : {} = Struct {};
-        let Num.261 : [C {}, C I64] = TagId(0) Num.262;
-        ret Num.261;
+procedure Num.40 (Num.235, Num.236):
+    let Num.270 : Int1 = CallByName Num.30 Num.236;
+    if Num.270 then
+        let Num.272 : {} = Struct {};
+        let Num.271 : [C {}, C I64] = TagId(0) Num.272;
+        ret Num.271;
     else
-        let Num.258 : I64 = CallByName Num.39 Num.227 Num.228;
-        let Num.257 : [C {}, C I64] = TagId(1) Num.258;
-        ret Num.257;
+        let Num.268 : I64 = CallByName Num.157 Num.235 Num.236;
+        let Num.267 : [C {}, C I64] = TagId(1) Num.268;
+        ret Num.267;
 
 procedure Test.0 ():
     let Test.8 : I64 = 1000i64;

crates/compiler/test_mono/generated/ir_when_just.txt

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

crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt

@@ -44,8 +44,8 @@ procedure List.9 (List.333):
         ret List.573;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Str.27 (Str.86):
     let Str.249 : [C Int1, C I64] = CallByName Str.60 Str.86;

crates/compiler/test_mono/generated/issue_4749.txt

@@ -179,44 +179,44 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
     jump List.636 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.260 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.260;
+    let Num.270 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.270;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.269 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.269;
+    let Num.279 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.279;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.272 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.272;
+    let Num.282 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.294;
+    let Num.304 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.304;
 
 procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.278 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.278;
+    let Num.288 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.288;
 
 procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.294 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.294;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.295 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.295;
+    let Num.305 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.305;
 
 procedure Num.71 (#Attr.2, #Attr.3):
-    let Num.257 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Num.72 (#Attr.2, #Attr.3):
-    let Num.258 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.301 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.301;
 
 procedure Str.43 (#Attr.2, #Attr.3, #Attr.4):
     let Str.258 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8Range #Attr.2 #Attr.3 #Attr.4;

crates/compiler/test_mono/generated/issue_4770.txt

@@ -82,16 +82,16 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
     jump List.587 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.260;
+    let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.270;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Test.1 (#Derived_gen.0):
     joinpoint Test.26 Test.6:

crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt

@@ -153,44 +153,44 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
     jump List.632 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.260 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.260;
+    let Num.270 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.270;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.269 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.269;
+    let Num.279 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.279;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.272 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.272;
+    let Num.282 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.294;
+    let Num.304 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.304;
 
 procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.278 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.278;
+    let Num.288 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.288;
 
 procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.294 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.294;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.295 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.295;
+    let Num.305 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.305;
 
 procedure Num.71 (#Attr.2, #Attr.3):
-    let Num.257 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U8 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Num.72 (#Attr.2, #Attr.3):
-    let Num.258 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U8 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.301 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.301;
 
 procedure Str.12 (#Attr.2):
     let Str.258 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/issue_6196.txt

@@ -1,6 +1,6 @@
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
     joinpoint Test.12 Test.2 Test.3:

crates/compiler/test_mono/generated/lambda_capture_niche_u8_vs_u64.txt

@@ -1,10 +1,10 @@
 procedure Num.96 (#Attr.2):
-    let Num.257 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.257;
+    let Num.267 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.267;
 
 procedure Num.96 (#Attr.2):
-    let Num.258 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.258;
+    let Num.268 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.268;
 
 procedure Test.1 (Test.4):
     let Test.13 : [C U8, C U64] = TagId(1) Test.4;

crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt

@@ -1,10 +1,14 @@
+procedure Str.3 (#Attr.2, #Attr.3):
+    let Str.249 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.249;
+
 procedure Test.1 (Test.5):
     let Test.16 : [C {}, C U64, C Str] = TagId(0) Test.5;
     ret Test.16;
 
 procedure Test.1 (Test.5):
-    let Test.30 : [C {}, C U64, C Str] = TagId(1) Test.5;
-    ret Test.30;
+    let Test.31 : [C {}, C U64, C Str] = TagId(1) Test.5;
+    ret Test.31;
 
 procedure Test.2 (Test.7):
     let Test.23 : [C {}, C U64, C Str] = TagId(2) Test.7;
@@ -16,13 +20,16 @@ procedure Test.6 (Test.17, #Attr.12):
     ret Test.19;
 
 procedure Test.6 (Test.17, #Attr.12):
-    let Test.34 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-    let Test.33 : Str = "";
-    ret Test.33;
+    let Test.35 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
+    let Test.34 : Str = "";
+    ret Test.34;
 
 procedure Test.8 (Test.24, #Attr.12):
-    let Test.27 : Str = UnionAtIndex (Id 2) (Index 0) #Attr.12;
-    ret Test.27;
+    let Test.28 : Str = UnionAtIndex (Id 2) (Index 0) #Attr.12;
+    let Test.27 : Str = "";
+    let Test.26 : Str = CallByName Str.3 Test.27 Test.28;
+    dec Test.28;
+    ret Test.26;
 
 procedure Test.0 ():
     let Test.3 : U8 = 0u8;
@@ -55,7 +62,7 @@ procedure Test.0 ():
             jump Test.13 Test.21;
     
         default:
-            let Test.29 : U64 = 1i64;
-            let Test.28 : [C {}, C U64, C Str] = CallByName Test.1 Test.29;
-            jump Test.13 Test.28;
+            let Test.30 : U64 = 1i64;
+            let Test.29 : [C {}, C U64, C Str] = CallByName Test.1 Test.30;
+            jump Test.13 Test.29;
     

crates/compiler/test_mono/generated/lambda_set_with_imported_toplevels_issue_4733.txt

@@ -7,12 +7,12 @@ procedure Bool.2 ():
     ret Bool.24;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.258 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Test.0 (Test.8):
     let Test.20 : Int1 = CallByName Bool.2;

crates/compiler/test_mono/generated/layout_cache_structure_with_multiple_recursive_structures.txt

@@ -29,12 +29,12 @@ procedure List.90 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
     jump List.574 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.7 (Test.11, Test.12):
     let Test.17 : {[<rnu>C *self, <null>], [<rnu><null>, C {[<rnu>C *self, <null>], *self}]} = Struct {Test.12, Test.11};

crates/compiler/test_mono/generated/linked_list_filter.txt

@@ -1,11 +1,11 @@
-procedure Num.31 (Num.199):
-    let Num.258 : I64 = 2i64;
-    let Num.257 : Int1 = CallByName Num.86 Num.199 Num.258;
-    ret Num.257;
+procedure Num.31 (Num.205):
+    let Num.268 : I64 = 2i64;
+    let Num.267 : Int1 = CallByName Num.86 Num.205 Num.268;
+    ret Num.267;
 
 procedure Num.86 (#Attr.2, #Attr.3):
-    let Num.259 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Test.2 (#Derived_gen.0, #Derived_gen.1):
     let #Derived_gen.3 : [<rnu><null>, C I64 *self] = NullPointer;

crates/compiler/test_mono/generated/linked_list_map.txt

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

crates/compiler/test_mono/generated/list_cannot_update_inplace.txt

@@ -22,12 +22,12 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
     ret List.578;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.258 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Test.1 ():
     let Test.8 : List I64 = Array [1i64, 2i64, 3i64];

crates/compiler/test_mono/generated/list_get.txt

@@ -21,8 +21,8 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.576;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (Test.2):
     let Test.6 : List I64 = Array [1i64, 2i64, 3i64];

crates/compiler/test_mono/generated/list_len.txt

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

crates/compiler/test_mono/generated/list_map_closure_borrows.txt

@@ -27,8 +27,8 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.576;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Str.16 (#Attr.2, #Attr.3):
     let Str.249 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_closure_owns.txt

@@ -27,8 +27,8 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.576;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.250 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_take_capturing_or_noncapturing.txt

@@ -21,8 +21,8 @@ procedure List.5 (#Attr.2, #Attr.3):
     
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.259 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Test.4 (Test.5, #Attr.12):
     let Test.16 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;

crates/compiler/test_mono/generated/list_pass_to_function.txt

@@ -22,8 +22,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
     ret List.576;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.2 (Test.3):
     let Test.6 : U64 = 0i64;

crates/compiler/test_mono/generated/list_sort_asc.txt

@@ -8,8 +8,8 @@ procedure List.59 (List.328):
     ret List.571;
 
 procedure Num.46 (#Attr.2, #Attr.3):
-    let Num.257 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.0 ():
     let Test.2 : List I64 = Array [4i64, 3i64, 2i64, 1i64];

crates/compiler/test_mono/generated/multiline_record_pattern.txt

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

crates/compiler/test_mono/generated/nested_optional_field_with_binary_op.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.0 ():
     let Test.17 : {} = Struct {};

crates/compiler/test_mono/generated/nested_pattern_match.txt

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

crates/compiler/test_mono/generated/num_width_gt_u8_layout_as_float.txt

@@ -1,6 +1,6 @@
 procedure Num.37 (#Attr.2, #Attr.3):
-    let Num.257 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.0 ():
     let Test.2 : Decimal = 1dec;

crates/compiler/test_mono/generated/optional_field_with_binary_op.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.0 ():
     let Test.5 : {} = Struct {};

crates/compiler/test_mono/generated/optional_when.txt

@@ -1,6 +1,6 @@
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.259 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Test.1 (Test.6):
     let Test.21 : Int1 = false;

crates/compiler/test_mono/generated/quicksort_help.txt

@@ -1,14 +1,14 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Test.1 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
     joinpoint Test.12 Test.2 Test.3 Test.4:

crates/compiler/test_mono/generated/quicksort_swap.txt

@@ -40,8 +40,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
     ret List.576;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Test.1 (Test.2):
     let Test.28 : U64 = 0i64;

crates/compiler/test_mono/generated/rb_tree_fbip.txt

@@ -1,10 +1,10 @@
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.260;
+    let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.270;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.258 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
     let #Derived_gen.4 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;

crates/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.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (Test.4):
     let Test.2 : I64 = StructAtIndex 0 Test.4;

crates/compiler/test_mono/generated/record_optional_field_function_use_default.txt

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

crates/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.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (Test.2):
     let Test.3 : I64 = StructAtIndex 0 Test.2;

crates/compiler/test_mono/generated/record_optional_field_let_use_default.txt

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

crates/compiler/test_mono/generated/record_update.txt

@@ -22,8 +22,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
     ret List.576;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.257 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (Test.2):
     let Test.6 : List U64 = StructAtIndex 0 Test.2;

crates/compiler/test_mono/generated/recursive_call_capturing_function.txt

@@ -3,8 +3,8 @@ procedure Bool.2 ():
     ret Bool.23;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (Test.2):
     let Test.8 : U32 = 0i64;

crates/compiler/test_mono/generated/recursive_lambda_set_resolved_only_upon_specialization.txt

@@ -3,12 +3,12 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     ret Bool.23;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.258 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.257 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (#Derived_gen.2, #Derived_gen.3):
     joinpoint Test.11 Test.2 Test.3:

crates/compiler/test_mono/generated/recursively_build_effect.txt

@@ -1,6 +1,6 @@
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.251 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/rigids.txt

@@ -40,8 +40,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
     ret List.576;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Test.1 (Test.2, Test.3, Test.4):
     inc 2 Test.4;

crates/compiler/test_mono/generated/specialize_after_match.txt

@@ -1,10 +1,10 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.259 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Test.2 (Test.9, Test.10):
     let Test.38 : U8 = 1i64;

crates/compiler/test_mono/generated/specialize_closures.txt

@@ -3,12 +3,12 @@ procedure Bool.2 ():
     ret Bool.24;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (Test.2, Test.3):
     let Test.15 : U8 = GetTagId Test.2;

crates/compiler/test_mono/generated/specialize_lowlevel.txt

@@ -3,12 +3,12 @@ procedure Bool.2 ():
     ret Bool.23;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.6 (Test.8, #Attr.12):
     let Test.20 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;

crates/compiler/test_mono/generated/tail_call_elimination.txt

@@ -1,10 +1,10 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.258 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
     joinpoint Test.7 Test.2 Test.3:

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt

@@ -184,40 +184,40 @@ procedure List.90 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_g
     jump List.612 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
 
 procedure Num.127 (#Attr.2):
-    let Num.264 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.264;
+    let Num.274 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.274;
 
 procedure Num.137 (#Attr.2, #Attr.3):
-    let Num.269 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
-    ret Num.269;
+    let Num.279 : U64 = lowlevel NumDivCeilUnchecked #Attr.2 #Attr.3;
+    ret Num.279;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.268 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.268;
-
-procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.265 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.265;
-
-procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.270 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.270;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.276 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.276;
-
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    let Num.278 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
     ret Num.278;
 
+procedure Num.20 (#Attr.2, #Attr.3):
+    let Num.275 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.275;
+
+procedure Num.21 (#Attr.2, #Attr.3):
+    let Num.280 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.280;
+
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.286;
+
+procedure Num.24 (#Attr.2, #Attr.3):
+    let Num.288 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.288;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.273 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.273;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.277 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.277;
+    let Num.287 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.287;
 
 procedure Str.12 (#Attr.2):
     let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt

@@ -158,24 +158,24 @@ procedure List.90 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_g
     jump List.600 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
 
 procedure Num.127 (#Attr.2):
-    let Num.276 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.276;
+    let Num.286 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.286;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.277 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.277;
+    let Num.287 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.287;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.278 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.278;
+    let Num.288 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.288;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Str.12 (#Attr.2):
     let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/weakening_avoids_overspecialization.txt

@@ -78,16 +78,16 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
     jump List.591 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.260 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.260;
+    let Num.270 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.270;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.259 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.259;
+    let Num.269 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.269;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.258 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.258;
+    let Num.268 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.268;
 
 procedure Test.3 (Test.4, Test.12):
     let Test.13 : [C U64, C U64] = TagId(0) Test.4;

crates/compiler/test_mono/generated/when_guard_appears_multiple_times_in_compiled_decision_tree_issue_5176.txt

@@ -3,8 +3,8 @@ procedure Bool.2 ():
     ret Bool.25;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.257 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.257;
+    let Num.267 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.267;
 
 procedure Test.1 (Test.2):
     joinpoint Test.12:

crates/compiler/test_mono/generated/when_nested_maybe.txt

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

crates/compiler/test_mono/generated/when_on_record.txt

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

crates/compiler/test_mono/generated/when_on_two_values.txt

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