Add Num.[f32,f64,dec]_[to,from]_bits builtins and deprecate Num.[f32,f64]_[to,from]_parts (#7741)

* Add `Num.[f32,f64,dec]_[to,from]_bits` builtins

* Update mono tests

* Deprecate `Num.[f32,f64]_[to,from]_parts`

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

@@ -114,6 +114,12 @@ comptime {
     exportNumFn(num.f64ToParts, "f64_to_parts");
     exportNumFn(num.f32FromParts, "f32_from_parts");
     exportNumFn(num.f64FromParts, "f64_from_parts");
+    exportNumFn(num.f32ToBits, "f32_to_bits");
+    exportNumFn(num.f64ToBits, "f64_to_bits");
+    exportNumFn(num.i128ToBits, "i128_to_bits");
+    exportNumFn(num.f32FromBits, "f32_from_bits");
+    exportNumFn(num.f64FromBits, "f64_from_bits");
+    exportNumFn(num.i128FromBits, "i128_from_bits");
 
     for (INTEGERS, 0..) |T, i| {
         num.exportPow(T, ROC_BUILTINS ++ "." ++ NUM ++ ".pow_int.");

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

@@ -702,3 +702,27 @@ pub fn f32FromParts(parts: F32Parts) callconv(.C) f32 {
 pub fn f64FromParts(parts: F64Parts) callconv(.C) f64 {
     return @as(f64, @bitCast(parts.fraction & 0xfffffffffffff | (@as(u64, parts.exponent & 0x7ff) << 52) | (@as(u64, @intFromBool(parts.sign)) << 63)));
 }
+
+pub fn f32ToBits(self: f32) callconv(.C) u32 {
+    return @as(u32, @bitCast(self));
+}
+
+pub fn f64ToBits(self: f64) callconv(.C) u64 {
+    return @as(u64, @bitCast(self));
+}
+
+pub fn i128ToBits(self: i128) callconv(.C) u128 {
+    return @as(u128, @bitCast(self));
+}
+
+pub fn f32FromBits(bits: u32) callconv(.C) f32 {
+    return @as(f32, @bitCast(bits));
+}
+
+pub fn f64FromBits(bits: u64) callconv(.C) f64 {
+    return @as(f64, @bitCast(bits));
+}
+
+pub fn i128FromBits(bits: u128) callconv(.C) i128 {
+    return @as(i128, @bitCast(bits));
+}

crates/compiler/builtins/roc/Num.roc

@@ -155,6 +155,12 @@ module [
     f64_to_parts,
     f32_from_parts,
     f64_from_parts,
+    f32_to_bits,
+    f64_to_bits,
+    dec_to_bits,
+    f32_from_bits,
+    f64_from_bits,
+    dec_from_bits,
     from_bool,
     nan_f32,
     nan_f64,
@@ -1444,20 +1450,62 @@ without_decimal_point : Dec -> I128
 with_decimal_point : I128 -> Dec
 
 ## Splits a [F32] into its components according to IEEE 754 standard.
+##
+## This function is deprecated due to common pitfalls when working with float components
+## using Roc’s fixed-size integer types. Please use [Num.f32_to_bits] instead and extract the
+## [IEEE 754 parts](https://en.wikipedia.org/wiki/Single-precision_floating-point_format#IEEE_754_standard:_binary32)
+## manually from the resulting [U32].
 f32_to_parts : F32 -> { sign : Bool, exponent : U8, fraction : U32 }
 
 ## Splits a [F64] into its components according to IEEE 754 standard.
+##
+## This function is deprecated due to common pitfalls when working with float components
+## using Roc’s fixed-size integer types. Please use [Num.f64_to_bits] instead and extract the
+## [IEEE 754 parts](https://en.wikipedia.org/wiki/Double-precision_floating-point_format#IEEE_754_double-precision_binary_floating-point_format:_binary64)
+## manually from the resulting [U64].
 f64_to_parts : F64 -> { sign : Bool, exponent : U16, fraction : U64 }
 
 ## Combine parts of a [F32] according to IEEE 754 standard.
 ## The fraction should not be bigger than 0x007F_FFFF, any bigger value will be truncated.
+##
+## This function is deprecated due to common pitfalls when working with float components
+## using Roc’s fixed-size integer types. Please combine the
+## [IEEE 754 parts](https://en.wikipedia.org/wiki/Single-precision_floating-point_format#IEEE_754_standard:_binary32)
+## manually into a [U32] and use [Num.f32_from_bits] to create the [F32] instead.
 f32_from_parts : { sign : Bool, exponent : U8, fraction : U32 } -> F32
 
 ## Combine parts of a [F64] according to IEEE 754 standard.
 ## The fraction should not be bigger than 0x000F_FFFF_FFFF_FFFF, any bigger value will be truncated.
 ## The exponent should not be bigger than 0x07FF, any bigger value will be truncated.
+##
+## This function is deprecated due to common pitfalls when working with float components
+## using Roc’s fixed-size integer types. Please combine the
+## [IEEE 754 parts](https://en.wikipedia.org/wiki/Double-precision_floating-point_format#IEEE_754_double-precision_binary_floating-point_format:_binary64)
+## manually into a [U64] and use [Num.f64_from_bits] to create the [F64] instead.
 f64_from_parts : { sign : Bool, exponent : U16, fraction : U64 } -> F64
 
+## Returns a [U32] containing the raw bits of a [F32], as defined by the IEEE 754 standard.
+f32_to_bits : F32 -> U32
+
+## Returns a [U64] containing the raw bits of a [F64], as defined by the IEEE 754 standard.
+f64_to_bits : F64 -> U64
+
+## Returns a [U128] containing the raw bits of a [Dec], which corresponds to the raw bits
+## of its [I128] representation.
+dec_to_bits : Dec -> U128
+
+## Interprets a [U32] as the binary representation of a 32-bit floating-point value according
+## to the IEEE 754 standard and returns the corresponding [F32].
+f32_from_bits : U32 -> F32
+
+## Interprets a [U64] as the binary representation of a 64-bit floating-point value according
+## to the IEEE 754 standard and returns the corresponding [F64].
+f64_from_bits : U64 -> F64
+
+## Interprets a [U128] as the raw bits of the internal [I128] representation of a fixed-point
+## decimal value and returns the corresponding [Dec].
+dec_from_bits : U128 -> Dec
+
 ## Convert a `Bool` to a `Num`
 ## ```roc
 ## expect Num.from_bool(Bool.true) == 1

crates/compiler/builtins/src/bitcode.rs

@@ -327,6 +327,12 @@ pub const NUM_F32_TO_PARTS: &str = "roc_builtins.num.f32_to_parts";
 pub const NUM_F64_TO_PARTS: &str = "roc_builtins.num.f64_to_parts";
 pub const NUM_F32_FROM_PARTS: &str = "roc_builtins.num.f32_from_parts";
 pub const NUM_F64_FROM_PARTS: &str = "roc_builtins.num.f64_from_parts";
+pub const NUM_F32_TO_BITS: &str = "roc_builtins.num.f32_to_bits";
+pub const NUM_F64_TO_BITS: &str = "roc_builtins.num.f64_to_bits";
+pub const NUM_I128_TO_BITS: &str = "roc_builtins.num.i128_to_bits";
+pub const NUM_F32_FROM_BITS: &str = "roc_builtins.num.f32_from_bits";
+pub const NUM_F64_FROM_BITS: &str = "roc_builtins.num.f64_from_bits";
+pub const NUM_I128_FROM_BITS: &str = "roc_builtins.num.i128_from_bits";
 
 pub const STR_INIT: &str = "roc_builtins.str.init";
 pub const STR_COUNT_SEGMENTS: &str = "roc_builtins.str.count_segments";

crates/compiler/can/src/builtins.rs

@@ -213,6 +213,12 @@ map_symbol_to_lowlevel_and_arity! {
     NumF64ToParts; NUM_F64_TO_PARTS; 1,
     NumF32FromParts; NUM_F32_FROM_PARTS; 1,
     NumF64FromParts; NUM_F64_FROM_PARTS; 1,
+    NumF32ToBits; NUM_F32_TO_BITS; 1,
+    NumF64ToBits; NUM_F64_TO_BITS; 1,
+    NumDecToBits; NUM_DEC_TO_BITS; 1,
+    NumF32FromBits; NUM_F32_FROM_BITS; 1,
+    NumF64FromBits; NUM_F64_FROM_BITS; 1,
+    NumDecFromBits; NUM_DEC_FROM_BITS; 1,
 
     Eq; BOOL_STRUCTURAL_EQ; 2,
     NotEq; BOOL_STRUCTURAL_NOT_EQ; 2,

crates/compiler/gen_dev/src/lib.rs

@@ -2230,6 +2230,36 @@ trait Backend<'a> {
                 self.build_fn_call(sym, intrinsic, args, arg_layouts, ret_layout)
             }
 
+            LowLevel::NumF32ToBits => {
+                let intrinsic = bitcode::NUM_F32_TO_BITS.to_string();
+                self.build_fn_call(sym, intrinsic, args, arg_layouts, ret_layout)
+            }
+
+            LowLevel::NumF64ToBits => {
+                let intrinsic = bitcode::NUM_F64_TO_BITS.to_string();
+                self.build_fn_call(sym, intrinsic, args, arg_layouts, ret_layout)
+            }
+
+            LowLevel::NumDecToBits => {
+                let intrinsic = bitcode::NUM_I128_TO_BITS.to_string();
+                self.build_fn_call(sym, intrinsic, args, arg_layouts, ret_layout)
+            }
+
+            LowLevel::NumF32FromBits => {
+                let intrinsic = bitcode::NUM_F32_FROM_BITS.to_string();
+                self.build_fn_call(sym, intrinsic, args, arg_layouts, ret_layout)
+            }
+
+            LowLevel::NumF64FromBits => {
+                let intrinsic = bitcode::NUM_F64_FROM_BITS.to_string();
+                self.build_fn_call(sym, intrinsic, args, arg_layouts, ret_layout)
+            }
+
+            LowLevel::NumDecFromBits => {
+                let intrinsic = bitcode::NUM_I128_FROM_BITS.to_string();
+                self.build_fn_call(sym, intrinsic, args, arg_layouts, ret_layout)
+            }
+
             x => todo!("low level, {:?}", x),
         }
     }

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

@@ -1271,6 +1271,36 @@ pub(crate) fn run_low_level<'a, 'ctx>(
             let fn_name = bitcode::NUM_F64_FROM_PARTS;
             call_bitcode_fn_with_record_arg(env, arg, fn_name)
         }
+        NumF32ToBits => {
+            arguments!(arg);
+            let fn_name = bitcode::NUM_F32_TO_BITS;
+            call_bitcode_fn(env, &[arg], fn_name)
+        }
+        NumF64ToBits => {
+            arguments!(arg);
+            let fn_name = bitcode::NUM_F64_TO_BITS;
+            call_bitcode_fn(env, &[arg], fn_name)
+        }
+        NumDecToBits => {
+            arguments!(arg);
+            let fn_name = bitcode::NUM_I128_TO_BITS;
+            call_bitcode_fn(env, &[arg], fn_name)
+        }
+        NumF32FromBits => {
+            arguments!(arg);
+            let fn_name = bitcode::NUM_F32_FROM_BITS;
+            call_bitcode_fn(env, &[arg], fn_name)
+        }
+        NumF64FromBits => {
+            arguments!(arg);
+            let fn_name = bitcode::NUM_F64_FROM_BITS;
+            call_bitcode_fn(env, &[arg], fn_name)
+        }
+        NumDecFromBits => {
+            arguments!(arg);
+            let fn_name = bitcode::NUM_I128_FROM_BITS;
+            call_bitcode_fn(env, &[arg], fn_name)
+        }
         Eq => {
             arguments_with_layouts!((lhs_arg, lhs_layout), (rhs_arg, rhs_layout));
 

crates/compiler/gen_wasm/src/low_level.rs

@@ -2173,6 +2173,12 @@ impl<'a> LowLevelCall<'a> {
             NumF64ToParts => self.load_args_and_call_zig(backend, bitcode::NUM_F64_TO_PARTS),
             NumF32FromParts => self.load_args_and_call_zig(backend, bitcode::NUM_F32_FROM_PARTS),
             NumF64FromParts => self.load_args_and_call_zig(backend, bitcode::NUM_F64_FROM_PARTS),
+            NumF32ToBits => self.load_args_and_call_zig(backend, bitcode::NUM_F32_TO_BITS),
+            NumF64ToBits => self.load_args_and_call_zig(backend, bitcode::NUM_F64_TO_BITS),
+            NumDecToBits => self.load_args_and_call_zig(backend, bitcode::NUM_I128_TO_BITS),
+            NumF32FromBits => self.load_args_and_call_zig(backend, bitcode::NUM_F32_FROM_BITS),
+            NumF64FromBits => self.load_args_and_call_zig(backend, bitcode::NUM_F64_FROM_BITS),
+            NumDecFromBits => self.load_args_and_call_zig(backend, bitcode::NUM_I128_FROM_BITS),
             Not => {
                 self.load_args(backend);
                 backend.code_builder.i32_eqz();

crates/compiler/module/src/low_level.rs

@@ -111,6 +111,12 @@ pub enum LowLevel {
     NumF64ToParts,
     NumF32FromParts,
     NumF64FromParts,
+    NumF32ToBits,
+    NumF64ToBits,
+    NumDecToBits,
+    NumF32FromBits,
+    NumF64FromBits,
+    NumDecFromBits,
     Eq,
     NotEq,
     Not,
@@ -347,6 +353,12 @@ map_symbol_to_lowlevel! {
     NumF64ToParts <= NUM_F64_TO_PARTS;
     NumF32FromParts <= NUM_F32_FROM_PARTS;
     NumF64FromParts <= NUM_F64_FROM_PARTS;
+    NumF32ToBits <= NUM_F32_TO_BITS;
+    NumF64ToBits <= NUM_F64_TO_BITS;
+    NumDecToBits <= NUM_DEC_TO_BITS;
+    NumF32FromBits <= NUM_F32_FROM_BITS;
+    NumF64FromBits <= NUM_F64_FROM_BITS;
+    NumDecFromBits <= NUM_DEC_FROM_BITS;
     Eq <= BOOL_STRUCTURAL_EQ;
     NotEq <= BOOL_STRUCTURAL_NOT_EQ;
     Not <= BOOL_NOT;

crates/compiler/module/src/symbol.rs

@@ -1354,6 +1354,12 @@ define_builtins! {
         167 NUM_INFINITY_F32: "infinity_f32"
         168 NUM_INFINITY_F64: "infinity_f64"
         169 NUM_FROM_BOOL: "from_bool"
+        170 NUM_F32_TO_BITS: "f32_to_bits"
+        171 NUM_F64_TO_BITS: "f64_to_bits"
+        172 NUM_DEC_TO_BITS: "dec_to_bits"
+        173 NUM_F32_FROM_BITS: "f32_from_bits"
+        174 NUM_F64_FROM_BITS: "f64_from_bits"
+        175 NUM_DEC_FROM_BITS: "dec_from_bits"
     }
     4 BOOL: "Bool" => {
         0 BOOL_BOOL: "Bool" exposed_type=true // the Bool.Bool type alias

crates/compiler/mono/src/drop_specialization.rs

@@ -1605,7 +1605,13 @@ fn low_level_no_rc(lowlevel: &LowLevel) -> RC {
         | NumF32ToParts
         | NumF64ToParts
         | NumF32FromParts
-        | NumF64FromParts => RC::NoRc,
+        | NumF64FromParts
+        | NumF32ToBits
+        | NumF64ToBits
+        | NumDecToBits
+        | NumF32FromBits
+        | NumF64FromBits
+        | NumDecFromBits => RC::NoRc,
         NumWithoutDecimalPoint | NumWithDecimalPoint => RC::NoRc,
         DictPseudoSeed => RC::NoRc,
         StrStartsWith | StrEndsWith => RC::NoRc,

crates/compiler/mono/src/inc_dec.rs

@@ -1302,7 +1302,13 @@ pub(crate) fn lowlevel_borrow_signature(op: LowLevel) -> &'static [Ownership] {
         | NumF32ToParts
         | NumF64ToParts
         | NumF32FromParts
-        | NumF64FromParts => &[IRRELEVANT],
+        | NumF64FromParts
+        | NumF32ToBits
+        | NumF64ToBits
+        | NumDecToBits
+        | NumF32FromBits
+        | NumF64FromBits
+        | NumDecFromBits => &[IRRELEVANT],
         StrStartsWith | StrEndsWith => &[BORROWED, BORROWED],
         StrFromUtf8 => &[OWNED],
         StrFromUtf8Lossy => &[BORROWED],

crates/compiler/test_gen/src/gen_num.rs

@@ -4140,6 +4140,74 @@ fn f64_from_parts() {
     );
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn f32_to_bits() {
+    assert_evals_to!(r"Num.f32_to_bits 0", 0, u32);
+    assert_evals_to!(r"Num.f32_to_bits Num.max_f32", 0x7f7fffff, u32);
+    assert_evals_to!(r"Num.f32_to_bits Num.min_f32", 0xff7fffff, u32);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn f64_to_bits() {
+    assert_evals_to!(r"Num.f64_to_bits 0", 0, u64);
+    assert_evals_to!(r"Num.f64_to_bits Num.max_f64", 0x7fefffffffffffff, u64);
+    assert_evals_to!(r"Num.f64_to_bits Num.min_f64", 0xffefffffffffffff, u64);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn dec_to_bits() {
+    assert_evals_to!(r"Num.dec_to_bits 0", U128::from(0), U128);
+    assert_evals_to!(
+        r"Num.dec_to_bits 170141183460469231731.687303715884105727",
+        U128::from(170141183460469231731687303715884105727),
+        U128
+    );
+    assert_evals_to!(
+        r"Num.dec_to_bits -170141183460469231731.687303715884105728",
+        U128::from(170141183460469231731687303715884105728),
+        U128
+    );
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn f32_from_bits() {
+    assert_evals_to!(r"Num.f32_from_bits 0", 0.0, f32);
+    assert_evals_to!(r"Num.f32_from_bits 0x7f7fffff", f32::MAX, f32);
+    assert_evals_to!(r"Num.f32_from_bits 0xff7fffff", f32::MIN, f32);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn f64_from_bits() {
+    assert_evals_to!(r"Num.f64_from_bits 0", 0.0, f64);
+    assert_evals_to!(r"Num.f64_from_bits 0x7fefffffffffffff", f64::MAX, f64);
+    assert_evals_to!(r"Num.f64_from_bits 0xffefffffffffffff", f64::MIN, f64);
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn dec_from_bits() {
+    assert_evals_to!(
+        r"Num.dec_from_bits 0",
+        RocDec::from_str("0").unwrap(),
+        RocDec
+    );
+    assert_evals_to!(
+        r"Num.dec_from_bits 170141183460469231731687303715884105727",
+        RocDec::MAX,
+        RocDec
+    );
+    assert_evals_to!(
+        r"Num.dec_from_bits 170141183460469231731687303715884105728",
+        RocDec::MIN,
+        RocDec
+    );
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
 fn from_bool_true() {

crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt

@@ -79,16 +79,16 @@ procedure List.80 (Bool.22, Bool.23, Bool.24, Bool.25, Bool.26):
     jump List.695 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.284 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.290;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.4 (Test.27):
     let Test.39 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = TagId(0) ;

crates/compiler/test_mono/generated/call_function_in_empty_list.txt

@@ -48,12 +48,12 @@ procedure List.71 (#Attr.2, #Attr.3):
     ret List.693;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.2 (Test.3):
     let Test.7 : {} = Struct {};

crates/compiler/test_mono/generated/call_function_in_empty_list_unbound.txt

@@ -48,12 +48,12 @@ procedure List.71 (#Attr.2, #Attr.3):
     ret List.693;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.2 (Test.3):
     let Test.7 : {} = Struct {};

crates/compiler/test_mono/generated/capture_void_layout_task.txt

@@ -29,12 +29,12 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.685;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.10 (Test.69, #Attr.12):
     let Test.72 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;

crates/compiler/test_mono/generated/choose_i128_layout.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.284 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.290;
 
 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.283 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.0 ():
     let Test.2 : U64 = 9999999999999999999i64;

crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt

@@ -33,12 +33,12 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.685;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.390 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/dbg_expr.txt

@@ -35,12 +35,12 @@ procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Num.96 (#Attr.2):
-    let Num.284 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.284;
+    let Num.290 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.290;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/dbg_in_expect.txt

@@ -76,32 +76,32 @@ procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.288;
+    let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.294;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.290;
+    let Num.296 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.296;
 
 procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.292;
+    let Num.298 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.298;
 
 procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.289;
+    let Num.295 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.295;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.297 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.297;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Str.20 (#Attr.2):
     let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;

crates/compiler/test_mono/generated/dbg_inside_string.txt

@@ -72,32 +72,32 @@ procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.288;
+    let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.294;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.290;
+    let Num.296 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.296;
 
 procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.292;
+    let Num.298 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.298;
 
 procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.289;
+    let Num.295 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.295;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.297 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.297;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Str.20 (#Attr.2):
     let Str.458 : Str = lowlevel StrWithCapacity #Attr.2;

crates/compiler/test_mono/generated/dbg_nested_expr.txt

@@ -35,8 +35,8 @@ procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt

@@ -72,32 +72,32 @@ procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.288;
+    let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.294;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.290;
+    let Num.296 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.296;
 
 procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.292;
+    let Num.298 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.298;
 
 procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.289;
+    let Num.295 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.295;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.297 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.297;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Str.20 (#Attr.2):
     let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;

crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt

@@ -3,12 +3,12 @@ procedure Bool.9 (#Attr.2, #Attr.3):
     ret Bool.22;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.285 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.96 (#Attr.2):
-    let Num.284 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.284;
+    let Num.290 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.290;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.389 : 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.675;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.283 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.0 ():
     let Test.3 : {} = Struct {};

crates/compiler/test_mono/generated/empty_list_of_function_type.txt

@@ -23,8 +23,8 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.680;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.2 (Test.5):
     let Test.17 : Str = "bar";

crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt

@@ -148,20 +148,20 @@ procedure List.8 (#Attr.2, #Attr.3):
     ret List.725;
 
 procedure Num.127 (#Attr.2):
-    let Num.288 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.288;
+    let Num.294 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.294;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.290;
+    let Num.296 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.296;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.289;
+    let Num.295 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.295;
 
 procedure Num.96 (#Attr.2):
-    let Num.287 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.287;
+    let Num.293 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.293;
 
 procedure Str.12 (#Attr.2):
     let Str.401 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt

@@ -89,20 +89,20 @@ procedure List.8 (#Attr.2, #Attr.3):
     ret List.699;
 
 procedure Num.127 (#Attr.2):
-    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.284;
+    let Num.290 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.290;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Str.12 (#Attr.2):
     let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt

@@ -96,20 +96,20 @@ procedure List.8 (#Attr.2, #Attr.3):
     ret List.699;
 
 procedure Num.127 (#Attr.2):
-    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.284;
+    let Num.290 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.290;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Str.12 (#Attr.2):
     let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_string.txt

@@ -30,12 +30,12 @@ procedure List.8 (#Attr.2, #Attr.3):
     ret List.687;
 
 procedure Num.127 (#Attr.2):
-    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.284;
+    let Num.290 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.290;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Str.12 (#Attr.2):
     let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt

@@ -94,20 +94,20 @@ procedure List.8 (#Attr.2, #Attr.3):
     ret List.699;
 
 procedure Num.127 (#Attr.2):
-    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.284;
+    let Num.290 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.290;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Str.12 (#Attr.2):
     let Str.398 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt

@@ -97,20 +97,20 @@ procedure List.8 (#Attr.2, #Attr.3):
     ret List.699;
 
 procedure Num.127 (#Attr.2):
-    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.284;
+    let Num.290 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.290;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Str.12 (#Attr.2):
     let Str.398 : 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.284 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.283 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.1 (Bool.21, Bool.22):
     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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.284 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.290;
 
 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.21;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.285 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.291;
 
 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.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Test.2 (Test.3, Test.1):
     let Test.18 : Int1 = false;

crates/compiler/test_mono/generated/inspect_derived_dict.txt

@@ -1065,143 +1065,143 @@ procedure List.99 (#Derived_gen.34, #Derived_gen.35, #Derived_gen.36):
     jump List.726 #Derived_gen.34 #Derived_gen.35 #Derived_gen.36;
 
 procedure Num.131 (#Attr.2):
-    let Num.291 : U32 = lowlevel NumIntCast #Attr.2;
-    ret Num.291;
-
-procedure Num.133 (#Attr.2):
-    let Num.299 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.299;
-
-procedure Num.133 (#Attr.2):
-    let Num.348 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.348;
-
-procedure Num.133 (#Attr.2):
-    let Num.363 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.363;
-
-procedure Num.135 (#Attr.2):
-    let Num.369 : U128 = lowlevel NumIntCast #Attr.2;
-    ret Num.369;
-
-procedure Num.139 (#Attr.2):
-    let Num.317 : Float32 = lowlevel NumToFloatCast #Attr.2;
-    ret Num.317;
-
-procedure Num.148 (Num.226, Num.227):
-    let Num.319 : Int1 = CallByName Num.22 Num.226 Num.227;
-    if Num.319 then
-        ret Num.226;
-    else
-        ret Num.227;
-
-procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.446 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.446;
-
-procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.316 : Float32 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.316;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.313 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.313;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.453 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.453;
-
-procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.450 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.450;
-
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.297 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    let Num.297 : U32 = lowlevel NumIntCast #Attr.2;
     ret Num.297;
 
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.438 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.438;
-
-procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.447 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.447;
-
-procedure Num.50 (#Attr.2):
-    let Num.315 : U64 = lowlevel NumFloor #Attr.2;
-    ret Num.315;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U32 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.452 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.452;
-
-procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.449 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.449;
-
-procedure Num.69 (#Attr.2, #Attr.3):
-    let Num.305 : U32 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3;
+procedure Num.133 (#Attr.2):
+    let Num.305 : U64 = lowlevel NumIntCast #Attr.2;
     ret Num.305;
 
+procedure Num.133 (#Attr.2):
+    let Num.354 : U64 = lowlevel NumIntCast #Attr.2;
+    ret Num.354;
+
+procedure Num.133 (#Attr.2):
+    let Num.369 : U64 = lowlevel NumIntCast #Attr.2;
+    ret Num.369;
+
+procedure Num.135 (#Attr.2):
+    let Num.375 : U128 = lowlevel NumIntCast #Attr.2;
+    ret Num.375;
+
+procedure Num.139 (#Attr.2):
+    let Num.323 : Float32 = lowlevel NumToFloatCast #Attr.2;
+    ret Num.323;
+
+procedure Num.148 (Num.232, Num.233):
+    let Num.325 : Int1 = CallByName Num.22 Num.232 Num.233;
+    if Num.325 then
+        ret Num.232;
+    else
+        ret Num.233;
+
+procedure Num.20 (#Attr.2, #Attr.3):
+    let Num.452 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.452;
+
+procedure Num.21 (#Attr.2, #Attr.3):
+    let Num.322 : Float32 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.322;
+
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.319 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.319;
+
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.459 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.459;
+
+procedure Num.23 (#Attr.2, #Attr.3):
+    let Num.456 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.456;
+
+procedure Num.24 (#Attr.2, #Attr.3):
+    let Num.303 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.303;
+
+procedure Num.24 (#Attr.2, #Attr.3):
+    let Num.444 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.444;
+
+procedure Num.25 (#Attr.2, #Attr.3):
+    let Num.453 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.453;
+
+procedure Num.50 (#Attr.2):
+    let Num.321 : U64 = lowlevel NumFloor #Attr.2;
+    ret Num.321;
+
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.289 : U32 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.289;
+
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.458 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.458;
+
+procedure Num.53 (#Attr.2, #Attr.3):
+    let Num.455 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.455;
+
+procedure Num.69 (#Attr.2, #Attr.3):
+    let Num.311 : U32 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3;
+    ret Num.311;
+
 procedure Num.70 (#Attr.2, #Attr.3):
-    let Num.346 : U64 = lowlevel NumBitwiseXor #Attr.2 #Attr.3;
-    ret Num.346;
+    let Num.352 : U64 = lowlevel NumBitwiseXor #Attr.2 #Attr.3;
+    ret Num.352;
 
 procedure Num.71 (#Attr.2, #Attr.3):
-    let Num.304 : U32 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
-    ret Num.304;
+    let Num.310 : U32 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
+    ret Num.310;
 
 procedure Num.71 (#Attr.2, #Attr.3):
-    let Num.383 : U64 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
-    ret Num.383;
+    let Num.389 : U64 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
+    ret Num.389;
 
 procedure Num.72 (#Attr.2, #Attr.3):
-    let Num.286 : U32 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : U32 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.72 (#Attr.2, #Attr.3):
-    let Num.398 : U64 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
-    ret Num.398;
+    let Num.404 : U64 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
+    ret Num.404;
 
 procedure Num.74 (#Attr.2, #Attr.3):
-    let Num.364 : U128 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
-    ret Num.364;
+    let Num.370 : U128 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
+    ret Num.370;
 
 procedure Num.74 (#Attr.2, #Attr.3):
-    let Num.366 : U64 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
-    ret Num.366;
+    let Num.372 : U64 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
+    ret Num.372;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.293 : U32 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U32 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.296 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.296;
+    let Num.302 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.302;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.432 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.432;
+    let Num.438 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.438;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.451 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.451;
+    let Num.457 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.457;
 
 procedure Num.78 (#Attr.2, #Attr.3):
-    let Num.367 : U128 = lowlevel NumMulWrap #Attr.2 #Attr.3;
-    ret Num.367;
+    let Num.373 : U128 = lowlevel NumMulWrap #Attr.2 #Attr.3;
+    ret Num.373;
 
 procedure Num.96 (#Attr.2):
-    let Num.312 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.312;
+    let Num.318 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.318;
 
 procedure Num.96 (#Attr.2):
-    let Num.440 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.440;
+    let Num.446 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.446;
 
 procedure Str.12 (#Attr.2):
     let Str.390 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_list.txt

@@ -151,16 +151,16 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.685;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.284 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt

@@ -294,32 +294,32 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.697;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.290 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.290;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.297 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.297;
-
-procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.294 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.294;
-
-procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.291 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.291;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.296 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.296 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
     ret Num.296;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.303 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.303;
+
+procedure Num.23 (#Attr.2, #Attr.3):
+    let Num.300 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.300;
+
+procedure Num.25 (#Attr.2, #Attr.3):
+    let Num.297 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.297;
+
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.302 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.302;
+
 procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.295 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.295;
+    let Num.301 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.301;
 
 procedure Str.20 (#Attr.2):
     let Str.457 : Str = lowlevel StrWithCapacity #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_record.txt

@@ -182,20 +182,20 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.685;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Num.96 (#Attr.2):
-    let Num.284 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.284;
+    let Num.290 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.290;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt

@@ -188,32 +188,32 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.685;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.288;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.295;
-
-procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.292;
-
-procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.289;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
     ret Num.294;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.301 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.301;
+
+procedure Num.23 (#Attr.2, #Attr.3):
+    let Num.298 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.298;
+
+procedure Num.25 (#Attr.2, #Attr.3):
+    let Num.295 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.295;
+
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.300 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.300;
+
 procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.297 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.297;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Str.20 (#Attr.2):
     let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt

@@ -195,32 +195,32 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.685;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.288;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.295;
-
-procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.292;
-
-procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.289;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
     ret Num.294;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.301 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.301;
+
+procedure Num.23 (#Attr.2, #Attr.3):
+    let Num.298 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.298;
+
+procedure Num.25 (#Attr.2, #Attr.3):
+    let Num.295 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.295;
+
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.300 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.300;
+
 procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.297 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.297;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Str.20 (#Attr.2):
     let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_string.txt

@@ -72,32 +72,32 @@ procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.288;
+    let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.294;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.290;
+    let Num.296 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.296;
 
 procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.292;
+    let Num.298 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.298;
 
 procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.289;
+    let Num.295 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.295;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.297 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.297;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Str.20 (#Attr.2):
     let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt

@@ -195,32 +195,32 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.685;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.288;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.295;
-
-procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.292;
-
-procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.289;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
     ret Num.294;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.301 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.301;
+
+procedure Num.23 (#Attr.2, #Attr.3):
+    let Num.298 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.298;
+
+procedure Num.25 (#Attr.2, #Attr.3):
+    let Num.295 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.295;
+
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.300 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.300;
+
 procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.297 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.297;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Str.20 (#Attr.2):
     let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt

@@ -198,32 +198,32 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.685;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.288 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.288;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.295 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.295;
-
-procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.292 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.292;
-
-procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.289 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.289;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.294 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.294 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
     ret Num.294;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.301 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.301;
+
+procedure Num.23 (#Attr.2, #Attr.3):
+    let Num.298 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.298;
+
+procedure Num.25 (#Attr.2, #Attr.3):
+    let Num.295 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.295;
+
+procedure Num.51 (#Attr.2, #Attr.3):
+    let Num.300 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.300;
+
 procedure Num.53 (#Attr.2, #Attr.3):
-    let Num.291 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
-    ret Num.291;
+    let Num.297 : U64 = lowlevel NumAddSaturated #Attr.2 #Attr.3;
+    ret Num.297;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.293 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.293;
+    let Num.299 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.299;
 
 procedure Str.20 (#Attr.2):
     let Str.456 : Str = lowlevel StrWithCapacity #Attr.2;

crates/compiler/test_mono/generated/ir_int_add.txt

@@ -3,8 +3,8 @@ procedure List.6 (#Attr.2):
     ret List.675;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.291;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.283 : I64 = lowlevel NumRound #Attr.2;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumRound #Attr.2;
+    ret Num.289;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.285 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.30 (#Attr.2):
-    let Num.290 : I64 = 0i64;
-    let Num.289 : Int1 = lowlevel Eq #Attr.2 Num.290;
-    ret Num.289;
+    let Num.296 : I64 = 0i64;
+    let Num.295 : Int1 = lowlevel Eq #Attr.2 Num.296;
+    ret Num.295;
 
-procedure Num.40 (Num.250, Num.251):
-    let Num.286 : Int1 = CallByName Num.30 Num.251;
-    if Num.286 then
-        let Num.288 : {} = Struct {};
-        let Num.287 : [C {}, C I64] = TagId(0) Num.288;
-        ret Num.287;
+procedure Num.40 (Num.256, Num.257):
+    let Num.292 : Int1 = CallByName Num.30 Num.257;
+    if Num.292 then
+        let Num.294 : {} = Struct {};
+        let Num.293 : [C {}, C I64] = TagId(0) Num.294;
+        ret Num.293;
     else
-        let Num.284 : I64 = CallByName Num.157 Num.250 Num.251;
-        let Num.283 : [C {}, C I64] = TagId(1) Num.284;
-        ret Num.283;
+        let Num.290 : I64 = CallByName Num.157 Num.256 Num.257;
+        let Num.289 : [C {}, C I64] = TagId(1) Num.290;
+        ret Num.289;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.0 ():
     let Test.10 : I64 = 41i64;

crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt

@@ -42,8 +42,8 @@ procedure List.9 (List.392):
         ret List.677;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Str.27 (Str.187):
     let Str.388 : [C Int1, C I64] = CallByName Str.75 Str.187;

crates/compiler/test_mono/generated/issue_4770.txt

@@ -119,24 +119,24 @@ procedure List.80 (Bool.25, Bool.26, Bool.27, Bool.28, Bool.29):
     inc Bool.25;
     jump List.691 Bool.25 Bool.26 Bool.27 Bool.28 Bool.29;
 
-procedure Num.148 (Num.226, Num.227):
-    let Num.290 : Int1 = CallByName Num.22 Num.226 Num.227;
-    if Num.290 then
-        ret Num.226;
+procedure Num.148 (Num.232, Num.233):
+    let Num.296 : Int1 = CallByName Num.22 Num.232 Num.233;
+    if Num.296 then
+        ret Num.232;
     else
-        ret Num.227;
+        ret Num.233;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.288 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.288;
+    let Num.294 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.294;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Test.1 (Bool.24):
     joinpoint Test.26 Test.6:

crates/compiler/test_mono/generated/issue_6196.txt

@@ -1,6 +1,6 @@
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.1 (Bool.21, Bool.22):
     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.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Num.96 (#Attr.2):
-    let Num.284 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.284;
+    let Num.290 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.290;
 
 procedure Test.1 (Test.4):
     let Test.13 : [C U8, C U64] = TagId(1) Test.4;

crates/compiler/test_mono/generated/lambda_set_with_imported_toplevels_issue_4733.txt

@@ -7,12 +7,12 @@ procedure Bool.9 (#Attr.2, #Attr.3):
     ret Bool.21;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.284 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.290;
 
 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

@@ -30,12 +30,12 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.685;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.289;
 
 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

@@ -29,7 +29,7 @@ procedure Test.0 ():
     let Test.28 : [<rnu><null>, C I64 *self] = TagId(0) Test.29 Test.30;
     let Test.14 : [<rnu><null>, C I64 *self] = TagId(0) Test.27 Test.28;
     joinpoint Bool.23:
-        let Test.26 : Str = "ValueNotExposed { module_name: ModuleName(IdentStr { string: \"Num\" }), ident: Ident(IdentStr { string: \"isEven\" }), region: @416-426, exposed_values: ['max_f32', 'min_f32', 'abs', 'neg', 'add', 'sub', 'mul', 'is_lt', 'is_lte', 'is_gt', 'is_gte', 'to_frac', 'sin', 'cos', 'tan', 'is_zero', 'is_even', 'is_odd', 'is_positive', 'is_negative', 'rem', 'rem_checked', 'div', 'div_checked', 'div_trunc', 'div_trunc_checked', 'sqrt', 'sqrt_checked', 'log', 'log_checked', 'round', 'compare', 'pow', 'ceiling', 'pow_int', 'floor', 'add_wrap', 'add_checked', 'add_saturated', 'atan', 'acos', 'asin', 'bitwise_and', 'bitwise_xor', 'bitwise_or', 'shift_left_by', 'shift_right_by', 'shift_right_zf_by', 'sub_wrap', 'sub_checked', 'sub_saturated', 'mul_wrap', 'mul_checked', 'mul_saturated', 'e', 'pi', 'tau', 'is_multiple_of', 'count_one_bits', 'abs_diff', 'is_nan', 'is_infinite', 'is_finite', 'count_leading_zero_bits', 'count_trailing_zero_bits', 'to_str', 'min_i8', 'max_i8', 'min_u8', 'max_u8', 'min_i16', 'max_i16', 'min_u16', 'max_u16', 'min_i32', 'max_i32', 'min_u32', 'max_u32', 'min_i64', 'max_i64', 'min_u64', 'max_u64', 'min_i128', 'max_i128', 'min_u128', 'max_u128', 'to_i8', 'to_i8_checked', 'to_i16', 'to_i16_checked', 'to_i32', 'to_i32_checked', 'to_i64', 'to_i64_checked', 'to_i128', 'to_i128_checked', 'to_u8', 'to_u8_checked', 'to_u16', 'to_u16_checked', 'to_u32', 'to_u32_checked', 'to_u64', 'to_u64_checked', 'to_u128', 'to_u128_checked', 'div_ceil', 'div_ceil_checked', 'to_f32', 'to_f32_checked', 'to_f64', 'to_f64_checked', 'max_f64', 'min_f64', 'add_checked_lowlevel', 'sub_checked_lowlevel', 'mul_checked_lowlevel', 'min', 'max', 'bitwise_not', 'int_cast', 'is_approx_eq', 'bytes_to_u16_owlevel', 'bytes_to_u32_lowlevel', 'bytes_to_u64_lowlevel', 'bytes_to_u128_lowlevel', 'div_trunc_unchecked', 'rem_unchecked', 'without_decimal_point', 'with_decimal_point', 'f32_to_parts', 'f64_to_parts', 'f32_from_parts', 'f64_from_parts', 'nan_f32', 'nan_f64', 'infinity_f32', 'infinity_f64', 'from_bool'] }";
+        let Test.26 : Str = "ValueNotExposed { module_name: ModuleName(IdentStr { string: \"Num\" }), ident: Ident(IdentStr { string: \"isEven\" }), region: @416-426, exposed_values: ['max_f32', 'min_f32', 'abs', 'neg', 'add', 'sub', 'mul', 'is_lt', 'is_lte', 'is_gt', 'is_gte', 'to_frac', 'sin', 'cos', 'tan', 'is_zero', 'is_even', 'is_odd', 'is_positive', 'is_negative', 'rem', 'rem_checked', 'div', 'div_checked', 'div_trunc', 'div_trunc_checked', 'sqrt', 'sqrt_checked', 'log', 'log_checked', 'round', 'compare', 'pow', 'ceiling', 'pow_int', 'floor', 'add_wrap', 'add_checked', 'add_saturated', 'atan', 'acos', 'asin', 'bitwise_and', 'bitwise_xor', 'bitwise_or', 'shift_left_by', 'shift_right_by', 'shift_right_zf_by', 'sub_wrap', 'sub_checked', 'sub_saturated', 'mul_wrap', 'mul_checked', 'mul_saturated', 'e', 'pi', 'tau', 'is_multiple_of', 'count_one_bits', 'abs_diff', 'is_nan', 'is_infinite', 'is_finite', 'count_leading_zero_bits', 'count_trailing_zero_bits', 'to_str', 'min_i8', 'max_i8', 'min_u8', 'max_u8', 'min_i16', 'max_i16', 'min_u16', 'max_u16', 'min_i32', 'max_i32', 'min_u32', 'max_u32', 'min_i64', 'max_i64', 'min_u64', 'max_u64', 'min_i128', 'max_i128', 'min_u128', 'max_u128', 'to_i8', 'to_i8_checked', 'to_i16', 'to_i16_checked', 'to_i32', 'to_i32_checked', 'to_i64', 'to_i64_checked', 'to_i128', 'to_i128_checked', 'to_u8', 'to_u8_checked', 'to_u16', 'to_u16_checked', 'to_u32', 'to_u32_checked', 'to_u64', 'to_u64_checked', 'to_u128', 'to_u128_checked', 'div_ceil', 'div_ceil_checked', 'to_f32', 'to_f32_checked', 'to_f64', 'to_f64_checked', 'max_f64', 'min_f64', 'add_checked_lowlevel', 'sub_checked_lowlevel', 'mul_checked_lowlevel', 'min', 'max', 'bitwise_not', 'int_cast', 'is_approx_eq', 'bytes_to_u16_owlevel', 'bytes_to_u32_lowlevel', 'bytes_to_u64_lowlevel', 'bytes_to_u128_lowlevel', 'div_trunc_unchecked', 'rem_unchecked', 'without_decimal_point', 'with_decimal_point', 'f32_to_parts', 'f64_to_parts', 'f32_from_parts', 'f64_from_parts', 'nan_f32', 'nan_f64', 'infinity_f32', 'infinity_f64', 'from_bool', 'f32_to_bits', 'f64_to_bits', 'dec_to_bits', 'f32_from_bits', 'f64_from_bits', 'dec_from_bits'] }";
         Crash Test.26
     in
     let Bool.24 : Int1 = lowlevel RefCountIsUnique Test.14;

crates/compiler/test_mono/generated/linked_list_map.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.682;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Test.1 ():
     let Test.8 : List I64 = Array [1i64, 2i64, 3i64];

crates/compiler/test_mono/generated/list_get.txt

@@ -19,8 +19,8 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.680;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.676;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.0 ():
     let Test.1 : List I64 = Array [1i64, 2i64, 3i64];

crates/compiler/test_mono/generated/list_map_closure_borrows.txt

@@ -63,12 +63,12 @@ procedure List.71 (#Attr.2, #Attr.3):
     ret List.699;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Str.16 (#Attr.2, #Attr.3):
     let Str.388 : Str = lowlevel StrRepeat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_closure_owns.txt

@@ -62,12 +62,12 @@ procedure List.71 (#Attr.2, #Attr.3):
     ret List.699;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.389 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/list_map_take_capturing_or_noncapturing.txt

@@ -63,16 +63,16 @@ procedure List.71 (#Attr.2, #Attr.3):
     ret List.693;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.285 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.287 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.287;
+    let Num.293 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.293;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.292;
 
 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.680;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.387):
     ret List.675;
 
 procedure Num.46 (#Attr.2, #Attr.3):
-    let Num.283 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.290;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.283 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.0 ():
     let Test.2 : Decimal = 1dec;

crates/compiler/test_mono/generated/opaque_as_pattern_in_closure_arg.txt

@@ -1,6 +1,6 @@
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.2 (Test.8):
     let Test.14 : U64 = 2i64;

crates/compiler/test_mono/generated/optional_field_with_binary_op.txt

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

crates/compiler/test_mono/generated/pizza_dbg.txt

@@ -35,12 +35,12 @@ procedure Inspect.64 (Inspect.297):
     ret Inspect.297;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Num.96 (#Attr.2):
-    let Num.284 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.284;
+    let Num.290 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.290;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.388 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/quicksort_help.txt

@@ -1,14 +1,14 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.284 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Test.1 (Bool.21, Bool.22, Bool.23):
     joinpoint Test.12 Test.2 Test.3 Test.4:

crates/compiler/test_mono/generated/quicksort_swap.txt

@@ -38,8 +38,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
     ret List.680;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.291;
 
 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.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Test.3 (Bool.21, Bool.22, Bool.23):
     let Bool.25 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;

crates/compiler/test_mono/generated/record_as_pattern_in_closure_arg.txt

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

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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.680;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.21;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.1 (Test.2):
     let Test.8 : U32 = 0i64;

crates/compiler/test_mono/generated/recursive_function_and_union_with_inference_hole.txt

@@ -49,12 +49,12 @@ procedure List.71 (#Attr.2, #Attr.3):
     ret List.693;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.2 (Test.5):
     let Test.6 : List [<rnnu>C List *self] = UnionAtIndex (Id 0) (Index 0) Test.5;

crates/compiler/test_mono/generated/recursive_lambda_set_resolved_only_upon_specialization.txt

@@ -3,12 +3,12 @@ procedure Bool.9 (#Attr.2, #Attr.3):
     ret Bool.21;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.284 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.283 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Test.1 (Bool.22, Bool.23):
     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.283 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.390 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/rigids.txt

@@ -38,8 +38,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
     ret List.680;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Test.1 (Test.2, Test.3, Test.4):
     let Test.29 : [C {}, C I64] = CallByName List.2 Test.4 Test.3;

crates/compiler/test_mono/generated/specialize_after_match.txt

@@ -1,10 +1,10 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.284 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.285 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    ret Num.291;
 
 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.22;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.283 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.21;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.283 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.289;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    let Num.289 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.289;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.284 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.290 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.290;
 
 procedure Test.1 (Bool.21, Bool.22):
     joinpoint Test.7 Test.2 Test.3:

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_types.txt

@@ -83,20 +83,20 @@ procedure List.8 (#Attr.2, #Attr.3):
     ret List.699;
 
 procedure Num.127 (#Attr.2):
-    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.284;
+    let Num.290 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.290;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.286;
+    let Num.292 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.292;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.291 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.291;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.289 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.289;
 
 procedure Str.12 (#Attr.2):
     let Str.389 : List U8 = lowlevel StrToUtf8 #Attr.2;