Merge branch 'main' into jared/improve-module-error

.devcontainer/devcontainer.json

@@ -0,0 +1,38 @@
+// For format details, see https://aka.ms/devcontainer.json. For config options, see the
+// README at: https://github.com/devcontainers/templates/tree/main/src/rust
+{
+	"name": "Rust",
+	// Or use a Dockerfile or Docker Compose file. More info: https://containers.dev/guide/dockerfile
+	"image": "mcr.microsoft.com/devcontainers/rust:1-1-bullseye",
+
+	// Use 'mounts' to make the cargo cache persistent in a Docker Volume.
+	// "mounts": [
+	// 	{
+	// 		"source": "devcontainer-cargo-cache-${devcontainerId}",
+	// 		"target": "/usr/local/cargo",
+	// 		"type": "volume"
+	// 	}
+	// ]
+
+	// Features to add to the dev container. More info: https://containers.dev/features.
+	"features": {
+		"ghcr.io/devcontainers-contrib/features/zig:1": {
+			"version": "0.13.0"
+		},
+		"ghcr.io/devcontainers-community/features/llvm:3": {
+			"version": 18
+		}
+	},
+	// Use 'forwardPorts' to make a list of ports inside the container available locally.
+	// "forwardPorts": [],
+
+	// Use 'postCreateCommand' to run commands after the container is created.
+	// "postCreateCommand": "rustc --version",
+	"onCreateCommand": "sudo apt-get update && sudo apt-get install -y pkg-config libz-dev libzstd-dev valgrind"  
+
+	// Configure tool-specific properties.
+	// "customizations": {},
+
+	// Uncomment to connect as root instead. More info: https://aka.ms/dev-containers-non-root.
+	// "remoteUser": "root"
+}

CONTRIBUTING.md

@@ -68,6 +68,8 @@ programs.gnupg.agent = {
 <details>
 <summary>Forgot to sign commits?</summary>
 
+:exclamation: Make sure [to set up signing on your device](devtools/signing.md) first, then continue below.
+
 You can view your commits on github, those without the "Verified" badge still need to be signed.
 If any of those is a merge commit, follow [these steps](https://stackoverflow.com/a/9958215/4200103) instead of the ones below.
 

crates/compiler/builtins/roc/Num.roc

@@ -155,6 +155,7 @@ module [
     f64ToParts,
     f32FromParts,
     f64FromParts,
+    fromBool,
     nanF32,
     nanF64,
     infinityF32,
@@ -1458,6 +1459,18 @@ f32FromParts : { sign : Bool, exponent : U8, fraction : U32 } -> F32
 ## The exponent should not be bigger than 0x07FF, any bigger value will be truncated.
 f64FromParts : { sign : Bool, exponent : U16, fraction : U64 } -> F64
 
+## Convert a `Bool` to a `Num`
+## ```roc
+## expect (Num.fromBool Bool.true) == 1
+## expect (Num.fromBool Bool.false) == 0
+## ```
+fromBool : Bool -> Num *
+fromBool = \bool ->
+    if bool then
+        1
+    else
+        0
+
 ## The value for not-a-number for a [F32] according to the IEEE 754 standard.
 nanF32 : F32
 nanF32 = 0.0f32 / 0.0
@@ -1473,3 +1486,4 @@ infinityF32 = 1.0f32 / 0.0
 ## The value for infinity for a [F64] according to the IEEE 754 standard.
 infinityF64 : F64
 infinityF64 = 1.0f64 / 0.0
+

crates/compiler/builtins/roc/Task.roc

@@ -11,6 +11,7 @@ module [
     loop,
     fromResult,
     batch,
+    combine,
     sequence,
     forEach,
     result,
@@ -187,26 +188,35 @@ fromResult : Result a b -> Task a b
 fromResult = \res ->
     @Task \{} -> res
 
-## Apply a task to another task applicatively. This can be used with
+## Apply a task to another task applicatively.
-## [ok] to build a [Task] that returns a record.
 ##
-## The following example returns a Record with two fields, `apples` and
+## DEPRECATED: Modern record builders use [combine].
-## `oranges`, each of which is a `List Str`. If it fails it returns the tag
-## `NoFruitAvailable`.
-##
-## ```
-## getFruitBasket : Task { apples : List Str, oranges : List Str } [NoFruitAvailable]
-## getFruitBasket = Task.ok {
-##     apples: <- getFruit Apples |> Task.batch,
-##     oranges: <- getFruit Oranges |> Task.batch,
-## }
-## ```
 batch : Task a c -> (Task (a -> b) c -> Task b c)
 batch = \current ->
     \next ->
         await next \f ->
             map current f
 
+## Combine the values of two tasks with a custom combining function.
+##
+## This is primarily used with record builders.
+##
+## ```
+## { a, b, c } =
+##     { Task.combine <-
+##         a: Task.ok 123,
+##         b: File.read "file.txt",
+##         c: Http.get "http://api.com/",
+##     }!
+## ```
+combine : Task a err, Task b err, (a, b -> c) -> Task c err
+combine = \@Task leftTask, @Task rightTask, combiner ->
+    @Task \{} ->
+        left = try leftTask {}
+        right = try rightTask {}
+
+        Ok (combiner left right)
+
 ## Apply each task in a list sequentially, and return a list of the resulting values.
 ## Each task will be awaited before beginning the next task.
 ##

crates/compiler/fmt/src/annotation.rs

@@ -367,13 +367,13 @@ fn fmt_ty_ann(
         }
 
         TypeAnnotation::As(lhs, spaces, TypeHeader { name, vars }) => {
-            let write_parens = parens == Parens::InAsPattern;
+            let write_parens = parens == Parens::InAsPattern || parens == Parens::InApply;
 
+            buf.indent(indent);
             if write_parens {
                 buf.push('(')
             }
 
-            buf.indent(indent);
             let lhs_indent = buf.cur_line_indent();
             lhs.value
                 .format_with_options(buf, Parens::InAsPattern, Newlines::No, indent);
@@ -410,6 +410,7 @@ fn fmt_ty_ann(
                 buf.spaces(1);
             }
             for (i, has) in implements_clauses.iter().enumerate() {
+                buf.indent(indent);
                 buf.push_str(if i == 0 {
                     roc_parse::keyword::WHERE
                 } else {
@@ -1373,6 +1374,19 @@ impl<'a> Nodify<'a> for TypeAnnotation<'a> {
                     inner
                 }
             }
+            TypeAnnotation::As(_left, _sp, _right) => {
+                let lifted = ann_lift_spaces(arena, self);
+                let item = Spaces {
+                    before: lifted.before,
+                    item: Node::TypeAnnotation(lifted.item),
+                    after: lifted.after,
+                };
+                if parens == Parens::InApply || parens == Parens::InAsPattern {
+                    parens_around_node(arena, item)
+                } else {
+                    item
+                }
+            }
             _ => {
                 let lifted = ann_lift_spaces(arena, self);
                 Spaces {

crates/compiler/fmt/src/expr.rs

@@ -1405,8 +1405,12 @@ fn fmt_binops<'a>(
             expr_lift_spaces(Parens::InOperator, buf.text.bump(), &loc_left_side.value);
         format_spaces(buf, lifted_left_side.before, Newlines::Yes, indent);
 
+        buf.indent(indent);
+        let line_indent = buf.cur_line_indent();
+
         let need_parens = matches!(lifted_left_side.item, Expr::BinOps(..))
-            || starts_with_unary_minus(lifted_left_side.item);
+            || starts_with_unary_minus(lifted_left_side.item)
+            || (ends_with_closure(&lifted_left_side.item) && line_indent < indent);
 
         if need_parens {
             fmt_parens(&lifted_left_side.item, buf, indent);
@@ -1451,6 +1455,17 @@ fn fmt_binops<'a>(
     format_spaces(buf, lifted_right_side.after, Newlines::Yes, indent);
 }
 
+fn ends_with_closure(item: &Expr<'_>) -> bool {
+    match item {
+        Expr::Closure(..) => true,
+        Expr::Apply(expr, args, _) => args
+            .last()
+            .map(|a| ends_with_closure(&a.value))
+            .unwrap_or_else(|| ends_with_closure(&expr.value)),
+        _ => false,
+    }
+}
+
 fn starts_with_unary_minus(item: Expr<'_>) -> bool {
     match item {
         Expr::UnaryOp(
@@ -1616,6 +1631,7 @@ fn fmt_when<'a>(
         }
 
         if let Some(guard_expr) = &branch.guard {
+            buf.indent(indent + INDENT);
             buf.push_str(" if");
             buf.spaces(1);
             guard_expr.format_with_options(buf, Parens::NotNeeded, Newlines::Yes, indent + INDENT);

crates/compiler/module/src/symbol.rs

@@ -1349,6 +1349,7 @@ define_builtins! {
         166 NUM_NAN_F64: "nanF64"
         167 NUM_INFINITY_F32: "infinityF32"
         168 NUM_INFINITY_F64: "infinityF64"
+        169 NUM_FROM_BOOL: "fromBool"
     }
     4 BOOL: "Bool" => {
         0 BOOL_BOOL: "Bool" exposed_type=true // the Bool.Bool type alias
@@ -1729,9 +1730,10 @@ define_builtins! {
         9 TASK_MAP_ERR: "mapErr"
         10 TASK_FROM_RESULT: "fromResult"
         11 TASK_BATCH: "batch"
-        12 TASK_SEQUENCE: "sequence"
+        12 TASK_COMBINE: "combine"
-        13 TASK_FOR_EACH: "forEach"
+        13 TASK_SEQUENCE: "sequence"
-        14 TASK_RESULT: "result"
+        14 TASK_FOR_EACH: "forEach"
+        15 TASK_RESULT: "result"
     }
 
     num_modules: 16 // Keep this count up to date by hand! (TODO: see the mut_map! macro for how we could determine this count correctly in the macro)

crates/compiler/parse/src/keyword.rs

@@ -21,6 +21,7 @@ pub const WHERE: &str = "where";
 // These keywords are valid in headers
 pub const PLATFORM: &str = "platform";
 
-pub const KEYWORDS: [&str; 11] = [
+pub const KEYWORDS: [&str; 12] = [
     IF, THEN, ELSE, WHEN, AS, IS, DBG, IMPORT, EXPECT, RETURN, CRASH,
+    "expect!", // not itself a keyword, but it's problematic if we allow an identifier like this!
 ];

crates/compiler/test_gen/src/gen_num.rs

@@ -4084,6 +4084,40 @@ fn f64_from_parts() {
     );
 }
 
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn from_bool_true() {
+    assert_evals_to!(
+        indoc!(
+            r"
+            bool : Bool
+            bool = Bool.true
+
+            Num.fromBool bool
+            "
+        ),
+        1,
+        u64
+    );
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
+fn from_bool_false() {
+    assert_evals_to!(
+        indoc!(
+            r"
+            bool : Bool
+            bool = Bool.false
+
+            Num.fromBool bool
+            "
+        ),
+        0,
+        u64
+    );
+}
+
 #[test]
 #[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
 fn nan_f32() {

crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt

@@ -79,16 +79,16 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
     jump List.679 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    ret Num.286;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.282 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    let Num.284 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.677;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.677;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.669;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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

@@ -90,12 +90,12 @@ procedure List.9 (List.391):
         ret List.661;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Result.5 (Result.14, Result.15):
     let Result.63 : U8 = 1i64;

crates/compiler/test_mono/generated/choose_i128_layout.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.282 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.284 : I128 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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.281 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : U128 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.669;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.248 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/dbg_expr.txt

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

crates/compiler/test_mono/generated/dbg_nested_expr.txt

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

crates/compiler/test_mono/generated/dec_refcount_for_usage_after_early_return_in_if.txt

@@ -3,12 +3,12 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     ret Bool.24;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.285 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Num.96 (#Attr.2):
-    let Num.282 : Str = lowlevel NumToStr #Attr.2;
+    let Num.284 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.282;
+    ret Num.284;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.247 : 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.659;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.281 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    let Num.283 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.664;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.709;
 
 procedure Num.127 (#Attr.2):
-    let Num.286 : U8 = lowlevel NumIntCast #Attr.2;
+    let Num.288 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.286;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.288 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.288;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.287 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.287;
+    ret Num.289;
 
 procedure Num.96 (#Attr.2):
-    let Num.285 : Str = lowlevel NumToStr #Attr.2;
+    let Num.287 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.285;
+    ret Num.287;
 
 procedure Str.12 (#Attr.2):
     let Str.258 : 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.683;
 
 procedure Num.127 (#Attr.2):
-    let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
+    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.282;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.284;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.286;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Num.96 (#Attr.2):
-    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.12 (#Attr.2):
     let Str.255 : 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.683;
 
 procedure Num.127 (#Attr.2):
-    let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
+    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.282;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.284;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.286;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Num.96 (#Attr.2):
-    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.12 (#Attr.2):
     let Str.255 : 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.671;
 
 procedure Num.127 (#Attr.2):
-    let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
+    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.96 (#Attr.2):
-    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.12 (#Attr.2):
     let Str.255 : 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.683;
 
 procedure Num.127 (#Attr.2):
-    let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
+    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.282;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.284;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.286;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Num.96 (#Attr.2):
-    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.12 (#Attr.2):
     let Str.255 : 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.683;
 
 procedure Num.127 (#Attr.2):
-    let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
+    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.282;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.284;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.286;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Num.96 (#Attr.2):
-    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.12 (#Attr.2):
     let Str.255 : 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.282 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.284 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.281 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.282 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.284 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.285 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 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.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Test.2 (Test.3, Test.1):
     let Test.18 : Int1 = false;

crates/compiler/test_mono/generated/inspect_derived_dict.txt

@@ -1057,131 +1057,131 @@ procedure List.98 (#Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
     jump List.710 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
 
 procedure Num.131 (#Attr.2):
-    let Num.289 : U32 = lowlevel NumIntCast #Attr.2;
+    let Num.291 : U32 = lowlevel NumIntCast #Attr.2;
-    ret Num.289;
-
-procedure Num.133 (#Attr.2):
-    let Num.297 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.297;
-
-procedure Num.133 (#Attr.2):
-    let Num.346 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.346;
-
-procedure Num.133 (#Attr.2):
-    let Num.361 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.361;
-
-procedure Num.135 (#Attr.2):
-    let Num.367 : U128 = lowlevel NumIntCast #Attr.2;
-    ret Num.367;
-
-procedure Num.139 (#Attr.2):
-    let Num.315 : Float32 = lowlevel NumToFloatCast #Attr.2;
-    ret Num.315;
-
-procedure Num.148 (Num.225, Num.226):
-    let Num.317 : Int1 = CallByName Num.22 Num.225 Num.226;
-    if Num.317 then
-        ret Num.225;
-    else
-        ret Num.226;
-
-procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.314 : Float32 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.314;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.311 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.311;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.440 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.440;
-
-procedure Num.23 (#Attr.2, #Attr.3):
-    let Num.433 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
-    ret Num.433;
-
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.295 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.295;
-
-procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.436 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.436;
-
-procedure Num.25 (#Attr.2, #Attr.3):
-    let Num.437 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
-    ret Num.437;
-
-procedure Num.50 (#Attr.2):
-    let Num.313 : U64 = lowlevel NumFloor #Attr.2;
-    ret Num.313;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U32 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
-
-procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.439 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.439;
-
-procedure Num.69 (#Attr.2, #Attr.3):
-    let Num.303 : U32 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3;
-    ret Num.303;
-
-procedure Num.70 (#Attr.2, #Attr.3):
-    let Num.344 : U64 = lowlevel NumBitwiseXor #Attr.2 #Attr.3;
-    ret Num.344;
-
-procedure Num.71 (#Attr.2, #Attr.3):
-    let Num.302 : U32 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
-    ret Num.302;
-
-procedure Num.71 (#Attr.2, #Attr.3):
-    let Num.381 : U64 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
-    ret Num.381;
-
-procedure Num.72 (#Attr.2, #Attr.3):
-    let Num.284 : U32 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
-    ret Num.284;
-
-procedure Num.72 (#Attr.2, #Attr.3):
-    let Num.396 : U64 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
-    ret Num.396;
-
-procedure Num.74 (#Attr.2, #Attr.3):
-    let Num.362 : U128 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
-    ret Num.362;
-
-procedure Num.74 (#Attr.2, #Attr.3):
-    let Num.364 : U64 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
-    ret Num.364;
-
-procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.291 : U32 = lowlevel NumSubWrap #Attr.2 #Attr.3;
     ret Num.291;
 
-procedure Num.75 (#Attr.2, #Attr.3):
+procedure Num.133 (#Attr.2):
-    let Num.294 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    let Num.299 : U64 = lowlevel NumIntCast #Attr.2;
-    ret Num.294;
+    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.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.442 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.442;
+
+procedure Num.23 (#Attr.2, #Attr.3):
+    let Num.435 : Int1 = lowlevel NumLte #Attr.2 #Attr.3;
+    ret Num.435;
+
+procedure Num.24 (#Attr.2, #Attr.3):
+    let Num.297 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    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.439 : Int1 = lowlevel NumGte #Attr.2 #Attr.3;
+    ret Num.439;
+
+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.441 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.441;
+
+procedure Num.69 (#Attr.2, #Attr.3):
+    let Num.305 : U32 = lowlevel NumBitwiseAnd #Attr.2 #Attr.3;
+    ret Num.305;
+
+procedure Num.70 (#Attr.2, #Attr.3):
+    let Num.346 : U64 = lowlevel NumBitwiseXor #Attr.2 #Attr.3;
+    ret Num.346;
+
+procedure Num.71 (#Attr.2, #Attr.3):
+    let Num.304 : U32 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
+    ret Num.304;
+
+procedure Num.71 (#Attr.2, #Attr.3):
+    let Num.383 : U64 = lowlevel NumBitwiseOr #Attr.2 #Attr.3;
+    ret Num.383;
+
+procedure Num.72 (#Attr.2, #Attr.3):
+    let Num.286 : U32 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
+    ret Num.286;
+
+procedure Num.72 (#Attr.2, #Attr.3):
+    let Num.398 : U64 = lowlevel NumShiftLeftBy #Attr.2 #Attr.3;
+    ret Num.398;
+
+procedure Num.74 (#Attr.2, #Attr.3):
+    let Num.364 : U128 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
+    ret Num.364;
+
+procedure Num.74 (#Attr.2, #Attr.3):
+    let Num.366 : U64 = lowlevel NumShiftRightZfBy #Attr.2 #Attr.3;
+    ret Num.366;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.430 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    let Num.293 : U32 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.430;
+    ret Num.293;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.296 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.296;
+
+procedure Num.75 (#Attr.2, #Attr.3):
+    let Num.432 : U64 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.432;
 
 procedure Num.78 (#Attr.2, #Attr.3):
-    let Num.365 : U128 = lowlevel NumMulWrap #Attr.2 #Attr.3;
+    let Num.367 : U128 = lowlevel NumMulWrap #Attr.2 #Attr.3;
-    ret Num.365;
+    ret Num.367;
 
 procedure Num.96 (#Attr.2):
-    let Num.310 : Str = lowlevel NumToStr #Attr.2;
+    let Num.312 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.310;
+    ret Num.312;
 
 procedure Num.96 (#Attr.2):
-    let Num.438 : Str = lowlevel NumToStr #Attr.2;
+    let Num.440 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.438;
+    ret Num.440;
 
 procedure Str.12 (#Attr.2):
     let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/inspect_derived_list.txt

@@ -166,16 +166,16 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.669;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.282 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.284 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.96 (#Attr.2):
-    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt

@@ -284,12 +284,12 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.681;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    ret Num.286;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.247 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record.txt

@@ -193,20 +193,20 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.669;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    ret Num.286;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.285;
+
+procedure Num.96 (#Attr.2):
+    let Num.283 : Str = lowlevel NumToStr #Attr.2;
     ret Num.283;
 
 procedure Num.96 (#Attr.2):
-    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    let Num.284 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.281;
+    ret Num.284;
-
-procedure Num.96 (#Attr.2):
-    let Num.282 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.282;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt

@@ -171,12 +171,12 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.669;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt

@@ -178,12 +178,12 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.669;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt

@@ -171,12 +171,12 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.669;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.246 : Str = lowlevel StrConcat #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt

@@ -174,12 +174,12 @@ procedure List.66 (#Attr.2, #Attr.3):
     ret List.669;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.246 : 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.659;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumRound #Attr.2;
+    let Num.283 : I64 = lowlevel NumRound #Attr.2;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.283 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
+    let Num.285 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Num.30 (#Attr.2):
-    let Num.288 : I64 = 0i64;
+    let Num.290 : I64 = 0i64;
-    let Num.287 : Int1 = lowlevel Eq #Attr.2 Num.288;
+    let Num.289 : Int1 = lowlevel Eq #Attr.2 Num.290;
-    ret Num.287;
+    ret Num.289;
 
-procedure Num.40 (Num.249, Num.250):
+procedure Num.40 (Num.250, Num.251):
-    let Num.284 : Int1 = CallByName Num.30 Num.250;
+    let Num.286 : Int1 = CallByName Num.30 Num.251;
-    if Num.284 then
+    if Num.286 then
-        let Num.286 : {} = Struct {};
+        let Num.288 : {} = Struct {};
-        let Num.285 : [C {}, C I64] = TagId(0) Num.286;
+        let Num.287 : [C {}, C I64] = TagId(0) Num.288;
-        ret Num.285;
+        ret Num.287;
     else
-        let Num.282 : I64 = CallByName Num.157 Num.249 Num.250;
+        let Num.284 : I64 = CallByName Num.157 Num.250 Num.251;
-        let Num.281 : [C {}, C I64] = TagId(1) Num.282;
+        let Num.283 : [C {}, C I64] = TagId(1) Num.284;
-        ret Num.281;
+        ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.391):
         ret List.661;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.27 (Str.84):
     let Str.246 : [C Int1, C I64] = CallByName Str.66 Str.84;

crates/compiler/test_mono/generated/issue_4770.txt

@@ -119,24 +119,24 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
     inc #Derived_gen.0;
     jump List.675 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
-procedure Num.148 (Num.225, Num.226):
+procedure Num.148 (Num.226, Num.227):
-    let Num.288 : Int1 = CallByName Num.22 Num.225 Num.226;
+    let Num.290 : Int1 = CallByName Num.22 Num.226 Num.227;
-    if Num.288 then
+    if Num.290 then
-        ret Num.225;
-    else
         ret Num.226;
+    else
+        ret Num.227;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.288 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.286;
+    ret Num.288;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.284 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.284;
+    ret Num.286;
 
 procedure Test.1 (#Derived_gen.5):
     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.281 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : Str = lowlevel NumToStr #Attr.2;
+    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.281;
+    ret Num.283;
 
 procedure Num.96 (#Attr.2):
-    let Num.282 : Str = lowlevel NumToStr #Attr.2;
+    let Num.284 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.282;
+    ret Num.284;
 
 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.2 ():
     ret Bool.24;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.282 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.284 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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.669;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.219):
+procedure Num.31 (Num.220):
-    let Num.282 : I64 = 2i64;
+    let Num.284 : I64 = 2i64;
-    let Num.281 : Int1 = CallByName Num.86 Num.219 Num.282;
+    let Num.283 : Int1 = CallByName Num.86 Num.220 Num.284;
-    ret Num.281;
+    ret Num.283;
 
 procedure Num.86 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
+    let Num.285 : Int1 = lowlevel NumIsMultipleOf #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.666;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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.664;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.660;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.683;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Str.16 (#Attr.2, #Attr.3):
     let Str.246 : 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.683;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.247 : 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.677;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.283 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.285 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.283;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.285;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.287 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.287;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.284 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.284;
+    ret Num.286;
 
 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.664;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.386):
     ret List.659;
 
 procedure Num.46 (#Attr.2, #Attr.3):
-    let Num.281 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
+    let Num.283 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
+    let Num.283 : Decimal = lowlevel NumDivFrac #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.283 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.285 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 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.302):
     ret Inspect.302;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Num.96 (#Attr.2):
-    let Num.282 : Str = lowlevel NumToStr #Attr.2;
+    let Num.284 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.282;
+    ret Num.284;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.246 : 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.282 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.284 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 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

@@ -38,8 +38,8 @@ procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
     ret List.664;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 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.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    ret Num.286;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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_as_pattern_in_closure_arg.txt

@@ -1,6 +1,6 @@
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.664;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : U32 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.677;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.11 (#Attr.2, #Attr.3):
     ret Bool.23;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.282 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.284 : U8 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.281 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.283 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
     let Str.248 : 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.664;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 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.282 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.284 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.24 (#Attr.2, #Attr.3):
-    let Num.283 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
+    let Num.285 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 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.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.281 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.284 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.281 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.282 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    let Num.284 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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

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

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt

@@ -176,20 +176,20 @@ procedure List.8 (#Attr.2, #Attr.3):
     ret List.710;
 
 procedure Num.127 (#Attr.2):
-    let Num.286 : U8 = lowlevel NumIntCast #Attr.2;
+    let Num.288 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.286;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.288 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.288;
 
+procedure Num.22 (#Attr.2, #Attr.3):
+    let Num.290 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.290;
+
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.287 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.289 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.287;
+    ret Num.289;
 
 procedure Num.96 (#Attr.2):
-    let Num.285 : Str = lowlevel NumToStr #Attr.2;
+    let Num.287 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.285;
+    ret Num.287;
 
 procedure Str.12 (#Attr.2):
     let Str.250 : List U8 = lowlevel StrToUtf8 #Attr.2;

crates/compiler/test_mono/generated/weakening_avoids_overspecialization.txt

@@ -79,16 +79,16 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
     jump List.679 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    ret Num.286;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.283;
+    ret Num.285;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.282 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    let Num.284 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.282;
+    ret Num.284;
 
 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.281 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    ret Num.283;
 
 procedure Test.0 ():
     let Test.15 : I64 = 3i64;

crates/compiler/test_syntax/src/minimize.rs

@@ -112,7 +112,11 @@ fn round_trip_once(input: Input<'_>, options: Options) -> Option<String> {
     };
 
     if actual.is_malformed() {
-        return Some("Initial parse is malformed".to_string());
+        if options.minimize_initial_parse_error {
+            return Some("Initial parse is malformed".to_string());
+        } else {
+            return None;
+        }
     }
 
     let output = actual.format();