Merge remote-tracking branch 'remote/main' into upgrade-llvm-zig

crates/compiler/builtins/roc/Result.roc

@@ -1,4 +1,15 @@
-module [Result, isOk, isErr, map, mapErr, try, onErr, withDefault]
+module [
+    Result,
+    isOk,
+    isErr,
+    map,
+    mapErr,
+    mapBoth,
+    map2,
+    try,
+    onErr,
+    withDefault,
+]
 
 import Bool exposing [Bool]
 
@@ -67,6 +78,22 @@ mapErr = \result, transform ->
         Ok v -> Ok v
         Err e -> Err (transform e)
 
+## Maps both the `Ok` and `Err` values of a `Result` to new values.
+mapBoth : Result ok1 err1, (ok1 -> ok2), (err1 -> err2) -> Result ok2 err2
+mapBoth = \result, okTransform, errTransform ->
+    when result is
+        Ok val -> Ok (okTransform val)
+        Err err -> Err (errTransform err)
+
+## Maps the `Ok` values of two `Result`s to a new value using a given transformation,
+## or returns the first `Err` value encountered.
+map2 : Result a err, Result b err, (a, b -> c) -> Result c err
+map2 = \firstResult, secondResult, transform ->
+    when (firstResult, secondResult) is
+        (Ok first, Ok second) -> Ok (transform first second)
+        (Err err, _) -> Err err
+        (_, Err err) -> Err err
+
 ## If the result is `Ok`, transforms the entire result by running a conversion
 ## function on the value the `Ok` holds. Then returns that new result. If the
 ## result is `Err`, this has no effect. Use `onErr` to transform an `Err`.

crates/compiler/can/src/annotation.rs

@@ -1,6 +1,6 @@
 use crate::env::Env;
 use crate::procedure::{QualifiedReference, References};
-use crate::scope::{PendingAbilitiesInScope, Scope};
+use crate::scope::{PendingAbilitiesInScope, Scope, SymbolLookup};
 use roc_collections::{ImMap, MutSet, SendMap, VecMap, VecSet};
 use roc_module::ident::{Ident, Lowercase, TagName};
 use roc_module::symbol::Symbol;
@@ -386,7 +386,10 @@ pub(crate) fn make_apply_symbol(
         // Look it up in scope!
 
         match scope.lookup_str(ident, region) {
-            Ok(symbol) => {
+            Ok(SymbolLookup {
+                symbol,
+                module_params: _,
+            }) => {
                 references.insert_type_lookup(symbol, QualifiedReference::Unqualified);
                 Ok(symbol)
             }
@@ -398,7 +401,10 @@ pub(crate) fn make_apply_symbol(
         }
     } else {
         match env.qualified_lookup(scope, module_name, ident, region) {
-            Ok(symbol) => {
+            Ok(SymbolLookup {
+                symbol,
+                module_params: _,
+            }) => {
                 references.insert_type_lookup(symbol, QualifiedReference::Qualified);
                 Ok(symbol)
             }
@@ -467,7 +473,8 @@ pub fn find_type_def_symbols(
                 while let Some(assigned_field) = inner_stack.pop() {
                     match assigned_field {
                         AssignedField::RequiredValue(_, _, t)
-                        | AssignedField::OptionalValue(_, _, t) => {
+                        | AssignedField::OptionalValue(_, _, t)
+                        | AssignedField::IgnoredValue(_, _, t) => {
                             stack.push(&t.value);
                         }
                         AssignedField::LabelOnly(_) => {}
@@ -1386,6 +1393,7 @@ fn can_assigned_fields<'a>(
 
                     break 'inner label;
                 }
+                IgnoredValue(_, _, _) => unreachable!(),
                 LabelOnly(loc_field_name) => {
                     // Interpret { a, b } as { a : a, b : b }
                     let field_name = Lowercase::from(loc_field_name.value);

crates/compiler/can/src/constraint.rs

@@ -602,7 +602,8 @@ impl Constraints {
             | Constraint::Exhaustive { .. }
             | Constraint::Resolve(..)
             | Constraint::IngestedFile(..)
-            | Constraint::CheckCycle(..) => false,
+            | Constraint::CheckCycle(..)
+            | Constraint::ImportParams(..) => false,
         }
     }
 
@@ -685,6 +686,15 @@ impl Constraints {
     ) -> Constraint {
         Constraint::IngestedFile(type_index, file_path, bytes)
     }
+
+    pub fn import_params(
+        &mut self,
+        opt_type_index: Option<TypeOrVar>,
+        module_id: ModuleId,
+        region: Region,
+    ) -> Constraint {
+        Constraint::ImportParams(opt_type_index, module_id, region)
+    }
 }
 
 roc_error_macros::assert_sizeof_default!(Constraint, 3 * 8);
@@ -787,6 +797,7 @@ pub enum Constraint {
     CheckCycle(Index<Cycle>, IllegalCycleMark),
 
     IngestedFile(TypeOrVar, Box<PathBuf>, Arc<Vec<u8>>),
+    ImportParams(Option<TypeOrVar>, ModuleId, Region),
 }
 
 #[derive(Debug, Clone, Copy, Default)]
@@ -865,6 +876,9 @@ impl std::fmt::Debug for Constraint {
             Self::IngestedFile(arg0, arg1, arg2) => {
                 write!(f, "IngestedFile({arg0:?}, {arg1:?}, {arg2:?})")
             }
+            Self::ImportParams(arg0, arg1, arg2) => {
+                write!(f, "ImportParams({arg0:?}, {arg1:?}, {arg2:?})")
+            }
         }
     }
 }

crates/compiler/can/src/copy.rs

@@ -288,6 +288,22 @@ fn deep_copy_expr_help<C: CopyEnv>(env: &mut C, copied: &mut Vec<Variable>, expr
             loc_elems: loc_elems.iter().map(|le| le.map(|e| go_help!(e))).collect(),
         },
         Var(sym, var) => Var(*sym, sub!(*var)),
+        ParamsVar {
+            symbol,
+            params,
+            var,
+        } => ParamsVar {
+            symbol: *symbol,
+            params: *params,
+            var: sub!(*var),
+        },
+        ImportParams(module_id, region, opt_provided) => ImportParams(
+            *module_id,
+            *region,
+            opt_provided
+                .as_ref()
+                .map(|(var, expr)| (sub!(*var), Box::new(go_help!(&expr)))),
+        ),
         &AbilityMember(sym, specialization, specialization_var) => {
             AbilityMember(sym, specialization, sub!(specialization_var))
         }

crates/compiler/can/src/debug/pretty_print.rs

@@ -206,7 +206,13 @@ fn expr<'a>(c: &Ctx, p: EPrec, f: &'a Arena<'a>, e: &'a Expr) -> DocBuilder<'a,
                     .append("]")
                     .group(),
             ),
-        Var(sym, _) | AbilityMember(sym, _, _) => pp_sym(c, f, *sym),
+        Var(sym, _) | ParamsVar { symbol: sym, .. } | AbilityMember(sym, _, _) => {
+            pp_sym(c, f, *sym)
+        }
+        ImportParams(_, _, Some((_, params_expr))) => expr(c, p, f, params_expr),
+        ImportParams(module_id, _, None) => {
+            text!(f, "<no params for {:?}>", module_id)
+        }
         When {
             loc_cond, branches, ..
         } => maybe_paren!(

crates/compiler/can/src/def.rs

@@ -10,6 +10,7 @@ use crate::annotation::IntroducedVariables;
 use crate::annotation::OwnedNamedOrAble;
 use crate::derive;
 use crate::env::Env;
+use crate::expr::canonicalize_record;
 use crate::expr::get_lookup_symbols;
 use crate::expr::AnnotatedMark;
 use crate::expr::ClosureData;
@@ -18,6 +19,7 @@ use crate::expr::Expr::{self, *};
 use crate::expr::StructAccessorData;
 use crate::expr::{canonicalize_expr, Output, Recursive};
 use crate::pattern::{canonicalize_def_header_pattern, BindingsFromPattern, Pattern};
+use crate::procedure::QualifiedReference;
 use crate::procedure::References;
 use crate::scope::create_alias;
 use crate::scope::{PendingAbilitiesInScope, Scope};
@@ -160,6 +162,13 @@ enum PendingValueDef<'a> {
         &'a Loc<ast::TypeAnnotation<'a>>,
         &'a Loc<ast::Expr<'a>>,
     ),
+    /// Module params from an import
+    ImportParams {
+        symbol: Symbol,
+        loc_pattern: Loc<Pattern>,
+        module_id: ModuleId,
+        opt_provided: Option<ast::Collection<'a, Loc<AssignedField<'a, ast::Expr<'a>>>>>,
+    },
     /// Ingested file
     IngestedFile(
         Loc<Pattern>,
@@ -174,6 +183,12 @@ impl PendingValueDef<'_> {
             PendingValueDef::AnnotationOnly(loc_pattern, _) => loc_pattern,
             PendingValueDef::Body(loc_pattern, _) => loc_pattern,
             PendingValueDef::TypedBody(_, loc_pattern, _, _) => loc_pattern,
+            PendingValueDef::ImportParams {
+                loc_pattern,
+                symbol: _,
+                module_id: _,
+                opt_provided: _,
+            } => loc_pattern,
             PendingValueDef::IngestedFile(loc_pattern, _, _) => loc_pattern,
         }
     }
@@ -485,6 +500,16 @@ fn canonicalize_alias<'a>(
     }
 }
 
+#[macro_export]
+macro_rules! params_in_abilities_unimplemented {
+    ($lookup:expr) => {
+        match $lookup.module_params {
+            None => $lookup.symbol,
+            Some(_) => unimplemented!("params in abilities"),
+        }
+    };
+}
+
 /// Canonicalizes a claimed ability implementation like `{ eq }` or `{ eq: myEq }`.
 /// Returns a mapping of the ability member to the implementation symbol.
 /// If there was an error, a problem will be recorded and nothing is returned.
@@ -503,7 +528,7 @@ fn canonicalize_claimed_ability_impl<'a>(
 
             let member_symbol =
                 match env.qualified_lookup_with_module_id(scope, ability_home, label_str, region) {
-                    Ok(symbol) => symbol,
+                    Ok(lookup) => params_in_abilities_unimplemented!(lookup),
                     Err(_) => {
                         env.problem(Problem::NotAnAbilityMember {
                             ability,
@@ -546,8 +571,13 @@ fn canonicalize_claimed_ability_impl<'a>(
             // To handle both cases, try checking for a shadow first, then check for a direct
             // reference. We want to check for a direct reference second so that if there is a
             // shadow, we won't accidentally grab the imported symbol.
-            let opt_impl_symbol = (scope.lookup_ability_member_shadow(member_symbol))
-                .or_else(|| scope.lookup_str(label_str, region).ok());
+            let opt_impl_symbol =
+                (scope.lookup_ability_member_shadow(member_symbol)).or_else(|| {
+                    scope
+                        .lookup_str(label_str, region)
+                        .map(|s| params_in_abilities_unimplemented!(s))
+                        .ok()
+                });
 
             match opt_impl_symbol {
                 // It's possible that even if we find a symbol it is still only the member
@@ -599,7 +629,7 @@ fn canonicalize_claimed_ability_impl<'a>(
                 label.value,
                 label.region,
             ) {
-                Ok(symbol) => symbol,
+                Ok(lookup) => params_in_abilities_unimplemented!(lookup),
                 Err(_) => {
                     env.problem(Problem::NotAnAbilityMember {
                         ability,
@@ -611,7 +641,7 @@ fn canonicalize_claimed_ability_impl<'a>(
             };
 
             let impl_symbol = match scope.lookup(&impl_ident.into(), impl_region) {
-                Ok(symbol) => symbol,
+                Ok(symbol) => params_in_abilities_unimplemented!(symbol),
                 Err(err) => {
                     env.problem(Problem::RuntimeError(err));
                     return Err(());
@@ -631,7 +661,9 @@ fn canonicalize_claimed_ability_impl<'a>(
             // An error will already have been reported
             Err(())
         }
-        AssignedField::SpaceBefore(_, _) | AssignedField::SpaceAfter(_, _) => {
+        AssignedField::SpaceBefore(_, _)
+        | AssignedField::SpaceAfter(_, _)
+        | AssignedField::IgnoredValue(_, _, _) => {
             internal_error!("unreachable")
         }
     }
@@ -1107,8 +1139,24 @@ fn canonicalize_value_defs<'a>(
             PendingValue::ExpectFx(pending_expect) => {
                 pending_expect_fx.push(pending_expect);
             }
-            PendingValue::ModuleImport(introduced_import) => {
-                imports_introduced.push(introduced_import);
+            PendingValue::ModuleImport(PendingModuleImport {
+                module_id,
+                region,
+                exposed_symbols,
+                params,
+            }) => {
+                imports_introduced.push(IntroducedImport {
+                    module_id,
+                    region,
+                    exposed_symbols,
+                });
+
+                pending_value_defs.push(PendingValueDef::ImportParams {
+                    symbol: params.symbol,
+                    loc_pattern: params.loc_pattern,
+                    opt_provided: params.opt_provided,
+                    module_id,
+                });
             }
             PendingValue::InvalidIngestedFile => { /* skip */ }
             PendingValue::ImportNameConflict => { /* skip */ }
@@ -1556,7 +1604,7 @@ impl DefOrdering {
     fn insert_symbol_references(&mut self, def_id: u32, def_references: &DefReferences) {
         match def_references {
             DefReferences::Value(references) => {
-                let it = references.value_lookups().chain(references.calls());
+                let it = references.value_lookups();
 
                 for referenced in it {
                     if let Some(ref_id) = self.get_id(*referenced) {
@@ -2350,6 +2398,50 @@ fn canonicalize_pending_value_def<'a>(
                 None,
             )
         }
+        ImportParams {
+            symbol,
+            loc_pattern,
+            module_id,
+            opt_provided,
+        } => {
+            // Insert a reference to the record so that we don't report it as unused
+            // If the whole module is unused, we'll report that separately
+            output
+                .references
+                .insert_value_lookup(symbol, QualifiedReference::Unqualified);
+
+            let (opt_var_record, references) = match opt_provided {
+                Some(params) => {
+                    let (record, can_output) =
+                        canonicalize_record(env, var_store, scope, loc_pattern.region, params);
+
+                    let references = can_output.references.clone();
+                    output.union(can_output);
+
+                    (Some((var_store.fresh(), Box::new(record))), references)
+                }
+                None => (None, References::new()),
+            };
+
+            let loc_expr = Loc::at(
+                loc_pattern.region,
+                Expr::ImportParams(module_id, loc_pattern.region, opt_var_record),
+            );
+
+            let def = single_can_def(
+                loc_pattern,
+                loc_expr,
+                var_store.fresh(),
+                None,
+                SendMap::default(),
+            );
+
+            DefOutput {
+                output,
+                references: DefReferences::Value(references),
+                def,
+            }
+        }
         IngestedFile(loc_pattern, opt_loc_ann, path_literal) => {
             let relative_path =
                 if let ast::StrLiteral::PlainLine(ingested_path) = path_literal.value {
@@ -2891,7 +2983,7 @@ enum PendingValue<'a> {
     Dbg(PendingExpectOrDbg<'a>),
     Expect(PendingExpectOrDbg<'a>),
     ExpectFx(PendingExpectOrDbg<'a>),
-    ModuleImport(IntroducedImport),
+    ModuleImport(PendingModuleImport<'a>),
     SignatureDefMismatch,
     InvalidIngestedFile,
     ImportNameConflict,
@@ -2902,6 +2994,19 @@ struct PendingExpectOrDbg<'a> {
     preceding_comment: Region,
 }
 
+struct PendingModuleImport<'a> {
+    module_id: ModuleId,
+    region: Region,
+    exposed_symbols: Vec<(Symbol, Region)>,
+    params: PendingModuleImportParams<'a>,
+}
+
+struct PendingModuleImportParams<'a> {
+    symbol: Symbol,
+    loc_pattern: Loc<Pattern>,
+    opt_provided: Option<ast::Collection<'a, Loc<AssignedField<'a, ast::Expr<'a>>>>>,
+}
+
 pub struct IntroducedImport {
     module_id: ModuleId,
     region: Region,
@@ -3051,10 +3156,27 @@ fn to_pending_value_def<'a>(
                 None => module_name.clone(),
             };
 
+            // Generate a symbol for the module params def
+            // We do this even if params weren't provided so that solve can report if they are missing
+            let params_sym = scope.gen_unique_symbol();
+            let params_region = module_import.params.map(|p| p.params.region).unwrap_or(region);
+            let params =
+                PendingModuleImportParams {
+                    symbol: params_sym,
+                    loc_pattern: Loc::at(params_region, Pattern::Identifier(params_sym)),
+                    opt_provided: module_import.params.map(|p| p.params.value),
+                };
+            let provided_params_sym = if module_import.params.is_some() {
+                // Only add params to scope if they are provided
+                Some(params_sym)
+            } else {
+                None
+            };
+
             if let Err(existing_import) =
                 scope
                     .modules
-                    .insert(name_with_alias.clone(), module_id, region)
+                    .insert(name_with_alias.clone(), module_id, provided_params_sym, region)
             {
                 env.problems.push(Problem::ImportNameConflict {
                     name: name_with_alias,
@@ -3065,7 +3187,7 @@ fn to_pending_value_def<'a>(
                 });
 
                 return PendingValue::ImportNameConflict;
-            }
+            };
 
             let exposed_names = module_import
                 .exposed
@@ -3117,13 +3239,13 @@ fn to_pending_value_def<'a>(
                         }))
                     }
                 }
-
             }
 
-            PendingValue::ModuleImport(IntroducedImport {
+            PendingValue::ModuleImport(PendingModuleImport {
                 module_id,
                 region,
                 exposed_symbols,
+                params,
             })
         }
         IngestedFileImport(ingested_file) => {

crates/compiler/can/src/desugar.rs

@@ -140,7 +140,9 @@ fn desugar_value_def<'a>(
             let desugared_params =
                 params.map(|ModuleImportParams { before, params }| ModuleImportParams {
                     before,
-                    params: desugar_field_collection(arena, params, src, line_info, module_path),
+                    params: params.map(|params| {
+                        desugar_field_collection(arena, *params, src, line_info, module_path)
+                    }),
                 });
 
             ModuleImport(roc_parse::ast::ModuleImport {
@@ -521,44 +523,68 @@ pub fn desugar_expr<'a>(
                 });
             }
 
-            let mut field_names = Vec::with_capacity_in(fields.len(), arena);
-            let mut field_vals = Vec::with_capacity_in(fields.len(), arena);
-
-            for field in fields.items {
-                match desugar_field(arena, &field.value, src, line_info, module_path) {
-                    AssignedField::RequiredValue(loc_name, _, loc_val) => {
-                        field_names.push(loc_name);
-                        field_vals.push(loc_val);
-                    }
-                    AssignedField::LabelOnly(loc_name) => {
-                        field_names.push(loc_name);
-                        field_vals.push(arena.alloc(Loc {
-                            region: loc_name.region,
-                            value: Expr::Var {
-                                module_name: "",
-                                ident: loc_name.value,
-                            },
-                        }));
-                    }
-                    AssignedField::OptionalValue(loc_name, _, loc_val) => {
-                        return arena.alloc(Loc {
-                            region: loc_expr.region,
-                            value: OptionalFieldInRecordBuilder(arena.alloc(loc_name), loc_val),
-                        });
-                    }
-                    AssignedField::SpaceBefore(_, _) | AssignedField::SpaceAfter(_, _) => {
-                        unreachable!("Should have been desugared in `desugar_field`")
-                    }
-                    AssignedField::Malformed(_name) => {}
-                }
+            struct FieldData<'d> {
+                name: Loc<&'d str>,
+                value: &'d Loc<Expr<'d>>,
+                ignored: bool,
             }
 
-            let closure_arg_from_field = |field: Loc<&'a str>| Loc {
-                region: field.region,
-                value: Pattern::Identifier {
-                    ident: arena.alloc_str(&format!("#{}", field.value)),
-                },
-            };
+            let mut field_data = Vec::with_capacity_in(fields.len(), arena);
+
+            for field in fields.items {
+                let (name, value, ignored) =
+                    match desugar_field(arena, &field.value, src, line_info, module_path) {
+                        AssignedField::RequiredValue(loc_name, _, loc_val) => {
+                            (loc_name, loc_val, false)
+                        }
+                        AssignedField::IgnoredValue(loc_name, _, loc_val) => {
+                            (loc_name, loc_val, true)
+                        }
+                        AssignedField::LabelOnly(loc_name) => (
+                            loc_name,
+                            &*arena.alloc(Loc {
+                                region: loc_name.region,
+                                value: Expr::Var {
+                                    module_name: "",
+                                    ident: loc_name.value,
+                                },
+                            }),
+                            false,
+                        ),
+                        AssignedField::OptionalValue(loc_name, _, loc_val) => {
+                            return arena.alloc(Loc {
+                                region: loc_expr.region,
+                                value: OptionalFieldInRecordBuilder(arena.alloc(loc_name), loc_val),
+                            });
+                        }
+                        AssignedField::SpaceBefore(_, _) | AssignedField::SpaceAfter(_, _) => {
+                            unreachable!("Should have been desugared in `desugar_field`")
+                        }
+                        AssignedField::Malformed(_name) => continue,
+                    };
+
+                field_data.push(FieldData {
+                    name,
+                    value,
+                    ignored,
+                });
+            }
+
+            let closure_arg_from_field =
+                |FieldData {
+                     name,
+                     value: _,
+                     ignored,
+                 }: &FieldData<'a>| Loc {
+                    region: name.region,
+                    value: if *ignored {
+                        Pattern::Underscore(name.value)
+                    } else {
+                        Pattern::Identifier {
+                            ident: arena.alloc_str(&format!("#{}", name.value)),
+                        }
+                    },
+                };
 
             let combiner_closure_in_region = |region| {
                 let closure_body = Tuple(Collection::with_items(
@@ -607,15 +633,15 @@ pub fn desugar_expr<'a>(
             };
 
             let closure_args = {
-                if field_names.len() == 2 {
+                if field_data.len() == 2 {
                     arena.alloc_slice_copy(&[
-                        closure_arg_from_field(field_names[0]),
-                        closure_arg_from_field(field_names[1]),
+                        closure_arg_from_field(&field_data[0]),
+                        closure_arg_from_field(&field_data[1]),
                     ])
                 } else {
                     let second_to_last_arg =
-                        closure_arg_from_field(field_names[field_names.len() - 2]);
-                    let last_arg = closure_arg_from_field(field_names[field_names.len() - 1]);
+                        closure_arg_from_field(&field_data[field_data.len() - 2]);
+                    let last_arg = closure_arg_from_field(&field_data[field_data.len() - 1]);
 
                     let mut second_arg = Pattern::Tuple(Collection::with_items(
                         arena.alloc_slice_copy(&[second_to_last_arg, last_arg]),
@@ -623,18 +649,18 @@ pub fn desugar_expr<'a>(
                     let mut second_arg_region =
                         Region::span_across(&second_to_last_arg.region, &last_arg.region);
 
-                    for index in (1..(field_names.len() - 2)).rev() {
+                    for index in (1..(field_data.len() - 2)).rev() {
                         second_arg =
                             Pattern::Tuple(Collection::with_items(arena.alloc_slice_copy(&[
-                                closure_arg_from_field(field_names[index]),
+                                closure_arg_from_field(&field_data[index]),
                                 Loc::at(second_arg_region, second_arg),
                             ])));
                         second_arg_region =
-                            Region::span_across(&field_names[index].region, &second_arg_region);
+                            Region::span_across(&field_data[index].name.region, &second_arg_region);
                     }
 
                     arena.alloc_slice_copy(&[
-                        closure_arg_from_field(field_names[0]),
+                        closure_arg_from_field(&field_data[0]),
                         Loc::at(second_arg_region, second_arg),
                     ])
                 }
@@ -642,22 +668,26 @@ pub fn desugar_expr<'a>(
 
             let record_val = Record(Collection::with_items(
                 Vec::from_iter_in(
-                    field_names.iter().map(|field_name| {
-                        Loc::at(
-                            field_name.region,
-                            AssignedField::RequiredValue(
-                                Loc::at(field_name.region, field_name.value),
-                                &[],
-                                arena.alloc(Loc::at(
-                                    field_name.region,
-                                    Expr::Var {
-                                        module_name: "",
-                                        ident: arena.alloc_str(&format!("#{}", field_name.value)),
-                                    },
-                                )),
-                            ),
-                        )
-                    }),
+                    field_data
+                        .iter()
+                        .filter(|field| !field.ignored)
+                        .map(|field| {
+                            Loc::at(
+                                field.name.region,
+                                AssignedField::RequiredValue(
+                                    field.name,
+                                    &[],
+                                    arena.alloc(Loc::at(
+                                        field.name.region,
+                                        Expr::Var {
+                                            module_name: "",
+                                            ident: arena
+                                                .alloc_str(&format!("#{}", field.name.value)),
+                                        },
+                                    )),
+                                ),
+                            )
+                        }),
                     arena,
                 )
                 .into_bump_slice(),
@@ -671,14 +701,14 @@ pub fn desugar_expr<'a>(
                 ),
             });
 
-            if field_names.len() == 2 {
+            if field_data.len() == 2 {
                 return arena.alloc(Loc {
                     region: loc_expr.region,
                     value: Apply(
                         new_mapper,
                         arena.alloc_slice_copy(&[
-                            field_vals[0],
-                            field_vals[1],
+                            field_data[0].value,
+                            field_data[1].value,
                             record_combiner_closure,
                         ]),
                         CalledVia::RecordBuilder,
@@ -688,27 +718,30 @@ pub fn desugar_expr<'a>(
 
             let mut inner_combined = arena.alloc(Loc {
                 region: Region::span_across(
-                    &field_vals[field_names.len() - 2].region,
-                    &field_vals[field_names.len() - 1].region,
+                    &field_data[field_data.len() - 2].value.region,
+                    &field_data[field_data.len() - 1].value.region,
                 ),
                 value: Apply(
                     new_mapper,
                     arena.alloc_slice_copy(&[
-                        field_vals[field_names.len() - 2],
-                        field_vals[field_names.len() - 1],
+                        field_data[field_data.len() - 2].value,
+                        field_data[field_data.len() - 1].value,
                         combiner_closure_in_region(loc_expr.region),
                     ]),
                     CalledVia::RecordBuilder,
                 ),
             });
 
-            for index in (1..(field_names.len() - 2)).rev() {
+            for index in (1..(field_data.len() - 2)).rev() {
                 inner_combined = arena.alloc(Loc {
-                    region: Region::span_across(&field_vals[index].region, &inner_combined.region),
+                    region: Region::span_across(
+                        &field_data[index].value.region,
+                        &inner_combined.region,
+                    ),
                     value: Apply(
                         new_mapper,
                         arena.alloc_slice_copy(&[
-                            field_vals[index],
+                            field_data[index].value,
                             inner_combined,
                             combiner_closure_in_region(loc_expr.region),
                         ]),
@@ -722,7 +755,7 @@ pub fn desugar_expr<'a>(
                 value: Apply(
                     new_mapper,
                     arena.alloc_slice_copy(&[
-                        field_vals[0],
+                        field_data[0].value,
                         inner_combined,
                         record_combiner_closure,
                     ]),
@@ -1095,6 +1128,14 @@ fn desugar_field<'a>(
             spaces,
             desugar_expr(arena, loc_expr, src, line_info, module_path),
         ),
+        IgnoredValue(loc_str, spaces, loc_expr) => IgnoredValue(
+            Loc {
+                value: loc_str.value,
+                region: loc_str.region,
+            },
+            spaces,
+            desugar_expr(arena, loc_expr, src, line_info, module_path),
+        ),
         LabelOnly(loc_str) => {
             // Desugar { x } into { x: x }
             let loc_expr = Loc {

crates/compiler/can/src/env.rs

@@ -1,7 +1,7 @@
 use std::path::Path;
 
 use crate::procedure::References;
-use crate::scope::Scope;
+use crate::scope::{ModuleLookup, Scope, SymbolLookup};
 use bumpalo::Bump;
 use roc_collections::{MutMap, VecSet};
 use roc_module::ident::{Ident, ModuleName};
@@ -74,7 +74,7 @@ impl<'a> Env<'a> {
         module_name_str: &str,
         ident: &str,
         region: Region,
-    ) -> Result<Symbol, RuntimeError> {
+    ) -> Result<SymbolLookup, RuntimeError> {
         debug_assert!(
             !module_name_str.is_empty(),
             "Called env.qualified_lookup with an unqualified ident: {ident:?}"
@@ -82,8 +82,10 @@ impl<'a> Env<'a> {
 
         let module_name = ModuleName::from(module_name_str);
 
-        match scope.modules.get_id(&module_name) {
-            Some(module_id) => self.qualified_lookup_help(scope, module_id, ident, region),
+        match scope.modules.lookup(&module_name) {
+            Some(lookedup_module) => {
+                self.qualified_lookup_help(scope, lookedup_module, ident, region)
+            }
             None => Err(RuntimeError::ModuleNotImported {
                 module_name: module_name.clone(),
                 imported_modules: scope
@@ -106,11 +108,11 @@ impl<'a> Env<'a> {
         module_id: ModuleId,
         ident: &str,
         region: Region,
-    ) -> Result<Symbol, RuntimeError> {
-        if !scope.modules.has_id(module_id) {
-            Err(self.module_exists_but_not_imported(scope, module_id, region))
+    ) -> Result<SymbolLookup, RuntimeError> {
+        if let Some(module) = scope.modules.lookup_by_id(&module_id) {
+            self.qualified_lookup_help(scope, module, ident, region)
         } else {
-            self.qualified_lookup_help(scope, module_id, ident, region)
+            Err(self.module_exists_but_not_imported(scope, module_id, region))
         }
     }
 
@@ -118,18 +120,18 @@ impl<'a> Env<'a> {
     fn qualified_lookup_help(
         &mut self,
         scope: &Scope,
-        module_id: ModuleId,
+        module: ModuleLookup,
         ident: &str,
         region: Region,
-    ) -> Result<Symbol, RuntimeError> {
+    ) -> Result<SymbolLookup, RuntimeError> {
         let is_type_name = ident.starts_with(|c: char| c.is_uppercase());
 
         // You can do qualified lookups on your own module, e.g.
         // if I'm in the Foo module, I can do a `Foo.bar` lookup.
-        if module_id == self.home {
+        if module.id == self.home {
             match scope.locals.ident_ids.get_id(ident) {
                 Some(ident_id) => {
-                    let symbol = Symbol::new(module_id, ident_id);
+                    let symbol = Symbol::new(module.id, ident_id);
 
                     if is_type_name {
                         self.qualified_type_lookups.insert(symbol);
@@ -137,7 +139,7 @@ impl<'a> Env<'a> {
                         self.qualified_value_lookups.insert(symbol);
                     }
 
-                    Ok(symbol)
+                    Ok(SymbolLookup::no_params(symbol))
                 }
                 None => {
                     let error = RuntimeError::LookupNotInScope {
@@ -157,10 +159,10 @@ impl<'a> Env<'a> {
                 }
             }
         } else {
-            match self.dep_idents.get(&module_id) {
+            match self.dep_idents.get(&module.id) {
                 Some(exposed_ids) => match exposed_ids.get_id(ident) {
                     Some(ident_id) => {
-                        let symbol = Symbol::new(module_id, ident_id);
+                        let symbol = Symbol::new(module.id, ident_id);
 
                         if is_type_name {
                             self.qualified_type_lookups.insert(symbol);
@@ -168,12 +170,12 @@ impl<'a> Env<'a> {
                             self.qualified_value_lookups.insert(symbol);
                         }
 
-                        Ok(symbol)
+                        Ok(module.into_symbol(symbol))
                     }
                     None => Err(RuntimeError::ValueNotExposed {
                         module_name: self
                             .qualified_module_ids
-                            .get_name(module_id)
+                            .get_name(module.id)
                             .expect("Module ID known, but not in the module IDs somehow")
                             .as_inner()
                             .clone(),
@@ -182,7 +184,7 @@ impl<'a> Env<'a> {
                         exposed_values: exposed_ids.exposed_values(),
                     }),
                 },
-                _ => Err(self.module_exists_but_not_imported(scope, module_id, region)),
+                _ => Err(self.module_exists_but_not_imported(scope, module.id, region)),
             }
         }
     }

crates/compiler/can/src/expr.rs

@@ -7,9 +7,10 @@ use crate::num::{
     finish_parsing_base, finish_parsing_float, finish_parsing_num, float_expr_from_result,
     int_expr_from_result, num_expr_from_result, FloatBound, IntBound, NumBound,
 };
+use crate::params_in_abilities_unimplemented;
 use crate::pattern::{canonicalize_pattern, BindingsFromPattern, Pattern, PermitShadows};
 use crate::procedure::{QualifiedReference, References};
-use crate::scope::Scope;
+use crate::scope::{Scope, SymbolLookup};
 use crate::traverse::{walk_expr, Visitor};
 use roc_collections::soa::Index;
 use roc_collections::{SendMap, VecMap, VecSet};
@@ -17,7 +18,7 @@ use roc_error_macros::internal_error;
 use roc_module::called_via::CalledVia;
 use roc_module::ident::{ForeignSymbol, Lowercase, TagName};
 use roc_module::low_level::LowLevel;
-use roc_module::symbol::Symbol;
+use roc_module::symbol::{ModuleId, Symbol};
 use roc_parse::ast::{self, Defs, PrecedenceConflict, StrLiteral};
 use roc_parse::ident::Accessor;
 use roc_parse::pattern::PatternType::*;
@@ -107,6 +108,12 @@ pub enum Expr {
 
     // Lookups
     Var(Symbol, Variable),
+    /// Like Var, but from a module with params
+    ParamsVar {
+        symbol: Symbol,
+        params: Symbol,
+        var: Variable,
+    },
     AbilityMember(
         /// Actual member name
         Symbol,
@@ -177,6 +184,9 @@ pub enum Expr {
         elems: Vec<(Variable, Box<Loc<Expr>>)>,
     },
 
+    /// Module params expression in import
+    ImportParams(ModuleId, Region, Option<(Variable, Box<Expr>)>),
+
     /// The "crash" keyword
     Crash {
         msg: Box<Loc<Expr>>,
@@ -308,6 +318,11 @@ impl Expr {
             Self::SingleQuote(..) => Category::Character,
             Self::List { .. } => Category::List,
             &Self::Var(sym, _) => Category::Lookup(sym),
+            &Self::ParamsVar {
+                symbol,
+                params: _,
+                var: _,
+            } => Category::Lookup(symbol),
             &Self::AbilityMember(sym, _, _) => Category::Lookup(sym),
             Self::When { .. } => Category::When,
             Self::If { .. } => Category::If,
@@ -324,6 +339,8 @@ impl Expr {
             Self::RecordAccessor(data) => Category::Accessor(data.field.clone()),
             Self::TupleAccess { index, .. } => Category::TupleAccess(*index),
             Self::RecordUpdate { .. } => Category::Record,
+            Self::ImportParams(_, _, Some((_, expr))) => expr.category(),
+            Self::ImportParams(_, _, None) => Category::Unknown,
             Self::Tag {
                 name, arguments, ..
             } => Category::TagApply {
@@ -632,33 +649,8 @@ pub fn canonicalize_expr<'a>(
             (answer, Output::default())
         }
         ast::Expr::Record(fields) => {
-            if fields.is_empty() {
-                (EmptyRecord, Output::default())
-            } else {
-                match canonicalize_fields(env, var_store, scope, region, fields.items) {
-                    Ok((can_fields, output)) => (
-                        Record {
-                            record_var: var_store.fresh(),
-                            fields: can_fields,
-                        },
-                        output,
-                    ),
-                    Err(CanonicalizeRecordProblem::InvalidOptionalValue {
-                        field_name,
-                        field_region,
-                        record_region,
-                    }) => (
-                        Expr::RuntimeError(roc_problem::can::RuntimeError::InvalidOptionalValue {
-                            field_name,
-                            field_region,
-                            record_region,
-                        }),
-                        Output::default(),
-                    ),
-                }
-            }
+            canonicalize_record(env, var_store, scope, region, *fields)
         }
-
         ast::Expr::RecordUpdate {
             fields,
             update: loc_update,
@@ -1452,6 +1444,42 @@ pub fn canonicalize_expr<'a>(
     )
 }
 
+pub fn canonicalize_record<'a>(
+    env: &mut Env<'a>,
+    var_store: &mut VarStore,
+    scope: &mut Scope,
+    region: Region,
+    fields: ast::Collection<'a, Loc<ast::AssignedField<'a, ast::Expr<'a>>>>,
+) -> (Expr, Output) {
+    use Expr::*;
+
+    if fields.is_empty() {
+        (EmptyRecord, Output::default())
+    } else {
+        match canonicalize_fields(env, var_store, scope, region, fields.items) {
+            Ok((can_fields, output)) => (
+                Record {
+                    record_var: var_store.fresh(),
+                    fields: can_fields,
+                },
+                output,
+            ),
+            Err(CanonicalizeRecordProblem::InvalidOptionalValue {
+                field_name,
+                field_region,
+                record_region,
+            }) => (
+                Expr::RuntimeError(roc_problem::can::RuntimeError::InvalidOptionalValue {
+                    field_name,
+                    field_region,
+                    record_region,
+                }),
+                Output::default(),
+            ),
+        }
+    }
+}
+
 pub fn canonicalize_closure<'a>(
     env: &mut Env<'a>,
     var_store: &mut VarStore,
@@ -1846,6 +1874,11 @@ fn canonicalize_field<'a>(
             field_region: Region::span_across(&label.region, &loc_expr.region),
         }),
 
+        // An ignored value, e.g. `{ _name: 123 }`
+        IgnoredValue(_, _, _) => {
+            internal_error!("Somehow an IgnoredValue record field was not desugared!");
+        }
+
         // A label with no value, e.g. `{ name }` (this is sugar for { name: name })
         LabelOnly(_) => {
             internal_error!("Somehow a LabelOnly record field was not desugared!");
@@ -1876,19 +1909,19 @@ fn canonicalize_var_lookup(
         // Since module_name was empty, this is an unqualified var.
         // Look it up in scope!
         match scope.lookup_str(ident, region) {
-            Ok(symbol) => {
+            Ok(lookup) => {
                 output
                     .references
-                    .insert_value_lookup(symbol, QualifiedReference::Unqualified);
+                    .insert_value_lookup(lookup.symbol, QualifiedReference::Unqualified);
 
-                if scope.abilities_store.is_ability_member_name(symbol) {
+                if scope.abilities_store.is_ability_member_name(lookup.symbol) {
                     AbilityMember(
-                        symbol,
+                        params_in_abilities_unimplemented!(lookup),
                         Some(scope.abilities_store.fresh_specialization_id()),
                         var_store.fresh(),
                     )
                 } else {
-                    Var(symbol, var_store.fresh())
+                    lookup_to_expr(lookup, var_store.fresh())
                 }
             }
             Err(problem) => {
@@ -1901,19 +1934,19 @@ fn canonicalize_var_lookup(
         // Since module_name was nonempty, this is a qualified var.
         // Look it up in the env!
         match env.qualified_lookup(scope, module_name, ident, region) {
-            Ok(symbol) => {
+            Ok(lookup) => {
                 output
                     .references
-                    .insert_value_lookup(symbol, QualifiedReference::Qualified);
+                    .insert_value_lookup(lookup.symbol, QualifiedReference::Qualified);
 
-                if scope.abilities_store.is_ability_member_name(symbol) {
+                if scope.abilities_store.is_ability_member_name(lookup.symbol) {
                     AbilityMember(
-                        symbol,
+                        params_in_abilities_unimplemented!(lookup),
                         Some(scope.abilities_store.fresh_specialization_id()),
                         var_store.fresh(),
                     )
                 } else {
-                    Var(symbol, var_store.fresh())
+                    lookup_to_expr(lookup, var_store.fresh())
                 }
             }
             Err(problem) => {
@@ -1931,6 +1964,24 @@ fn canonicalize_var_lookup(
     (can_expr, output)
 }
 
+fn lookup_to_expr(
+    SymbolLookup {
+        symbol,
+        module_params: params,
+    }: SymbolLookup,
+    var: Variable,
+) -> Expr {
+    if let Some(params) = params {
+        Expr::ParamsVar {
+            symbol,
+            params,
+            var,
+        }
+    } else {
+        Expr::Var(symbol, var)
+    }
+}
+
 /// Currently uses the heuristic of "only inline if it's a builtin"
 pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr {
     use Expr::*;
@@ -1949,6 +2000,7 @@ pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr {
         | other @ RecordAccessor { .. }
         | other @ RecordUpdate { .. }
         | other @ Var(..)
+        | other @ ParamsVar { .. }
         | other @ AbilityMember(..)
         | other @ RunLowLevel { .. }
         | other @ TypedHole { .. }
@@ -2212,6 +2264,14 @@ pub fn inline_calls(var_store: &mut VarStore, expr: Expr) -> Expr {
             );
         }
 
+        ImportParams(module_id, region, Some((var, expr))) => ImportParams(
+            module_id,
+            region,
+            Some((var, Box::new(inline_calls(var_store, *expr)))),
+        ),
+
+        ImportParams(module_id, region, None) => ImportParams(module_id, region, None),
+
         RecordAccess {
             record_var,
             ext_var,
@@ -2433,7 +2493,8 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
         }
         ast::Expr::Record(fields) => fields.iter().all(|loc_field| match loc_field.value {
             ast::AssignedField::RequiredValue(_label, loc_comments, loc_val)
-            | ast::AssignedField::OptionalValue(_label, loc_comments, loc_val) => {
+            | ast::AssignedField::OptionalValue(_label, loc_comments, loc_val)
+            | ast::AssignedField::IgnoredValue(_label, loc_comments, loc_val) => {
                 loc_comments.is_empty() && is_valid_interpolation(&loc_val.value)
             }
             ast::AssignedField::Malformed(_) | ast::AssignedField::LabelOnly(_) => true,
@@ -2481,7 +2542,8 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
             is_valid_interpolation(&update.value)
                 && fields.iter().all(|loc_field| match loc_field.value {
                     ast::AssignedField::RequiredValue(_label, loc_comments, loc_val)
-                    | ast::AssignedField::OptionalValue(_label, loc_comments, loc_val) => {
+                    | ast::AssignedField::OptionalValue(_label, loc_comments, loc_val)
+                    | ast::AssignedField::IgnoredValue(_label, loc_comments, loc_val) => {
                         loc_comments.is_empty() && is_valid_interpolation(&loc_val.value)
                     }
                     ast::AssignedField::Malformed(_) | ast::AssignedField::LabelOnly(_) => true,
@@ -2514,7 +2576,8 @@ pub fn is_valid_interpolation(expr: &ast::Expr<'_>) -> bool {
             is_valid_interpolation(&mapper.value)
                 && fields.iter().all(|loc_field| match loc_field.value {
                     ast::AssignedField::RequiredValue(_label, loc_comments, loc_val)
-                    | ast::AssignedField::OptionalValue(_label, loc_comments, loc_val) => {
+                    | ast::AssignedField::OptionalValue(_label, loc_comments, loc_val)
+                    | ast::AssignedField::IgnoredValue(_label, loc_comments, loc_val) => {
                         loc_comments.is_empty() && is_valid_interpolation(&loc_val.value)
                     }
                     ast::AssignedField::Malformed(_) | ast::AssignedField::LabelOnly(_) => true,
@@ -3133,6 +3196,11 @@ pub(crate) fn get_lookup_symbols(expr: &Expr) -> Vec<ExpectLookup> {
     while let Some(expr) = stack.pop() {
         match expr {
             Expr::Var(symbol, var)
+            | Expr::ParamsVar {
+                symbol,
+                params: _,
+                var,
+            }
             | Expr::RecordUpdate {
                 symbol,
                 record_var: var,
@@ -3237,6 +3305,9 @@ pub(crate) fn get_lookup_symbols(expr: &Expr) -> Vec<ExpectLookup> {
             Expr::Tuple { elems, .. } => {
                 stack.extend(elems.iter().map(|(_, elem)| &elem.value));
             }
+            Expr::ImportParams(_, _, Some((_, expr))) => {
+                stack.push(expr);
+            }
             Expr::Expect {
                 loc_continuation, ..
             }
@@ -3263,6 +3334,7 @@ pub(crate) fn get_lookup_symbols(expr: &Expr) -> Vec<ExpectLookup> {
             | Expr::EmptyRecord
             | Expr::TypedHole(_)
             | Expr::RuntimeError(_)
+            | Expr::ImportParams(_, _, None)
             | Expr::OpaqueWrapFunction(_) => {}
         }
     }

crates/compiler/can/src/module.rs

@@ -6,9 +6,11 @@ use crate::def::{canonicalize_defs, report_unused_imports, Def};
 use crate::effect_module::HostedGeneratedFunctions;
 use crate::env::Env;
 use crate::expr::{
-    ClosureData, DbgLookup, Declarations, ExpectLookup, Expr, Output, PendingDerives,
+    AnnotatedMark, ClosureData, DbgLookup, Declarations, ExpectLookup, Expr, Output, PendingDerives,
+};
+use crate::pattern::{
+    canonicalize_record_destructure, BindingsFromPattern, Pattern, PermitShadows,
 };
-use crate::pattern::{BindingsFromPattern, Pattern};
 use crate::procedure::References;
 use crate::scope::Scope;
 use bumpalo::Bump;
@@ -18,7 +20,7 @@ use roc_module::ident::Ident;
 use roc_module::ident::Lowercase;
 use roc_module::symbol::{IdentIds, IdentIdsByModule, ModuleId, PackageModuleIds, Symbol};
 use roc_parse::ast::{Defs, TypeAnnotation};
-use roc_parse::header::HeaderType;
+use roc_parse::header::{HeaderType, ModuleParams};
 use roc_parse::pattern::PatternType;
 use roc_problem::can::{Problem, RuntimeError};
 use roc_region::all::{Loc, Region};
@@ -136,6 +138,7 @@ pub struct Module {
     pub abilities_store: PendingAbilitiesStore,
     pub loc_expects: VecMap<Region, Vec<ExpectLookup>>,
     pub loc_dbgs: VecMap<Symbol, DbgLookup>,
+    pub params_pattern: Option<(Variable, AnnotatedMark, Loc<Pattern>)>,
 }
 
 #[derive(Debug, Default)]
@@ -149,6 +152,7 @@ pub struct RigidVariables {
 pub struct ModuleOutput {
     pub aliases: MutMap<Symbol, Alias>,
     pub rigid_variables: RigidVariables,
+    pub params_pattern: Option<(Variable, AnnotatedMark, Loc<Pattern>)>,
     pub declarations: Declarations,
     pub exposed_imports: MutMap<Symbol, Region>,
     pub exposed_symbols: VecSet<Symbol>,
@@ -244,6 +248,7 @@ impl GeneratedInfo {
                 generates_with,
                 name: _,
                 exposes: _,
+                opt_params: _,
             } => {
                 debug_assert!(generates_with.is_empty());
                 GeneratedInfo::Builtin
@@ -274,7 +279,7 @@ fn has_no_implementation(expr: &Expr) -> bool {
 pub fn canonicalize_module_defs<'a>(
     arena: &'a Bump,
     loc_defs: &'a mut Defs<'a>,
-    header_type: &roc_parse::header::HeaderType,
+    header_type: &'a roc_parse::header::HeaderType,
     home: ModuleId,
     module_path: &'a str,
     src: &'a str,
@@ -290,6 +295,7 @@ pub fn canonicalize_module_defs<'a>(
     opt_shorthand: Option<&'a str>,
 ) -> ModuleOutput {
     let mut can_exposed_imports = MutMap::default();
+
     let mut scope = Scope::new(
         home,
         qualified_module_ids
@@ -382,9 +388,42 @@ pub fn canonicalize_module_defs<'a>(
         }
     }
 
+    let mut output = Output::default();
+
+    let params_pattern = header_type.get_params().as_ref().map(
+        |ModuleParams {
+             pattern,
+             before_arrow: _,
+             after_arrow: _,
+         }| {
+            let can_pattern = canonicalize_record_destructure(
+                &mut env,
+                var_store,
+                &mut scope,
+                &mut output,
+                PatternType::ModuleParams,
+                &pattern.value,
+                pattern.region,
+                PermitShadows(false),
+            );
+
+            let loc_pattern = Loc::at(pattern.region, can_pattern);
+
+            for (symbol, _) in BindingsFromPattern::new(&loc_pattern) {
+                env.top_level_symbols.insert(symbol);
+            }
+
+            (
+                var_store.fresh(),
+                AnnotatedMark::new(var_store),
+                loc_pattern,
+            )
+        },
+    );
+
     let (defs, output, symbols_introduced, imports_introduced) = canonicalize_defs(
         &mut env,
-        Output::default(),
+        output,
         var_store,
         &mut scope,
         loc_defs,
@@ -812,6 +851,7 @@ pub fn canonicalize_module_defs<'a>(
         scope,
         aliases,
         rigid_variables,
+        params_pattern,
         declarations,
         referenced_values,
         exposed_imports: can_exposed_imports,
@@ -1105,6 +1145,7 @@ fn fix_values_captured_in_closure_expr(
         | SingleQuote(..)
         | IngestedFile(..)
         | Var(..)
+        | ParamsVar { .. }
         | AbilityMember(..)
         | EmptyRecord
         | TypedHole { .. }
@@ -1216,6 +1257,12 @@ fn fix_values_captured_in_closure_expr(
             }
         }
 
+        ImportParams(_, _, Some((_, expr))) => {
+            fix_values_captured_in_closure_expr(expr, no_capture_symbols, closure_captures);
+        }
+
+        ImportParams(_, _, None) => {}
+
         Tuple { elems, .. } => {
             for (_var, expr) in elems.iter_mut() {
                 fix_values_captured_in_closure_expr(

crates/compiler/can/src/pattern.rs

@@ -623,132 +623,16 @@ pub fn canonicalize_pattern<'a>(
             }
         }
 
-        RecordDestructure(patterns) => {
-            let ext_var = var_store.fresh();
-            let whole_var = var_store.fresh();
-            let mut destructs = Vec::with_capacity(patterns.len());
-            let mut opt_erroneous = None;
-
-            for loc_pattern in patterns.iter() {
-                match loc_pattern.value {
-                    Identifier { ident: label } => {
-                        match scope.introduce(label.into(), region) {
-                            Ok(symbol) => {
-                                output.references.insert_bound(symbol);
-
-                                destructs.push(Loc {
-                                    region: loc_pattern.region,
-                                    value: RecordDestruct {
-                                        var: var_store.fresh(),
-                                        label: Lowercase::from(label),
-                                        symbol,
-                                        typ: DestructType::Required,
-                                    },
-                                });
-                            }
-                            Err((shadowed_symbol, shadow, new_symbol)) => {
-                                env.problem(Problem::RuntimeError(RuntimeError::Shadowing {
-                                    original_region: shadowed_symbol.region,
-                                    shadow: shadow.clone(),
-                                    kind: ShadowKind::Variable,
-                                }));
-
-                                // No matter what the other patterns
-                                // are, we're definitely shadowed and will
-                                // get a runtime exception as soon as we
-                                // encounter the first bad pattern.
-                                opt_erroneous = Some(Pattern::Shadowed(
-                                    shadowed_symbol.region,
-                                    shadow,
-                                    new_symbol,
-                                ));
-                            }
-                        };
-                    }
-
-                    RequiredField(label, loc_guard) => {
-                        // a guard does not introduce the label into scope!
-                        let symbol =
-                            scope.scopeless_symbol(&Ident::from(label), loc_pattern.region);
-                        let can_guard = canonicalize_pattern(
-                            env,
-                            var_store,
-                            scope,
-                            output,
-                            pattern_type,
-                            &loc_guard.value,
-                            loc_guard.region,
-                            permit_shadows,
-                        );
-
-                        destructs.push(Loc {
-                            region: loc_pattern.region,
-                            value: RecordDestruct {
-                                var: var_store.fresh(),
-                                label: Lowercase::from(label),
-                                symbol,
-                                typ: DestructType::Guard(var_store.fresh(), can_guard),
-                            },
-                        });
-                    }
-                    OptionalField(label, loc_default) => {
-                        // an optional DOES introduce the label into scope!
-                        match scope.introduce(label.into(), region) {
-                            Ok(symbol) => {
-                                let (can_default, expr_output) = canonicalize_expr(
-                                    env,
-                                    var_store,
-                                    scope,
-                                    loc_default.region,
-                                    &loc_default.value,
-                                );
-
-                                // an optional field binds the symbol!
-                                output.references.insert_bound(symbol);
-
-                                output.union(expr_output);
-
-                                destructs.push(Loc {
-                                    region: loc_pattern.region,
-                                    value: RecordDestruct {
-                                        var: var_store.fresh(),
-                                        label: Lowercase::from(label),
-                                        symbol,
-                                        typ: DestructType::Optional(var_store.fresh(), can_default),
-                                    },
-                                });
-                            }
-                            Err((shadowed_symbol, shadow, new_symbol)) => {
-                                env.problem(Problem::RuntimeError(RuntimeError::Shadowing {
-                                    original_region: shadowed_symbol.region,
-                                    shadow: shadow.clone(),
-                                    kind: ShadowKind::Variable,
-                                }));
-
-                                // No matter what the other patterns
-                                // are, we're definitely shadowed and will
-                                // get a runtime exception as soon as we
-                                // encounter the first bad pattern.
-                                opt_erroneous = Some(Pattern::Shadowed(
-                                    shadowed_symbol.region,
-                                    shadow,
-                                    new_symbol,
-                                ));
-                            }
-                        };
-                    }
-                    _ => unreachable!("Any other pattern should have given a parse error"),
-                }
-            }
-
-            // If we encountered an erroneous pattern (e.g. one with shadowing),
-            // use the resulting RuntimeError. Otherwise, return a successful record destructure.
-            opt_erroneous.unwrap_or(Pattern::RecordDestructure {
-                whole_var,
-                ext_var,
-                destructs,
-            })
-        }
+        RecordDestructure(patterns) => canonicalize_record_destructure(
+            env,
+            var_store,
+            scope,
+            output,
+            pattern_type,
+            patterns,
+            region,
+            permit_shadows,
+        ),
 
         RequiredField(_name, _loc_pattern) => {
             unreachable!("should have been handled in RecordDestructure");
@@ -894,6 +778,144 @@ pub fn canonicalize_pattern<'a>(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
+pub fn canonicalize_record_destructure<'a>(
+    env: &mut Env<'a>,
+    var_store: &mut VarStore,
+    scope: &mut Scope,
+    output: &mut Output,
+    pattern_type: PatternType,
+    patterns: &ast::Collection<Loc<ast::Pattern<'a>>>,
+    region: Region,
+    permit_shadows: PermitShadows,
+) -> Pattern {
+    use ast::Pattern::*;
+
+    let ext_var = var_store.fresh();
+    let whole_var = var_store.fresh();
+    let mut destructs = Vec::with_capacity(patterns.len());
+    let mut opt_erroneous = None;
+
+    for loc_pattern in patterns.iter() {
+        match loc_pattern.value {
+            Identifier { ident: label } => {
+                match scope.introduce(label.into(), region) {
+                    Ok(symbol) => {
+                        output.references.insert_bound(symbol);
+
+                        destructs.push(Loc {
+                            region: loc_pattern.region,
+                            value: RecordDestruct {
+                                var: var_store.fresh(),
+                                label: Lowercase::from(label),
+                                symbol,
+                                typ: DestructType::Required,
+                            },
+                        });
+                    }
+                    Err((shadowed_symbol, shadow, new_symbol)) => {
+                        env.problem(Problem::RuntimeError(RuntimeError::Shadowing {
+                            original_region: shadowed_symbol.region,
+                            shadow: shadow.clone(),
+                            kind: ShadowKind::Variable,
+                        }));
+
+                        // No matter what the other patterns
+                        // are, we're definitely shadowed and will
+                        // get a runtime exception as soon as we
+                        // encounter the first bad pattern.
+                        opt_erroneous = Some(Pattern::Shadowed(
+                            shadowed_symbol.region,
+                            shadow,
+                            new_symbol,
+                        ));
+                    }
+                };
+            }
+
+            RequiredField(label, loc_guard) => {
+                // a guard does not introduce the label into scope!
+                let symbol = scope.scopeless_symbol(&Ident::from(label), loc_pattern.region);
+                let can_guard = canonicalize_pattern(
+                    env,
+                    var_store,
+                    scope,
+                    output,
+                    pattern_type,
+                    &loc_guard.value,
+                    loc_guard.region,
+                    permit_shadows,
+                );
+
+                destructs.push(Loc {
+                    region: loc_pattern.region,
+                    value: RecordDestruct {
+                        var: var_store.fresh(),
+                        label: Lowercase::from(label),
+                        symbol,
+                        typ: DestructType::Guard(var_store.fresh(), can_guard),
+                    },
+                });
+            }
+            OptionalField(label, loc_default) => {
+                // an optional DOES introduce the label into scope!
+                match scope.introduce(label.into(), region) {
+                    Ok(symbol) => {
+                        let (can_default, expr_output) = canonicalize_expr(
+                            env,
+                            var_store,
+                            scope,
+                            loc_default.region,
+                            &loc_default.value,
+                        );
+
+                        // an optional field binds the symbol!
+                        output.references.insert_bound(symbol);
+
+                        output.union(expr_output);
+
+                        destructs.push(Loc {
+                            region: loc_pattern.region,
+                            value: RecordDestruct {
+                                var: var_store.fresh(),
+                                label: Lowercase::from(label),
+                                symbol,
+                                typ: DestructType::Optional(var_store.fresh(), can_default),
+                            },
+                        });
+                    }
+                    Err((shadowed_symbol, shadow, new_symbol)) => {
+                        env.problem(Problem::RuntimeError(RuntimeError::Shadowing {
+                            original_region: shadowed_symbol.region,
+                            shadow: shadow.clone(),
+                            kind: ShadowKind::Variable,
+                        }));
+
+                        // No matter what the other patterns
+                        // are, we're definitely shadowed and will
+                        // get a runtime exception as soon as we
+                        // encounter the first bad pattern.
+                        opt_erroneous = Some(Pattern::Shadowed(
+                            shadowed_symbol.region,
+                            shadow,
+                            new_symbol,
+                        ));
+                    }
+                };
+            }
+            _ => unreachable!("Any other pattern should have given a parse error"),
+        }
+    }
+
+    // If we encountered an erroneous pattern (e.g. one with shadowing),
+    // use the resulting RuntimeError. Otherwise, return a successful record destructure.
+    opt_erroneous.unwrap_or(Pattern::RecordDestructure {
+        whole_var,
+        ext_var,
+        destructs,
+    })
+}
+
 /// When we detect an unsupported pattern type (e.g. 5 = 1 + 2 is unsupported because you can't
 /// assign to Int patterns), report it to Env and return an UnsupportedPattern runtime error pattern.
 fn unsupported_pattern(env: &mut Env, pattern_type: PatternType, region: Region) -> Pattern {

crates/compiler/can/src/scope.rs

@@ -1,8 +1,8 @@
 use roc_collections::{VecMap, VecSet};
 use roc_error_macros::internal_error;
 use roc_module::ident::{Ident, ModuleName};
-use roc_module::symbol::{IdentId, IdentIds, ModuleId, ScopeModules, Symbol};
-use roc_problem::can::RuntimeError;
+use roc_module::symbol::{IdentId, IdentIds, ModuleId, ModuleIds, Symbol};
+use roc_problem::can::{RuntimeError, ScopeModuleSource};
 use roc_region::all::{Loc, Region};
 use roc_types::subs::Variable;
 use roc_types::types::{Alias, AliasKind, AliasVar, Type};
@@ -76,7 +76,7 @@ impl Scope {
         }
     }
 
-    pub fn lookup(&self, ident: &Ident, region: Region) -> Result<Symbol, RuntimeError> {
+    pub fn lookup(&self, ident: &Ident, region: Region) -> Result<SymbolLookup, RuntimeError> {
         self.lookup_str(ident.as_str(), region)
     }
 
@@ -91,7 +91,7 @@ impl Scope {
             .push(("Set".into(), Symbol::SET_SET, Region::zero()));
     }
 
-    pub fn lookup_str(&self, ident: &str, region: Region) -> Result<Symbol, RuntimeError> {
+    pub fn lookup_str(&self, ident: &str, region: Region) -> Result<SymbolLookup, RuntimeError> {
         use ContainsIdent::*;
 
         match self.scope_contains_ident(ident) {
@@ -205,14 +205,19 @@ impl Scope {
         }
     }
 
-    fn has_imported_symbol(&self, ident: &str) -> Option<(Symbol, Region)> {
-        for (import, shadow, original_region) in self.imported_symbols.iter() {
-            if ident == import.as_str() {
-                return Some((*shadow, *original_region));
-            }
-        }
-
-        None
+    fn has_imported_symbol(&self, ident: &str) -> Option<(SymbolLookup, Region)> {
+        self.imported_symbols
+            .iter()
+            .find_map(|(import, symbol, original_region)| {
+                if ident == import.as_str() {
+                    match self.modules.lookup_by_id(&symbol.module_id()) {
+                        Some(module) => Some((module.into_symbol(*symbol), *original_region)),
+                        None => Some((SymbolLookup::no_params(*symbol), *original_region)),
+                    }
+                } else {
+                    None
+                }
+            })
     }
 
     /// Is an identifier in scope, either in the locals or imports
@@ -229,7 +234,7 @@ impl Scope {
             ContainsIdent::InScope(original_symbol, original_region) => {
                 // the ident is already in scope; up to the caller how to handle that
                 // (usually it's shadowing, but it is valid to shadow ability members)
-                Err((original_symbol, original_region))
+                Err((original_symbol.symbol, original_region))
             }
             ContainsIdent::NotPresent => {
                 // We know nothing about this ident yet; introduce it to the scope
@@ -389,7 +394,13 @@ impl Scope {
         region: Region,
     ) -> Result<(), (Symbol, Region)> {
         match self.scope_contains_ident(ident.as_str()) {
-            ContainsIdent::InScope(symbol, region) => Err((symbol, region)),
+            ContainsIdent::InScope(
+                SymbolLookup {
+                    symbol,
+                    module_params: _,
+                },
+                region,
+            ) => Err((symbol, region)),
             ContainsIdent::NotPresent | ContainsIdent::NotInScope(_) => {
                 self.imported_symbols.push((ident, symbol, region));
                 Ok(())
@@ -534,7 +545,7 @@ pub fn create_alias(
 
 #[derive(Debug)]
 enum ContainsIdent {
-    InScope(Symbol, Region),
+    InScope(SymbolLookup, Region),
     NotInScope(IdentId),
     NotPresent,
 }
@@ -561,7 +572,7 @@ impl ScopedIdentIds {
 
     fn has_in_scope(&self, ident: &Ident) -> Option<(Symbol, Region)> {
         match self.contains_ident(ident.as_str()) {
-            ContainsIdent::InScope(symbol, region) => Some((symbol, region)),
+            ContainsIdent::InScope(symbol, region) => Some((symbol.symbol, region)),
             ContainsIdent::NotInScope(_) | ContainsIdent::NotPresent => None,
         }
     }
@@ -574,7 +585,10 @@ impl ScopedIdentIds {
         for ident_id in self.ident_ids.get_id_many(ident) {
             let index = ident_id.index();
             if self.in_scope[index] {
-                return InScope(Symbol::new(self.home, ident_id), self.regions[index]);
+                return InScope(
+                    SymbolLookup::no_params(Symbol::new(self.home, ident_id)),
+                    self.regions[index],
+                );
             } else {
                 result = NotInScope(ident_id)
             }
@@ -646,6 +660,149 @@ impl ScopedIdentIds {
     }
 }
 
+#[derive(Debug, Clone)]
+pub struct ScopeModules {
+    /// The ids of all modules in scope
+    ids: Vec<ModuleId>,
+    /// The alias or original name of each module in scope
+    names: Vec<ModuleName>,
+    /// Why is this module in scope?
+    sources: Vec<ScopeModuleSource>,
+    /// The params of a module if any
+    params: Vec<Option<Symbol>>,
+}
+
+impl ScopeModules {
+    pub fn new(home_id: ModuleId, home_name: ModuleName) -> Self {
+        let builtins = ModuleIds::default();
+        let builtins_iter = builtins.iter();
+        let count = builtins_iter.len();
+
+        let mut ids = Vec::with_capacity(count + 1);
+        let mut names = Vec::with_capacity(count + 1);
+        let mut sources = vec![ScopeModuleSource::Builtin; count];
+        let mut params = vec![None; count];
+
+        for (module_id, module_name) in builtins_iter {
+            ids.push(module_id);
+            names.push(module_name.clone());
+        }
+
+        if !home_id.is_builtin() {
+            ids.push(home_id);
+            names.push(home_name);
+            sources.push(ScopeModuleSource::Current);
+            params.push(None);
+        }
+
+        Self {
+            ids,
+            names,
+            sources,
+            params,
+        }
+    }
+
+    pub fn lookup(&self, module_name: &ModuleName) -> Option<ModuleLookup> {
+        self.names
+            .iter()
+            .position(|name| name == module_name)
+            .map(|index| ModuleLookup {
+                id: self.ids[index],
+                params: self.params[index],
+            })
+    }
+
+    pub fn lookup_by_id(&self, module_id: &ModuleId) -> Option<ModuleLookup> {
+        self.ids
+            .iter()
+            .position(|id| id == module_id)
+            .map(|index| ModuleLookup {
+                id: self.ids[index],
+                params: self.params[index],
+            })
+    }
+
+    pub fn available_names(&self) -> impl Iterator<Item = &ModuleName> {
+        self.names.iter()
+    }
+
+    pub fn insert(
+        &mut self,
+        module_name: ModuleName,
+        module_id: ModuleId,
+        params_symbol: Option<Symbol>,
+        region: Region,
+    ) -> Result<(), ScopeModuleSource> {
+        if let Some(index) = self.names.iter().position(|name| name == &module_name) {
+            if self.ids[index] == module_id {
+                return Ok(());
+            }
+
+            return Err(self.sources[index]);
+        }
+
+        self.ids.push(module_id);
+        self.names.push(module_name);
+        self.sources.push(ScopeModuleSource::Import(region));
+        self.params.push(params_symbol);
+        Ok(())
+    }
+
+    pub fn len(&self) -> usize {
+        debug_assert_eq!(self.ids.len(), self.names.len());
+        debug_assert_eq!(self.ids.len(), self.sources.len());
+        debug_assert_eq!(self.ids.len(), self.params.len());
+        self.ids.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.ids.is_empty()
+    }
+
+    pub fn truncate(&mut self, len: usize) {
+        self.ids.truncate(len);
+        self.names.truncate(len);
+        self.sources.truncate(len);
+        self.params.truncate(len);
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SymbolLookup {
+    pub symbol: Symbol,
+    pub module_params: Option<Symbol>,
+}
+
+impl SymbolLookup {
+    pub fn new(symbol: Symbol, params: Option<Symbol>) -> Self {
+        Self {
+            symbol,
+            module_params: params,
+        }
+    }
+
+    pub fn no_params(symbol: Symbol) -> Self {
+        Self::new(symbol, None)
+    }
+}
+
+pub struct ModuleLookup {
+    pub id: ModuleId,
+    pub params: Option<Symbol>,
+}
+
+impl ModuleLookup {
+    pub fn into_symbol(&self, symbol: Symbol) -> SymbolLookup {
+        debug_assert_eq!(symbol.module_id(), self.id);
+
+        SymbolLookup {
+            symbol,
+            module_params: self.params,
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use super::*;
@@ -701,7 +858,7 @@ mod test {
 
         let lookup = scope.lookup(&ident, Region::zero()).unwrap();
 
-        assert_eq!(first, lookup);
+        assert_eq!(first, lookup.symbol);
     }
 
     #[test]
@@ -857,6 +1014,6 @@ mod test {
 
         let lookup = scope.lookup(&ident, Region::zero()).unwrap();
 
-        assert_eq!(symbol, lookup);
+        assert_eq!(symbol, lookup.symbol);
     }
 }

crates/compiler/can/src/traverse.rs

@@ -266,6 +266,7 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expr: &Expr, var: Variable) {
             walk_list(visitor, *elem_var, loc_elems);
         }
         Expr::Var(..) => { /* terminal */ }
+        Expr::ParamsVar { .. } => { /* terminal */ }
         Expr::AbilityMember(..) => { /* terminal */ }
         Expr::If {
             cond_var,
@@ -317,6 +318,8 @@ pub fn walk_expr<V: Visitor>(visitor: &mut V, expr: &Expr, var: Variable) {
             .iter()
             .for_each(|(var, elem)| visitor.visit_expr(&elem.value, elem.region, *var)),
         Expr::EmptyRecord => { /* terminal */ }
+        Expr::ImportParams(_, region, Some((_, expr))) => visitor.visit_expr(expr, *region, var),
+        Expr::ImportParams(_, _, None) => { /* terminal */ }
         Expr::RecordAccess {
             field_var,
             loc_expr,

crates/compiler/constrain/src/expr.rs

@@ -566,7 +566,12 @@ pub fn constrain_expr(
 
             constraints.exists([*ret_var], and)
         }
-        Var(symbol, variable) => {
+        Var(symbol, variable)
+        | ParamsVar {
+            symbol,
+            params: _,
+            var: variable,
+        } => {
             // Save the expectation in the variable, then lookup the symbol's type in the environment
             let expected_type = *constraints[expected].get_type_ref();
             let store_expected = constraints.store(expected_type, *variable, file!(), line!());
@@ -575,6 +580,22 @@ pub fn constrain_expr(
 
             constraints.and_constraint([store_expected, lookup_constr])
         }
+        ImportParams(module_id, region, Some((var, params))) => {
+            let index = constraints.push_variable(*var);
+            let expected_params = constraints.push_expected_type(Expected::ForReason(
+                Reason::ImportParams(*module_id),
+                index,
+                *region,
+            ));
+            let expr_con =
+                constrain_expr(types, constraints, env, *region, params, expected_params);
+            let params_con = constraints.import_params(Some(index), *module_id, *region);
+            let expr_and_params = constraints.and_constraint([expr_con, params_con]);
+            constraints.exists([*var], expr_and_params)
+        }
+        ImportParams(module_id, region, None) => {
+            constraints.import_params(None, *module_id, *region)
+        }
         &AbilityMember(symbol, specialization_id, specialization_var) => {
             // Save the expectation in the `specialization_var` so we know what to specialize, then
             // lookup the member in the environment.
@@ -4089,6 +4110,8 @@ fn is_generalizable_expr(mut expr: &Expr) -> bool {
                 return true;
             }
             OpaqueRef { argument, .. } => expr = &argument.1.value,
+            ImportParams(_, _, Some((_, params))) => expr = params,
+            ImportParams(_, _, None) => return false,
             Str(_)
             | IngestedFile(..)
             | List { .. }
@@ -4115,7 +4138,8 @@ fn is_generalizable_expr(mut expr: &Expr) -> bool {
             | ZeroArgumentTag { .. }
             | Tag { .. }
             | AbilityMember(..)
-            | Var(..) => return false,
+            | Var(..)
+            | ParamsVar { .. } => return false,
         }
     }
 }

crates/compiler/constrain/src/module.rs

@@ -1,11 +1,15 @@
 use crate::expr::{constrain_def_make_constraint, constrain_def_pattern, Env};
+use crate::pattern::{constrain_pattern, PatternState};
 use roc_can::abilities::{PendingAbilitiesStore, PendingMemberType};
 use roc_can::constraint::{Constraint, Constraints, Generalizable};
-use roc_can::expected::Expected;
-use roc_can::expr::Declarations;
+use roc_can::expected::{Expected, PExpected};
+use roc_can::expr::{AnnotatedMark, Declarations};
 use roc_can::pattern::Pattern;
+use roc_collections::MutMap;
+use roc_error_macros::internal_error;
 use roc_module::symbol::{ModuleId, Symbol};
 use roc_region::all::{Loc, Region};
+use roc_types::subs::Variable;
 use roc_types::types::{AnnotationSource, Category, Type, Types};
 
 pub fn constrain_module(
@@ -14,9 +18,18 @@ pub fn constrain_module(
     symbols_from_requires: Vec<(Loc<Symbol>, Loc<Type>)>,
     abilities_store: &PendingAbilitiesStore,
     declarations: &Declarations,
+    params_pattern: &Option<(Variable, AnnotatedMark, Loc<Pattern>)>,
     home: ModuleId,
 ) -> Constraint {
     let constraint = crate::expr::constrain_decls(types, constraints, home, declarations);
+
+    let constraint = match params_pattern {
+        Some(params_pattern) => {
+            constrain_params(types, constraints, home, constraint, params_pattern)
+        }
+        None => constraint,
+    };
+
     let constraint = constrain_symbols_from_requires(
         types,
         constraints,
@@ -33,6 +46,63 @@ pub fn constrain_module(
     constraint
 }
 
+fn constrain_params(
+    types: &mut Types,
+    constraints: &mut Constraints,
+    home: ModuleId,
+    constraint: Constraint,
+    (pattern_var, _, loc_pattern): &(Variable, AnnotatedMark, Loc<Pattern>),
+) -> Constraint {
+    let mut env = Env {
+        home,
+        rigids: MutMap::default(),
+        resolutions_to_make: vec![],
+    };
+
+    let index = constraints.push_variable(*pattern_var);
+    let expected_params = constraints.push_pat_expected_type(PExpected::NoExpectation(index));
+
+    let mut state = PatternState::default();
+
+    let closed_con = match loc_pattern.value {
+        Pattern::RecordDestructure {
+            whole_var: _,
+            ext_var,
+            destructs: _,
+        } => {
+            // Disallow record extension for module params
+            let empty_rec = constraints.push_type(types, Types::EMPTY_RECORD);
+            constraints.store(empty_rec, ext_var, file!(), line!())
+        }
+        _ => internal_error!("Only record destructures are allowed in module params. This should've been caught earlier."),
+    };
+
+    state.constraints.push(closed_con);
+
+    constrain_pattern(
+        types,
+        constraints,
+        &mut env,
+        &loc_pattern.value,
+        loc_pattern.region,
+        expected_params,
+        &mut state,
+    );
+
+    let pattern_constraints = constraints.and_constraint(state.constraints);
+
+    let cons = constraints.let_constraint(
+        [],
+        state.vars,
+        state.headers,
+        pattern_constraints,
+        constraint,
+        Generalizable(true),
+    );
+
+    constraints.exists([*pattern_var], cons)
+}
+
 fn constrain_symbols_from_requires(
     types: &mut Types,
     constraints: &mut Constraints,

crates/compiler/fmt/src/annotation.rs

@@ -428,9 +428,9 @@ fn is_multiline_assigned_field_help<T: Formattable>(afield: &AssignedField<'_, T
     use self::AssignedField::*;
 
     match afield {
-        RequiredValue(_, spaces, ann) | OptionalValue(_, spaces, ann) => {
-            !spaces.is_empty() || ann.value.is_multiline()
-        }
+        RequiredValue(_, spaces, ann)
+        | OptionalValue(_, spaces, ann)
+        | IgnoredValue(_, spaces, ann) => !spaces.is_empty() || ann.value.is_multiline(),
         LabelOnly(_) => false,
         AssignedField::SpaceBefore(_, _) | AssignedField::SpaceAfter(_, _) => true,
         Malformed(text) => text.chars().any(|c| c == '\n'),
@@ -483,6 +483,24 @@ fn format_assigned_field_help<T>(
             buf.spaces(1);
             ann.value.format(buf, indent);
         }
+        IgnoredValue(name, spaces, ann) => {
+            if is_multiline {
+                buf.newline();
+            }
+
+            buf.indent(indent);
+            buf.push('_');
+            buf.push_str(name.value);
+
+            if !spaces.is_empty() {
+                fmt_spaces(buf, spaces.iter(), indent);
+            }
+
+            buf.spaces(separator_spaces);
+            buf.push(':');
+            buf.spaces(1);
+            ann.value.format(buf, indent);
+        }
         LabelOnly(name) => {
             if is_multiline {
                 buf.newline();

crates/compiler/fmt/src/def.rs

@@ -252,14 +252,14 @@ impl<'a> Formattable for ModuleImportParams<'a> {
     fn is_multiline(&self) -> bool {
         let ModuleImportParams { before, params } = self;
 
-        !before.is_empty() || is_collection_multiline(params)
+        !before.is_empty() || is_collection_multiline(&params.value)
     }
 
     fn format_with_options(&self, buf: &mut Buf, _parens: Parens, newlines: Newlines, indent: u16) {
         let ModuleImportParams { before, params } = self;
 
         fmt_default_spaces(buf, before, indent);
-        fmt_collection(buf, indent, Braces::Curly, *params, newlines);
+        fmt_collection(buf, indent, Braces::Curly, params.value, newlines);
     }
 }
 

crates/compiler/fmt/src/expr.rs

@@ -1529,6 +1529,23 @@ fn format_assigned_field_multiline<T>(
             ann.value.format(buf, indent);
             buf.push(',');
         }
+        IgnoredValue(name, spaces, ann) => {
+            buf.newline();
+            buf.indent(indent);
+            buf.push('_');
+            buf.push_str(name.value);
+
+            if !spaces.is_empty() {
+                fmt_spaces(buf, spaces.iter(), indent);
+                buf.indent(indent);
+            }
+
+            buf.push_str(separator_prefix);
+            buf.push_str(":");
+            buf.spaces(1);
+            ann.value.format(buf, indent);
+            buf.push(',');
+        }
         LabelOnly(name) => {
             buf.newline();
             buf.indent(indent);

crates/compiler/fmt/src/header.rs

@@ -5,7 +5,7 @@ use crate::collection::{fmt_collection, Braces};
 use crate::expr::fmt_str_literal;
 use crate::spaces::{fmt_comments_only, fmt_default_spaces, fmt_spaces, NewlineAt, INDENT};
 use crate::Buf;
-use roc_parse::ast::{Collection, CommentOrNewline, Header, Module, Spaced, Spaces};
+use roc_parse::ast::{Collection, CommentOrNewline, Header, Spaced, Spaces, SpacesBefore};
 use roc_parse::header::{
     AppHeader, ExposedName, ExposesKeyword, GeneratesKeyword, HostedHeader, ImportsEntry,
     ImportsKeyword, Keyword, KeywordItem, ModuleHeader, ModuleName, PackageEntry, PackageHeader,
@@ -16,9 +16,9 @@ use roc_parse::header::{
 use roc_parse::ident::UppercaseIdent;
 use roc_region::all::Loc;
 
-pub fn fmt_module<'a>(buf: &mut Buf<'_>, module: &'a Module<'a>) {
-    fmt_comments_only(buf, module.comments.iter(), NewlineAt::Bottom, 0);
-    match &module.header {
+pub fn fmt_header<'a>(buf: &mut Buf<'_>, header: &'a SpacesBefore<'a, Header<'a>>) {
+    fmt_comments_only(buf, header.before.iter(), NewlineAt::Bottom, 0);
+    match &header.item {
         Header::Module(header) => {
             fmt_module_header(buf, header);
         }
@@ -174,11 +174,17 @@ pub fn fmt_module_header<'a>(buf: &mut Buf, header: &'a ModuleHeader<'a>) {
     let mut indent = fmt_spaces_with_outdent(buf, header.after_keyword, 0);
 
     if let Some(params) = &header.params {
-        if is_collection_multiline(&params.params) {
+        if is_collection_multiline(&params.pattern.value) {
             indent = INDENT;
         }
 
-        fmt_collection(buf, indent, Braces::Curly, params.params, Newlines::Yes);
+        fmt_collection(
+            buf,
+            indent,
+            Braces::Curly,
+            params.pattern.value,
+            Newlines::Yes,
+        );
 
         indent = fmt_spaces_with_outdent(buf, params.before_arrow, indent);
         buf.push_str("->");

crates/compiler/fmt/src/lib.rs

@@ -6,18 +6,11 @@ pub mod annotation;
 pub mod collection;
 pub mod def;
 pub mod expr;
-pub mod module;
+pub mod header;
 pub mod pattern;
 pub mod spaces;
 
 use bumpalo::{collections::String, Bump};
-use roc_parse::ast::Module;
-
-#[derive(Debug)]
-pub struct Ast<'a> {
-    pub module: Module<'a>,
-    pub defs: roc_parse::ast::Defs<'a>,
-}
 
 #[derive(Debug)]
 pub struct Buf<'a> {

crates/compiler/fmt/src/spaces.rs

@@ -1,7 +1,6 @@
-use bumpalo::Bump;
-use roc_parse::{ast::CommentOrNewline, remove_spaces::RemoveSpaces};
+use roc_parse::ast::CommentOrNewline;
 
-use crate::{Ast, Buf};
+use crate::Buf;
 
 /// The number of spaces to indent.
 pub const INDENT: u16 = 4;
@@ -192,12 +191,3 @@ fn fmt_docs(buf: &mut Buf, docs: &str) {
     }
     buf.push_str(docs.trim_end());
 }
-
-impl<'a> RemoveSpaces<'a> for Ast<'a> {
-    fn remove_spaces(&self, arena: &'a Bump) -> Self {
-        Ast {
-            module: self.module.remove_spaces(arena),
-            defs: self.defs.remove_spaces(arena),
-        }
-    }
-}

crates/compiler/load/tests/helpers/mod.rs

@@ -51,6 +51,8 @@ pub fn infer_expr(
         exposed_by_module: &Default::default(),
         derived_module,
         function_kind: FunctionKind::LambdaSet,
+        params_pattern: None,
+        module_params_vars: Default::default(),
         #[cfg(debug_assertions)]
         checkmate: None,
     };

crates/compiler/load/tests/test_reporting.rs

@@ -16,7 +16,7 @@ mod test_reporting {
     use roc_load::{self, ExecutionMode, LoadConfig, LoadedModule, LoadingProblem, Threading};
     use roc_module::symbol::{Interns, ModuleId};
     use roc_packaging::cache::RocCacheDir;
-    use roc_parse::module::parse_header;
+    use roc_parse::header::parse_header;
     use roc_parse::state::State;
     use roc_parse::test_helpers::parse_expr_with;
     use roc_problem::Severity;
@@ -359,7 +359,7 @@ mod test_reporting {
         let src_lines: Vec<&str> = src.split('\n').collect();
         let lines = LineInfo::new(src);
 
-        match roc_parse::module::parse_header(arena, state) {
+        match roc_parse::header::parse_header(arena, state) {
             Err(fail) => {
                 let interns = Interns::default();
                 let home = crate::helpers::test_home();
@@ -10875,12 +10875,12 @@ All branches in an `if` must have the same type!
         ),
         @r#"
     ── EMPTY RECORD BUILDER in /code/proj/Main.roc ─────────────────────────────────
-    
+
     This record builder has no fields:
-    
+
     4│      { a <- }
             ^^^^^^^^
-    
+
     I need at least two fields to combine their values into a record.
     "#
     );
@@ -10898,11 +10898,11 @@ All branches in an `if` must have the same type!
     ── NOT ENOUGH FIELDS IN RECORD BUILDER in /code/proj/Main.roc ──────────────────
 
     This record builder only has one field:
-    
+
     4│>      { a <-
     5│>          b: 123
     6│>      }
-    
+
     I need at least two fields to combine their values into a record.
     "#
     );
@@ -10919,14 +10919,14 @@ All branches in an `if` must have the same type!
         ),
         @r#"
     ── OPTIONAL FIELD IN RECORD BUILDER in /code/proj/Main.roc ─────────────────────
-    
+
     Optional fields are not allowed to be used in record builders.
-    
+
     4│       { a <-
     5│           b: 123,
     6│>          c? 456
     7│       }
-    
+
     Record builders can only have required values for their fields.
     "#
     );

crates/compiler/load_internal/src/docs.rs

@@ -465,7 +465,8 @@ fn contains_unexposed_type(
             while let Some(field) = fields_to_process.pop() {
                 match field {
                     AssignedField::RequiredValue(_field, _spaces, loc_val)
-                    | AssignedField::OptionalValue(_field, _spaces, loc_val) => {
+                    | AssignedField::OptionalValue(_field, _spaces, loc_val)
+                    | AssignedField::IgnoredValue(_field, _spaces, loc_val) => {
                         if contains_unexposed_type(&loc_val.value, exposed_module_ids, module_ids) {
                             return true;
                         }
@@ -721,7 +722,7 @@ fn record_field_to_doc(
         AssignedField::LabelOnly(label) => Some(RecordField::LabelOnly {
             name: label.value.to_string(),
         }),
-        AssignedField::Malformed(_) => None,
+        AssignedField::Malformed(_) | AssignedField::IgnoredValue(_, _, _) => None,
     }
 }
 

crates/compiler/load_internal/src/file.rs

@@ -48,11 +48,11 @@ use roc_mono::reset_reuse;
 use roc_mono::{drop_specialization, inc_dec};
 use roc_packaging::cache::RocCacheDir;
 use roc_parse::ast::{self, CommentOrNewline, ExtractSpaces, Spaced, ValueDef};
+use roc_parse::header::parse_module_defs;
 use roc_parse::header::{
     self, AppHeader, ExposedName, HeaderType, ImportsKeywordItem, PackageEntry, PackageHeader,
     PlatformHeader, To, TypedIdent,
 };
-use roc_parse::module::parse_module_defs;
 use roc_parse::parser::{FileError, SourceError, SyntaxError};
 use roc_problem::Severity;
 use roc_region::all::{LineInfo, Loc, Region};
@@ -1327,8 +1327,8 @@ fn load_packages_from_main<'a>(
 
     let parse_state = roc_parse::state::State::new(arena.alloc(src_bytes));
 
-    let (parsed_module, _) =
-        roc_parse::module::parse_header(arena, parse_state.clone()).map_err(|fail| {
+    let (parsed_header, _) =
+        roc_parse::header::parse_header(arena, parse_state.clone()).map_err(|fail| {
             LoadingProblem::ParsingFailed(
                 fail.map_problem(SyntaxError::Header)
                     .into_file_error(filename.clone()),
@@ -1337,7 +1337,7 @@ fn load_packages_from_main<'a>(
 
     use ast::Header::*;
 
-    let packages = match parsed_module.header {
+    let packages = match parsed_header.item {
         App(AppHeader { packages, .. }) | Package(PackageHeader { packages, .. }) => {
             unspace(arena, packages.value.items)
         }
@@ -2395,6 +2395,13 @@ fn update<'a>(
                 .pending_abilities
                 .insert(module_id, constrained_module.module.abilities_store.clone());
 
+            if let Some(params_pattern) = constrained_module.module.params_pattern.clone() {
+                state
+                    .module_cache
+                    .param_patterns
+                    .insert(module_id, params_pattern);
+            }
+
             state
                 .module_cache
                 .constrained
@@ -3349,7 +3356,7 @@ fn load_package_from_disk<'a>(
             let parse_start = Instant::now();
             let bytes = arena.alloc(bytes_vec);
             let parse_state = roc_parse::state::State::new(bytes);
-            let parsed = roc_parse::module::parse_header(arena, parse_state.clone());
+            let parsed = roc_parse::header::parse_header(arena, parse_state.clone());
             let parse_header_duration = parse_start.elapsed();
 
             // Insert the first entries for this module's timings
@@ -3360,8 +3367,8 @@ fn load_package_from_disk<'a>(
 
             match parsed {
                 Ok((
-                    ast::Module {
-                        header: ast::Header::Module(header),
+                    ast::SpacesBefore {
+                        item: ast::Header::Module(header),
                         ..
                     },
                     _parse_state,
@@ -3369,8 +3376,8 @@ fn load_package_from_disk<'a>(
                     "expected platform/package module, got Module with header\n{header:?}"
                 ))),
                 Ok((
-                    ast::Module {
-                        header: ast::Header::Hosted(header),
+                    ast::SpacesBefore {
+                        item: ast::Header::Hosted(header),
                         ..
                     },
                     _parse_state,
@@ -3378,8 +3385,8 @@ fn load_package_from_disk<'a>(
                     "expected platform/package module, got Hosted module with header\n{header:?}"
                 ))),
                 Ok((
-                    ast::Module {
-                        header: ast::Header::App(header),
+                    ast::SpacesBefore {
+                        item: ast::Header::App(header),
                         ..
                     },
                     _parse_state,
@@ -3387,9 +3394,9 @@ fn load_package_from_disk<'a>(
                     "expected platform/package module, got App with header\n{header:?}"
                 ))),
                 Ok((
-                    ast::Module {
-                        header: ast::Header::Package(header),
-                        comments,
+                    ast::SpacesBefore {
+                        item: ast::Header::Package(header),
+                        before: comments,
                     },
                     parser_state,
                 )) => {
@@ -3430,9 +3437,9 @@ fn load_package_from_disk<'a>(
                     Ok(Msg::Many(messages))
                 }
                 Ok((
-                    ast::Module {
-                        header: ast::Header::Platform(header),
-                        comments,
+                    ast::SpacesBefore {
+                        item: ast::Header::Platform(header),
+                        before: comments,
                     },
                     parser_state,
                 )) => {
@@ -3530,13 +3537,13 @@ fn load_builtin_module_help<'a>(
     let opt_shorthand = None;
     let filename = PathBuf::from(filename);
     let parse_state = roc_parse::state::State::new(src_bytes.as_bytes());
-    let parsed = roc_parse::module::parse_header(arena, parse_state.clone());
+    let parsed = roc_parse::header::parse_header(arena, parse_state.clone());
 
     match parsed {
         Ok((
-            ast::Module {
-                header: ast::Header::Module(header),
-                comments,
+            ast::SpacesBefore {
+                item: ast::Header::Module(header),
+                before: comments,
             },
             parse_state,
         )) => {
@@ -3551,6 +3558,7 @@ fn load_builtin_module_help<'a>(
                     name: header::ModuleName::new(name_stem),
                     exposes: unspace(arena, header.exposes.items),
                     generates_with: &[],
+                    opt_params: header.params,
                 },
                 module_comments: comments,
                 header_imports: header.interface_imports,
@@ -3786,7 +3794,7 @@ fn parse_header<'a>(
 ) -> Result<HeaderOutput<'a>, LoadingProblem<'a>> {
     let parse_start = Instant::now();
     let parse_state = roc_parse::state::State::new(src_bytes);
-    let parsed = roc_parse::module::parse_header(arena, parse_state.clone());
+    let parsed = roc_parse::header::parse_header(arena, parse_state.clone());
     let parse_header_duration = parse_start.elapsed();
 
     if let Err(problem) = ensure_roc_file(&filename, src_bytes) {
@@ -3815,9 +3823,9 @@ fn parse_header<'a>(
 
     match parsed {
         Ok((
-            ast::Module {
-                header: ast::Header::Module(header),
-                comments,
+            ast::SpacesBefore {
+                item: ast::Header::Module(header),
+                before: comments,
             },
             parse_state,
         )) => {
@@ -3837,6 +3845,7 @@ fn parse_header<'a>(
                 header_type: HeaderType::Module {
                     name: roc_parse::header::ModuleName::new(module_name),
                     exposes: unspace(arena, header.exposes.items),
+                    opt_params: header.params,
                 },
                 module_comments: comments,
                 header_imports: header.interface_imports,
@@ -3852,9 +3861,9 @@ fn parse_header<'a>(
             })
         }
         Ok((
-            ast::Module {
-                header: ast::Header::Hosted(header),
-                comments,
+            ast::SpacesBefore {
+                item: ast::Header::Hosted(header),
+                before: comments,
             },
             parse_state,
         )) => {
@@ -3883,9 +3892,9 @@ fn parse_header<'a>(
             })
         }
         Ok((
-            ast::Module {
-                header: ast::Header::App(header),
-                comments,
+            ast::SpacesBefore {
+                item: ast::Header::App(header),
+                before: comments,
             },
             parse_state,
         )) => {
@@ -3988,9 +3997,9 @@ fn parse_header<'a>(
             })
         }
         Ok((
-            ast::Module {
-                header: ast::Header::Package(header),
-                comments,
+            ast::SpacesBefore {
+                item: ast::Header::Package(header),
+                before: comments,
             },
             parse_state,
         )) => {
@@ -4015,9 +4024,9 @@ fn parse_header<'a>(
         }
 
         Ok((
-            ast::Module {
-                header: ast::Header::Platform(header),
-                comments,
+            ast::SpacesBefore {
+                item: ast::Header::Platform(header),
+                before: comments,
             },
             parse_state,
         )) => {
@@ -4380,7 +4389,7 @@ pub fn add_imports(
     def_types: &mut Vec<(Symbol, Loc<TypeOrVar>)>,
     imported_rigid_vars: &mut Vec<Variable>,
     imported_flex_vars: &mut Vec<Variable>,
-) -> (Vec<Variable>, AbilitiesStore) {
+) -> (Vec<Variable>, VecMap<ModuleId, Variable>, AbilitiesStore) {
     let mut import_variables = Vec::new();
 
     let mut cached_symbol_vars = VecMap::default();
@@ -4487,7 +4496,31 @@ pub fn add_imports(
         },
     );
 
-    (import_variables, abilities_store)
+    let mut imported_param_vars = VecMap::default();
+
+    for (module_id, _) in exposed_for_module.exposed_by_module.iter_all() {
+        let ExposedModuleTypes {
+            exposed_types_storage_subs: exposed_types,
+            ..
+        } = exposed_for_module.exposed_by_module.get(module_id).unwrap();
+
+        if let Some(stored_aprams_var) = exposed_types.stored_params_var {
+            let copied_import = exposed_types
+                .storage_subs
+                .export_variable_to(subs, stored_aprams_var);
+
+            let copied_import_var = extend_imports_data_with_copied_import(
+                copied_import,
+                &mut import_variables,
+                imported_rigid_vars,
+                imported_flex_vars,
+            );
+
+            imported_param_vars.insert(*module_id, copied_import_var);
+        }
+    }
+
+    (import_variables, imported_param_vars, abilities_store)
 }
 
 enum OnSymbolNotFound {
@@ -4609,6 +4642,7 @@ fn run_solve_solve(
         aliases,
         rigid_variables,
         abilities_store: pending_abilities,
+        params_pattern,
         ..
     } = module;
 
@@ -4618,7 +4652,7 @@ fn run_solve_solve(
 
     let mut subs = Subs::new_from_varstore(var_store);
 
-    let (import_variables, abilities_store) = add_imports(
+    let (import_variables, imported_param_vars, abilities_store) = add_imports(
         module.module_id,
         &mut constraints,
         &mut subs,
@@ -4656,6 +4690,8 @@ fn run_solve_solve(
             derived_module,
             #[cfg(debug_assertions)]
             checkmate,
+            params_pattern: params_pattern.map(|(_, _, pattern)| pattern.value),
+            module_params_vars: imported_param_vars,
         };
 
         let solve_output = roc_solve::module::run_solve(
@@ -4740,6 +4776,11 @@ fn run_solve<'a>(
     // TODO remove when we write builtins in roc
     let aliases = module.aliases.clone();
 
+    let opt_params_var = module
+        .params_pattern
+        .as_ref()
+        .map(|(params_var, _, _)| *params_var);
+
     let mut module = module;
     let loc_expects = std::mem::take(&mut module.loc_expects);
     let loc_dbgs = std::mem::take(&mut module.loc_dbgs);
@@ -4811,6 +4852,7 @@ fn run_solve<'a>(
         module_id,
         &mut solved_subs,
         &exposed_vars_by_symbol,
+        opt_params_var,
         &solved_implementations,
         &abilities_store,
     );
@@ -4922,6 +4964,7 @@ fn build_platform_header<'a>(
             .zip(requires.iter().copied()),
         arena,
     );
+    let packages = unspace(arena, header.packages.item.items);
     let exposes = bumpalo::collections::Vec::from_iter_in(
         unspace(arena, header.exposes.item.items).iter().copied(),
         arena,
@@ -4943,7 +4986,7 @@ fn build_platform_header<'a>(
         filename,
         is_root_module,
         opt_shorthand,
-        packages: &[],
+        packages,
         header_type,
         module_comments: comments,
         header_imports: Some(header.imports),
@@ -5059,6 +5102,7 @@ fn canonicalize_and_constrain<'a>(
             module_output.symbols_from_requires,
             &module_output.scope.abilities_store,
             &module_output.declarations,
+            &module_output.params_pattern,
             module_id,
         )
     };
@@ -5115,6 +5159,7 @@ fn canonicalize_and_constrain<'a>(
         abilities_store: module_output.scope.abilities_store,
         loc_expects: module_output.loc_expects,
         loc_dbgs: module_output.loc_dbgs,
+        params_pattern: module_output.params_pattern,
     };
 
     let constrained_module = ConstrainedModule {
@@ -5152,7 +5197,7 @@ fn parse<'a>(
     let parse_state = header.parse_state;
 
     let header_import_defs =
-        roc_parse::ast::Module::header_imports_to_defs(arena, header.header_imports);
+        roc_parse::ast::Header::header_imports_to_defs(arena, header.header_imports);
 
     let parsed_defs = match parse_module_defs(arena, parse_state.clone(), header_import_defs) {
         Ok(success) => success,
@@ -5458,6 +5503,7 @@ fn make_specializations<'a>(
 ) -> Msg<'a> {
     let make_specializations_start = Instant::now();
     let mut update_mode_ids = UpdateModeIds::new();
+
     // do the thing
     let mut mono_env = roc_mono::ir::Env {
         arena,

crates/compiler/load_internal/src/module_cache.rs

@@ -4,12 +4,13 @@ use crate::module::{
     ModuleHeader, ParsedModule, TypeCheckedModule,
 };
 use roc_can::abilities::PendingAbilitiesStore;
+use roc_can::expr::AnnotatedMark;
 use roc_collections::{MutMap, MutSet, VecMap};
 use roc_module::ident::ModuleName;
 use roc_module::symbol::{ModuleId, PQModuleName, Symbol};
 use roc_mono::ir::ExternalSpecializations;
 use roc_problem::Severity;
-use roc_region::all::Region;
+use roc_region::all::{Loc, Region};
 use roc_solve_problem::TypeError;
 use roc_types::subs::Variable;
 use roc_types::types::Alias;
@@ -26,6 +27,8 @@ pub(crate) struct ModuleCache<'a> {
     pub(crate) aliases: MutMap<ModuleId, MutMap<Symbol, (bool, Alias)>>,
     pub(crate) pending_abilities: MutMap<ModuleId, PendingAbilitiesStore>,
     pub(crate) constrained: MutMap<ModuleId, ConstrainedModule>,
+    pub(crate) param_patterns:
+        MutMap<ModuleId, (Variable, AnnotatedMark, Loc<roc_can::pattern::Pattern>)>,
     pub(crate) typechecked: MutMap<ModuleId, TypeCheckedModule<'a>>,
     pub(crate) checked: MutMap<ModuleId, CheckedModule>,
     pub(crate) found_specializations: MutMap<ModuleId, FoundSpecializationsModule<'a>>,
@@ -100,6 +103,7 @@ impl Default for ModuleCache<'_> {
             aliases: Default::default(),
             pending_abilities: Default::default(),
             constrained: Default::default(),
+            param_patterns: Default::default(),
             typechecked: Default::default(),
             checked: Default::default(),
             found_specializations: Default::default(),

crates/compiler/load_internal/tests/test_load.rs

@@ -27,10 +27,11 @@ use roc_module::symbol::{Interns, ModuleId};
 use roc_packaging::cache::RocCacheDir;
 use roc_problem::can::Problem;
 use roc_region::all::LineInfo;
-use roc_reporting::report::RocDocAllocator;
 use roc_reporting::report::{can_problem, DEFAULT_PALETTE};
 use roc_reporting::report::{strip_colors, RenderTarget};
+use roc_reporting::report::{type_problem, RocDocAllocator};
 use roc_solve::FunctionKind;
+use roc_solve_problem::TypeError;
 use roc_target::Target;
 use roc_test_utils_dir::TmpDir;
 use roc_types::pretty_print::name_and_print_var;
@@ -107,6 +108,33 @@ fn format_can_problems(
     buf
 }
 
+fn format_type_problems(
+    problems: Vec<TypeError>,
+    home: ModuleId,
+    interns: &Interns,
+    filename: PathBuf,
+    src: &str,
+) -> String {
+    use ven_pretty::DocAllocator;
+
+    let src_lines: Vec<&str> = src.split('\n').collect();
+    let lines = LineInfo::new(src);
+    let alloc = RocDocAllocator::new(&src_lines, home, interns);
+    let reports = problems
+        .into_iter()
+        .flat_map(|problem| type_problem(&alloc, &lines, filename.clone(), problem))
+        .map(|report| report.pretty(&alloc));
+
+    let mut buf = String::new();
+    alloc
+        .stack(reports)
+        .append(alloc.line())
+        .1
+        .render_raw(70, &mut roc_reporting::report::CiWrite::new(&mut buf))
+        .unwrap();
+    buf
+}
+
 fn multiple_modules(subdir: &str, files: Vec<(&str, &str)>) -> Result<LoadedModule, String> {
     let arena = Bump::new();
     let arena = &arena;
@@ -130,11 +158,19 @@ fn multiple_modules(subdir: &str, files: Vec<(&str, &str)>) -> Result<LoadedModu
                 ));
             }
 
-            assert!(loaded_module
+            let type_problems = loaded_module
                 .type_problems
                 .remove(&home)
-                .unwrap_or_default()
-                .is_empty(),);
+                .unwrap_or_default();
+            if !type_problems.is_empty() {
+                return Err(format_type_problems(
+                    type_problems,
+                    home,
+                    &loaded_module.interns,
+                    filepath.clone(),
+                    src,
+                ));
+            }
 
             Ok(loaded_module)
         }
@@ -279,6 +315,13 @@ fn expect_types(mut loaded_module: LoadedModule, mut expected_types: HashMap<&st
 
         match declarations.declarations[index] {
             Value | Function(_) | Recursive(_) | TailRecursive(_) => {
+                let body = declarations.expressions[index].clone();
+
+                if let roc_can::expr::Expr::ImportParams(_, _, None) = body.value {
+                    // Skip import defs without params
+                    continue;
+                }
+
                 let symbol = declarations.symbols[index].value;
                 let expr_var = declarations.variables[index];
 
@@ -407,7 +450,13 @@ fn module_with_deps() {
 
         match declarations.declarations[index] {
             Value | Function(_) | Recursive(_) | TailRecursive(_) => {
-                def_count += 1;
+                let body = declarations.expressions[index].clone();
+
+                if let roc_can::expr::Expr::ImportParams(_, _, None) = body.value {
+                    // Skip import defs without params
+                } else {
+                    def_count += 1;
+                }
             }
             Destructure(_) => {
                 def_count += 1;
@@ -1563,6 +1612,325 @@ fn cannot_use_original_name_if_imported_with_alias() {
     multiple_modules("cannot_use_original_name_if_imported_with_alias", modules).unwrap_err();
 }
 
+#[test]
+fn module_params_checks() {
+    let modules = vec![
+        (
+            "Api.roc",
+            indoc!(
+                r#"
+            module { key } -> [url]
+
+            url = "example.com/$(key)"
+            "#
+            ),
+        ),
+        (
+            "Main.roc",
+            indoc!(
+                r#"
+        module [example]
+
+        import Api { key: "abcdef" }
+
+        example = Api.url
+            "#
+            ),
+        ),
+    ];
+
+    let result = multiple_modules("module_params_checks", modules);
+    assert!(result.is_ok());
+}
+
+#[test]
+fn module_params_optional() {
+    let modules = vec![
+        (
+            "Api.roc",
+            indoc!(
+                r#"
+            module { key, exp ? "default" } -> [url]
+
+            url = "example.com/$(key)?exp=$(exp)"
+            "#
+            ),
+        ),
+        (
+            "Main.roc",
+            indoc!(
+                r#"
+        module [example]
+
+        import Api { key: "abcdef" }
+
+        example = Api.url
+            "#
+            ),
+        ),
+    ];
+
+    let result = multiple_modules("module_params_optional", modules);
+    assert!(result.is_ok())
+}
+
+#[test]
+fn module_params_typecheck_fail() {
+    let modules = vec![
+        (
+            "Api.roc",
+            indoc!(
+                r#"
+            module { key } -> [url]
+
+            url = "example.com/$(key)"
+            "#
+            ),
+        ),
+        (
+            "Main.roc",
+            indoc!(
+                r#"
+        module [example]
+
+        import Api { key: 123 }
+
+        example = Api.url
+            "#
+            ),
+        ),
+    ];
+
+    let result = multiple_modules("module_params_typecheck_fail", modules).unwrap_err();
+    assert_eq!(
+        result,
+        indoc!(
+            r#"
+            ── MODULE PARAMS MISMATCH in tmp/module_params_typecheck_fail/Main.roc ─────────
+
+            Something is off with the params provided by this import:
+
+            3│  import Api { key: 123 }
+                           ^^^^^^^^^^^^
+
+            This is the type I inferred:
+
+                { key : Num * }
+
+            However, Api expects:
+
+                { key : Str }
+            "#
+        )
+    );
+}
+
+#[test]
+fn module_params_missing_fields() {
+    let modules = vec![
+        (
+            "Api.roc",
+            indoc!(
+                r#"
+            module { key } -> [url]
+
+            url = "example.com/$(key)"
+            "#
+            ),
+        ),
+        (
+            "Main.roc",
+            indoc!(
+                r#"
+        module [example]
+
+        import Api {}
+
+        example = Api.url
+            "#
+            ),
+        ),
+    ];
+
+    let result = multiple_modules("module_params_missing_fields", modules).unwrap_err();
+    assert_eq!(
+        result,
+        indoc!(
+            r#"
+            ── MODULE PARAMS MISMATCH in tmp/module_params_missing_fields/Main.roc ─────────
+
+            Something is off with the params provided by this import:
+
+            3│  import Api {}
+                           ^^
+
+            This is the type I inferred:
+
+                {}
+
+            However, Api expects:
+
+                { key : Str }
+
+            Tip: Looks like the key field is missing.
+            "#
+        )
+    );
+}
+
+#[test]
+fn module_params_extra_fields() {
+    let modules = vec![
+        (
+            "Api.roc",
+            indoc!(
+                r#"
+            module { key } -> [url]
+
+            url = "example.com/$(key)"
+            "#
+            ),
+        ),
+        (
+            "Main.roc",
+            indoc!(
+                r#"
+        module [example]
+
+        import Api { key: "123", doesNotExist: Bool.true }
+
+        example = Api.url
+            "#
+            ),
+        ),
+    ];
+
+    let result = multiple_modules("module_params_extra_fields", modules).unwrap_err();
+    assert_eq!(
+        result,
+        indoc!(
+            r#"
+            ── MODULE PARAMS MISMATCH in tmp/module_params_extra_fields/Main.roc ───────────
+
+            Something is off with the params provided by this import:
+
+            3│  import Api { key: "123", doesNotExist: Bool.true }
+                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+            This is the type I inferred:
+
+                { doesNotExist : Bool, … }
+
+            However, Api expects:
+
+                { … }
+
+
+            "#
+        )
+    );
+}
+
+#[test]
+fn module_params_unexpected() {
+    let modules = vec![
+        (
+            "Api.roc",
+            indoc!(
+                r#"
+            module [url]
+
+            url = "example.com"
+            "#
+            ),
+        ),
+        (
+            "Main.roc",
+            indoc!(
+                r#"
+        module [example]
+
+        import Api { key: 123 }
+
+        example = Api.url
+            "#
+            ),
+        ),
+    ];
+
+    let err = multiple_modules("module_params_unexpected", modules).unwrap_err();
+    assert_eq!(
+        err,
+        indoc!(
+            r#"
+            ── UNEXPECTED MODULE PARAMS in tmp/module_params_unexpected/Main.roc ───────────
+
+            This import specifies module params:
+
+            3│  import Api { key: 123 }
+                           ^^^^^^^^^^^^
+
+            However, Api does not expect any. Did you intend to import a different
+            module?
+            "#
+        )
+    )
+}
+
+#[test]
+fn module_params_missing() {
+    let modules = vec![
+        (
+            "Api.roc",
+            indoc!(
+                r#"
+            module { key, exp } -> [url]
+
+            url = "example.com/$(key)?exp=$(Num.toStr exp)"
+            "#
+            ),
+        ),
+        (
+            "Main.roc",
+            indoc!(
+                r#"
+        module [example]
+
+        import Api
+
+        example = Api.url
+            "#
+            ),
+        ),
+    ];
+
+    let err = multiple_modules("module_params_missing", modules).unwrap_err();
+    assert_eq!(
+        err,
+        indoc!(
+            r#"
+            ── MISSING MODULE PARAMS in tmp/module_params_missing/Main.roc ─────────────────
+
+            This import specifies no module params:
+
+            3│  import Api
+                ^^^^^^^^^^
+
+            However, Api expects the following to be provided:
+
+                {
+                    exp : Num *,
+                    key : Str,
+                }
+
+            You can provide params after the module name, like:
+
+                import Menu { echo, read }
+            "#
+        )
+    )
+}
+
 #[test]
 fn issue_2863_module_type_does_not_exist() {
     let modules = vec![

crates/compiler/module/src/symbol.rs

@@ -627,67 +627,12 @@ impl ModuleIds {
     pub fn available_modules(&self) -> impl Iterator<Item = &ModuleName> {
         self.by_id.iter()
     }
-}
 
-#[derive(Debug, Clone)]
-pub struct ScopeModules {
-    modules: VecMap<ModuleName, ModuleId>,
-    sources: VecMap<ModuleId, ScopeModuleSource>,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ScopeModuleSource {
-    Builtin,
-    Current,
-    Import(Region),
-}
-
-impl ScopeModules {
-    pub fn get_id(&self, module_name: &ModuleName) -> Option<ModuleId> {
-        self.modules.get(module_name).copied()
-    }
-
-    pub fn has_id(&self, module_id: ModuleId) -> bool {
-        self.sources.contains_key(&module_id)
-    }
-
-    pub fn available_names(&self) -> impl Iterator<Item = &ModuleName> {
-        self.modules.keys()
-    }
-
-    pub fn insert(
-        &mut self,
-        module_name: ModuleName,
-        module_id: ModuleId,
-        region: Region,
-    ) -> Result<(), ScopeModuleSource> {
-        if let Some(existing_module_id) = self.modules.get(&module_name) {
-            if *existing_module_id == module_id {
-                return Ok(());
-            }
-
-            return Err(*self.sources.get(existing_module_id).unwrap());
-        }
-
-        self.modules.insert(module_name, module_id);
-        self.sources
-            .insert(module_id, ScopeModuleSource::Import(region));
-        Ok(())
-    }
-
-    pub fn len(&self) -> usize {
-        debug_assert_eq!(self.modules.len(), self.sources.len());
-        self.modules.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        debug_assert_eq!(self.modules.is_empty(), self.sources.is_empty());
-        self.modules.is_empty()
-    }
-
-    pub fn truncate(&mut self, len: usize) {
-        self.modules.truncate(len);
-        self.sources.truncate(len);
+    pub fn iter(&self) -> impl ExactSizeIterator<Item = (ModuleId, &ModuleName)> {
+        self.by_id
+            .iter()
+            .enumerate()
+            .map(|(index, name)| (ModuleId::from_zero_indexed(index), name))
     }
 }
 
@@ -1031,32 +976,6 @@ macro_rules! define_builtins {
             }
         }
 
-        impl ScopeModules {
-            pub fn new(home_id: ModuleId, home_name: ModuleName) -> Self {
-                // +1 because the user will be compiling at least 1 non-builtin module!
-                let capacity = $total + 1;
-
-                let mut modules = VecMap::with_capacity(capacity);
-                let mut sources = VecMap::with_capacity(capacity);
-
-                modules.insert(home_name, home_id);
-                sources.insert(home_id, ScopeModuleSource::Current);
-
-                let mut insert_both = |id: ModuleId, name_str: &'static str| {
-                    let name: ModuleName = name_str.into();
-
-                    modules.insert(name, id);
-                    sources.insert(id, ScopeModuleSource::Builtin);
-                };
-
-                $(
-                    insert_both(ModuleId::$module_const, $module_name);
-                )+
-
-                ScopeModules { modules, sources }
-            }
-        }
-
         impl<'a> Default for PackageModuleIds<'a> {
             fn default() -> Self {
                 // +1 because the user will be compiling at least 1 non-builtin module!
@@ -1556,6 +1475,8 @@ define_builtins! {
         5 RESULT_WITH_DEFAULT: "withDefault"
         6 RESULT_TRY: "try"
         7 RESULT_IS_OK: "isOk"
+        8 RESULT_MAP_BOTH: "mapBoth"
+        9 RESULT_MAP_TWO: "map2"
     }
     8 DICT: "Dict" => {
         0 DICT_DICT: "Dict" exposed_type=true // the Dict.Dict type alias

crates/compiler/mono/src/ir.rs

@@ -4443,6 +4443,15 @@ pub fn with_hole<'a>(
 
             specialize_naked_symbol(env, variable, procs, layout_cache, assigned, hole, symbol)
         }
+        ParamsVar { .. } => {
+            unimplemented!("module params code generation")
+        }
+        ImportParams(_, _, Some((_, value))) => {
+            with_hole(env, *value, variable, procs, layout_cache, assigned, hole)
+        }
+        ImportParams(_, _, None) => {
+            internal_error!("Missing module params should've been dropped by now");
+        }
         AbilityMember(member, specialization_id, specialization_var) => {
             let specialization_symbol = late_resolve_ability_specialization(
                 env,

crates/compiler/parse/benches/bench_parse.rs

@@ -2,7 +2,7 @@ use bumpalo::Bump;
 use criterion::{black_box, criterion_group, criterion_main, Criterion};
 use roc_parse::{
     ast::Defs,
-    module::{self, parse_module_defs},
+    header::{self, parse_module_defs},
     state::State,
 };
 use std::path::PathBuf;
@@ -20,7 +20,7 @@ pub fn parse_benchmark(c: &mut Criterion) {
             let arena = Bump::new();
 
             let (_actual, state) =
-                module::parse_header(&arena, State::new(src.as_bytes())).unwrap();
+                header::parse_header(&arena, State::new(src.as_bytes())).unwrap();
 
             let res = parse_module_defs(&arena, state, Defs::default()).unwrap();
 
@@ -41,7 +41,7 @@ pub fn parse_benchmark(c: &mut Criterion) {
             let arena = Bump::new();
 
             let (_actual, state) =
-                module::parse_header(&arena, State::new(src.as_bytes())).unwrap();
+                header::parse_header(&arena, State::new(src.as_bytes())).unwrap();
 
             let res = parse_module_defs(&arena, state, Defs::default()).unwrap();
 

crates/compiler/parse/src/ast.rs

@@ -14,6 +14,12 @@ use roc_module::called_via::{BinOp, CalledVia, UnaryOp};
 use roc_module::ident::QualifiedModuleName;
 use roc_region::all::{Loc, Position, Region};
 
+#[derive(Debug, Clone)]
+pub struct FullAst<'a> {
+    pub header: SpacesBefore<'a, Header<'a>>,
+    pub defs: Defs<'a>,
+}
+
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 pub struct Spaces<'a, T> {
     pub before: &'a [CommentOrNewline<'a>],
@@ -111,15 +117,9 @@ impl<'a, T: ExtractSpaces<'a>> ExtractSpaces<'a> for Loc<T> {
     }
 }
 
-#[derive(Clone, Debug, PartialEq)]
-pub struct Module<'a> {
-    pub comments: &'a [CommentOrNewline<'a>],
-    pub header: Header<'a>,
-}
-
-impl<'a> Module<'a> {
+impl<'a> Header<'a> {
     pub fn upgrade_header_imports(self, arena: &'a Bump) -> (Self, Defs<'a>) {
-        let (header, defs) = match self.header {
+        let (header, defs) = match self {
             Header::Module(header) => (
                 Header::Module(ModuleHeader {
                     interface_imports: None,
@@ -134,12 +134,10 @@ impl<'a> Module<'a> {
                 }),
                 Self::header_imports_to_defs(arena, header.old_imports),
             ),
-            Header::Package(_) | Header::Platform(_) | Header::Hosted(_) => {
-                (self.header, Defs::default())
-            }
+            Header::Package(_) | Header::Platform(_) | Header::Hosted(_) => (self, Defs::default()),
         };
 
-        (Module { header, ..self }, defs)
+        (header, defs)
     }
 
     pub fn header_imports_to_defs(
@@ -681,9 +679,9 @@ fn is_when_branch_suffixed(branch: &WhenBranch<'_>) -> bool {
 
 fn is_assigned_value_suffixed<'a>(value: &AssignedField<'a, Expr<'a>>) -> bool {
     match value {
-        AssignedField::RequiredValue(_, _, a) | AssignedField::OptionalValue(_, _, a) => {
-            is_expr_suffixed(&a.value)
-        }
+        AssignedField::RequiredValue(_, _, a)
+        | AssignedField::OptionalValue(_, _, a)
+        | AssignedField::IgnoredValue(_, _, a) => is_expr_suffixed(&a.value),
         AssignedField::LabelOnly(_) => false,
         AssignedField::SpaceBefore(a, _) | AssignedField::SpaceAfter(a, _) => {
             is_assigned_value_suffixed(a)
@@ -869,9 +867,9 @@ impl<'a, 'b> RecursiveValueDefIter<'a, 'b> {
                         use AssignedField::*;
 
                         match current {
-                            RequiredValue(_, _, loc_val) | OptionalValue(_, _, loc_val) => {
-                                break expr_stack.push(&loc_val.value)
-                            }
+                            RequiredValue(_, _, loc_val)
+                            | OptionalValue(_, _, loc_val)
+                            | IgnoredValue(_, _, loc_val) => break expr_stack.push(&loc_val.value),
                             SpaceBefore(next, _) | SpaceAfter(next, _) => current = *next,
                             LabelOnly(_) | Malformed(_) => break,
                         }
@@ -1070,7 +1068,7 @@ impl<'a, 'b> Iterator for RecursiveValueDefIter<'a, 'b> {
                             params,
                         }) => {
                             if let Some(ModuleImportParams { before: _, params }) = params {
-                                for loc_assigned_field in params.items {
+                                for loc_assigned_field in params.value.items {
                                     if let Some(expr) = loc_assigned_field.value.value() {
                                         self.push_pending_from_expr(&expr.value);
                                     }
@@ -1118,7 +1116,7 @@ pub struct ModuleImport<'a> {
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub struct ModuleImportParams<'a> {
     pub before: &'a [CommentOrNewline<'a>],
-    pub params: Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>,
+    pub params: Loc<Collection<'a, Loc<AssignedField<'a, Expr<'a>>>>>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq)]
@@ -1598,6 +1596,9 @@ pub enum AssignedField<'a, Val> {
     // and in destructuring patterns (e.g. `{ name ? "blah" }`)
     OptionalValue(Loc<&'a str>, &'a [CommentOrNewline<'a>], &'a Loc<Val>),
 
+    // An ignored field, e.g. `{ _name: "blah" }` or `{ _ : Str }`
+    IgnoredValue(Loc<&'a str>, &'a [CommentOrNewline<'a>], &'a Loc<Val>),
+
     // A label with no value, e.g. `{ name }` (this is sugar for { name: name })
     LabelOnly(Loc<&'a str>),
 
@@ -1615,7 +1616,9 @@ impl<'a, Val> AssignedField<'a, Val> {
 
         loop {
             match current {
-                Self::RequiredValue(_, _, val) | Self::OptionalValue(_, _, val) => break Some(val),
+                Self::RequiredValue(_, _, val)
+                | Self::OptionalValue(_, _, val)
+                | Self::IgnoredValue(_, _, val) => break Some(val),
                 Self::LabelOnly(_) | Self::Malformed(_) => break None,
                 Self::SpaceBefore(next, _) | Self::SpaceAfter(next, _) => current = *next,
             }
@@ -2433,9 +2436,9 @@ pub trait Malformed {
     fn is_malformed(&self) -> bool;
 }
 
-impl<'a> Malformed for Module<'a> {
+impl<'a> Malformed for FullAst<'a> {
     fn is_malformed(&self) -> bool {
-        self.header.is_malformed()
+        self.header.item.is_malformed() || self.defs.is_malformed()
     }
 }
 
@@ -2457,6 +2460,12 @@ impl<'a, T: Malformed> Malformed for Spaces<'a, T> {
     }
 }
 
+impl<'a, T: Malformed> Malformed for SpacesBefore<'a, T> {
+    fn is_malformed(&self) -> bool {
+        self.item.is_malformed()
+    }
+}
+
 impl<'a> Malformed for Expr<'a> {
     fn is_malformed(&self) -> bool {
         use Expr::*;
@@ -2577,9 +2586,9 @@ impl<T: Malformed> Malformed for Option<T> {
 impl<'a, T: Malformed> Malformed for AssignedField<'a, T> {
     fn is_malformed(&self) -> bool {
         match self {
-            AssignedField::RequiredValue(_, _, val) | AssignedField::OptionalValue(_, _, val) => {
-                val.is_malformed()
-            }
+            AssignedField::RequiredValue(_, _, val)
+            | AssignedField::OptionalValue(_, _, val)
+            | AssignedField::IgnoredValue(_, _, val) => val.is_malformed(),
             AssignedField::LabelOnly(_) => false,
             AssignedField::SpaceBefore(field, _) | AssignedField::SpaceAfter(field, _) => {
                 field.is_malformed()

crates/compiler/parse/src/expr.rs

@@ -9,10 +9,10 @@ use crate::blankspace::{
     loc_space0_e, require_newline_or_eof, space0_after_e, space0_around_ee, space0_before_e,
     space0_before_optional_after, space0_e, spaces, spaces_around, spaces_before,
 };
+use crate::header::module_name_help;
 use crate::ident::{
     integer_ident, lowercase_ident, parse_ident, unqualified_ident, Accessor, Ident, Suffix,
 };
-use crate::module::module_name_help;
 use crate::parser::{
     self, and, backtrackable, between, byte, byte_indent, collection_inner,
     collection_trailing_sep_e, either, increment_min_indent, indented_seq_skip_first, loc, map,
@@ -24,8 +24,8 @@ use crate::parser::{
 use crate::pattern::closure_param;
 use crate::state::State;
 use crate::string_literal::{self, StrLikeLiteral};
+use crate::type_annotation;
 use crate::{header, keyword};
-use crate::{module, type_annotation};
 use bumpalo::collections::Vec;
 use bumpalo::Bump;
 use roc_collections::soa::Slice;
@@ -892,10 +892,10 @@ fn import_params<'a>() -> impl Parser<'a, ModuleImportParams<'a>, EImportParams<
     then(
         and(
             backtrackable(space0_e(EImportParams::Indent)),
-            specialize_err(EImportParams::Record, record_help()),
+            specialize_err(EImportParams::Record, loc(record_help())),
         ),
-        |arena, state, _, (before, record): (_, RecordHelp<'a>)| {
-            if let Some(prefix) = record.prefix {
+        |arena, state, _, (before, loc_record): (_, Loc<RecordHelp<'a>>)| {
+            if let Some(prefix) = loc_record.value.prefix {
                 match prefix {
                     (update, RecordHelpPrefix::Update) => {
                         return Err((
@@ -912,17 +912,27 @@ fn import_params<'a>() -> impl Parser<'a, ModuleImportParams<'a>, EImportParams<
                 }
             }
 
-            let params = record.fields.map_items_result(arena, |loc_field| {
-                match loc_field.value.to_assigned_field(arena) {
-                    Ok(field) => Ok(Loc::at(loc_field.region, field)),
-                    Err(FoundApplyValue) => Err((
-                        MadeProgress,
-                        EImportParams::RecordApplyFound(loc_field.region),
-                    )),
-                }
-            })?;
+            let params = loc_record
+                .value
+                .fields
+                .map_items_result(arena, |loc_field| {
+                    match loc_field.value.to_assigned_field(arena) {
+                        Ok(AssignedField::IgnoredValue(_, _, _)) => Err((
+                            MadeProgress,
+                            EImportParams::RecordIgnoredFieldFound(loc_field.region),
+                        )),
+                        Ok(field) => Ok(Loc::at(loc_field.region, field)),
+                        Err(FoundApplyValue) => Err((
+                            MadeProgress,
+                            EImportParams::RecordApplyFound(loc_field.region),
+                        )),
+                    }
+                })?;
 
-            let import_params = ModuleImportParams { before, params };
+            let import_params = ModuleImportParams {
+                before,
+                params: Loc::at(loc_record.region, params),
+            };
 
             Ok((MadeProgress, import_params, state))
         },
@@ -944,7 +954,7 @@ fn imported_module_name<'a>() -> impl Parser<'a, ImportedModuleName<'a>, EImport
 fn import_as<'a>(
 ) -> impl Parser<'a, header::KeywordItem<'a, ImportAsKeyword, Loc<ImportAlias<'a>>>, EImport<'a>> {
     record!(header::KeywordItem {
-        keyword: module::spaces_around_keyword(
+        keyword: header::spaces_around_keyword(
             ImportAsKeyword,
             EImport::As,
             EImport::IndentAs,
@@ -978,7 +988,7 @@ fn import_exposing<'a>() -> impl Parser<
     EImport<'a>,
 > {
     record!(header::KeywordItem {
-        keyword: module::spaces_around_keyword(
+        keyword: header::spaces_around_keyword(
             ImportExposingKeyword,
             EImport::Exposing,
             EImport::IndentExposing,
@@ -1023,7 +1033,7 @@ fn import_ingested_file_body<'a>() -> impl Parser<'a, ValueDef<'a>, EImport<'a>>
 fn import_ingested_file_as<'a>(
 ) -> impl Parser<'a, header::KeywordItem<'a, ImportAsKeyword, Loc<&'a str>>, EImport<'a>> {
     record!(header::KeywordItem {
-        keyword: module::spaces_around_keyword(
+        keyword: header::spaces_around_keyword(
             ImportAsKeyword,
             EImport::As,
             EImport::IndentAs,
@@ -2234,6 +2244,7 @@ fn assigned_expr_field_to_pattern_help<'a>(
             spaces,
         ),
         AssignedField::Malformed(string) => Pattern::Malformed(string),
+        AssignedField::IgnoredValue(_, _, _) => return Err(()),
     })
 }
 
@@ -3322,6 +3333,7 @@ fn list_literal_help<'a>() -> impl Parser<'a, Expr<'a>, EList<'a>> {
 pub enum RecordField<'a> {
     RequiredValue(Loc<&'a str>, &'a [CommentOrNewline<'a>], &'a Loc<Expr<'a>>),
     OptionalValue(Loc<&'a str>, &'a [CommentOrNewline<'a>], &'a Loc<Expr<'a>>),
+    IgnoredValue(Loc<&'a str>, &'a [CommentOrNewline<'a>], &'a Loc<Expr<'a>>),
     LabelOnly(Loc<&'a str>),
     SpaceBefore(&'a RecordField<'a>, &'a [CommentOrNewline<'a>]),
     SpaceAfter(&'a RecordField<'a>, &'a [CommentOrNewline<'a>]),
@@ -3337,7 +3349,10 @@ pub enum RecordField<'a> {
 pub struct FoundApplyValue;
 
 #[derive(Debug)]
-struct FoundOptionalValue;
+pub enum NotOldBuilderFieldValue {
+    FoundOptionalValue,
+    FoundIgnoredValue,
+}
 
 impl<'a> RecordField<'a> {
     fn is_apply_value(&self) -> bool {
@@ -3354,6 +3369,20 @@ impl<'a> RecordField<'a> {
         }
     }
 
+    fn is_ignored_value(&self) -> bool {
+        let mut current = self;
+
+        loop {
+            match current {
+                RecordField::IgnoredValue(_, _, _) => break true,
+                RecordField::SpaceBefore(field, _) | RecordField::SpaceAfter(field, _) => {
+                    current = *field;
+                }
+                _ => break false,
+            }
+        }
+    }
+
     pub fn to_assigned_field(
         self,
         arena: &'a Bump,
@@ -3369,6 +3398,10 @@ impl<'a> RecordField<'a> {
                 Ok(OptionalValue(loc_label, spaces, loc_expr))
             }
 
+            RecordField::IgnoredValue(loc_label, spaces, loc_expr) => {
+                Ok(IgnoredValue(loc_label, spaces, loc_expr))
+            }
+
             RecordField::LabelOnly(loc_label) => Ok(LabelOnly(loc_label)),
 
             RecordField::ApplyValue(_, _, _, _) => Err(FoundApplyValue),
@@ -3390,7 +3423,7 @@ impl<'a> RecordField<'a> {
     fn to_builder_field(
         self,
         arena: &'a Bump,
-    ) -> Result<OldRecordBuilderField<'a>, FoundOptionalValue> {
+    ) -> Result<OldRecordBuilderField<'a>, NotOldBuilderFieldValue> {
         use OldRecordBuilderField::*;
 
         match self {
@@ -3398,7 +3431,9 @@ impl<'a> RecordField<'a> {
                 Ok(Value(loc_label, spaces, loc_expr))
             }
 
-            RecordField::OptionalValue(_, _, _) => Err(FoundOptionalValue),
+            RecordField::OptionalValue(_, _, _) => Err(NotOldBuilderFieldValue::FoundOptionalValue),
+
+            RecordField::IgnoredValue(_, _, _) => Err(NotOldBuilderFieldValue::FoundIgnoredValue),
 
             RecordField::LabelOnly(loc_label) => Ok(LabelOnly(loc_label)),
 
@@ -3434,42 +3469,70 @@ pub fn record_field<'a>() -> impl Parser<'a, RecordField<'a>, ERecord<'a>> {
     use RecordField::*;
 
     map_with_arena(
-        and(
-            specialize_err(|_, pos| ERecord::Field(pos), loc(lowercase_ident())),
+        either(
             and(
-                spaces(),
-                optional(either(
-                    and(byte(b':', ERecord::Colon), record_field_expr()),
-                    and(
-                        byte(b'?', ERecord::QuestionMark),
+                specialize_err(|_, pos| ERecord::Field(pos), loc(lowercase_ident())),
+                and(
+                    spaces(),
+                    optional(either(
+                        and(byte(b':', ERecord::Colon), record_field_expr()),
+                        and(
+                            byte(b'?', ERecord::QuestionMark),
+                            spaces_before(specialize_err_ref(ERecord::Expr, loc_expr(false))),
+                        ),
+                    )),
+                ),
+            ),
+            and(
+                loc(skip_first(
+                    byte(b'_', ERecord::UnderscoreField),
+                    optional(specialize_err(
+                        |_, pos| ERecord::Field(pos),
+                        lowercase_ident(),
+                    )),
+                )),
+                and(
+                    spaces(),
+                    skip_first(
+                        byte(b':', ERecord::Colon),
                         spaces_before(specialize_err_ref(ERecord::Expr, loc_expr(false))),
                     ),
-                )),
+                ),
             ),
         ),
-        |arena: &'a bumpalo::Bump, (loc_label, (spaces, opt_loc_val))| {
-            match opt_loc_val {
-                Some(Either::First((_, RecordFieldExpr::Value(loc_val)))) => {
-                    RequiredValue(loc_label, spaces, arena.alloc(loc_val))
-                }
+        |arena: &'a bumpalo::Bump, field_data| {
+            match field_data {
+                Either::First((loc_label, (spaces, opt_loc_val))) => {
+                    match opt_loc_val {
+                        Some(Either::First((_, RecordFieldExpr::Value(loc_val)))) => {
+                            RequiredValue(loc_label, spaces, arena.alloc(loc_val))
+                        }
 
-                Some(Either::First((_, RecordFieldExpr::Apply(arrow_spaces, loc_val)))) => {
-                    ApplyValue(loc_label, spaces, arrow_spaces, arena.alloc(loc_val))
-                }
+                        Some(Either::First((_, RecordFieldExpr::Apply(arrow_spaces, loc_val)))) => {
+                            ApplyValue(loc_label, spaces, arrow_spaces, arena.alloc(loc_val))
+                        }
 
-                Some(Either::Second((_, loc_val))) => {
-                    OptionalValue(loc_label, spaces, arena.alloc(loc_val))
-                }
+                        Some(Either::Second((_, loc_val))) => {
+                            OptionalValue(loc_label, spaces, arena.alloc(loc_val))
+                        }
 
-                // If no value was provided, record it as a Var.
-                // Canonicalize will know what to do with a Var later.
-                None => {
-                    if !spaces.is_empty() {
-                        SpaceAfter(arena.alloc(LabelOnly(loc_label)), spaces)
-                    } else {
-                        LabelOnly(loc_label)
+                        // If no value was provided, record it as a Var.
+                        // Canonicalize will know what to do with a Var later.
+                        None => {
+                            if !spaces.is_empty() {
+                                SpaceAfter(arena.alloc(LabelOnly(loc_label)), spaces)
+                            } else {
+                                LabelOnly(loc_label)
+                            }
+                        }
                     }
                 }
+                Either::Second((loc_opt_label, (spaces, loc_val))) => {
+                    let loc_label = loc_opt_label
+                        .map(|opt_label| opt_label.unwrap_or_else(|| arena.alloc_str("")));
+
+                    IgnoredValue(loc_label, spaces, arena.alloc(loc_val))
+                }
             }
         },
     )
@@ -3573,20 +3636,23 @@ fn record_literal_help<'a>() -> impl Parser<'a, Expr<'a>, EExpr<'a>> {
                     new_record_builder_help(arena, mapper, record.fields)
                 }
                 None => {
-                    let is_old_record_builder = record
-                        .fields
-                        .iter()
-                        .any(|field| field.value.is_apply_value());
+                    let special_field_found = record.fields.iter().find_map(|field| {
+                        if field.value.is_apply_value() {
+                            Some(old_record_builder_help(arena, record.fields))
+                        } else if field.value.is_ignored_value() {
+                            Some(Err(EExpr::RecordUpdateIgnoredField(field.region)))
+                        } else {
+                            None
+                        }
+                    });
 
-                    if is_old_record_builder {
-                        old_record_builder_help(arena, record.fields)
-                    } else {
+                    special_field_found.unwrap_or_else(|| {
                         let fields = record.fields.map_items(arena, |loc_field| {
                             loc_field.map(|field| field.to_assigned_field(arena).unwrap())
                         });
 
                         Ok(Expr::Record(fields))
-                    }
+                    })
                 }
             };
 
@@ -3609,11 +3675,14 @@ fn record_update_help<'a>(
 ) -> Result<Expr<'a>, EExpr<'a>> {
     let result = fields.map_items_result(arena, |loc_field| {
         match loc_field.value.to_assigned_field(arena) {
+            Ok(AssignedField::IgnoredValue(_, _, _)) => {
+                Err(EExpr::RecordUpdateIgnoredField(loc_field.region))
+            }
             Ok(builder_field) => Ok(Loc {
                 region: loc_field.region,
                 value: builder_field,
             }),
-            Err(FoundApplyValue) => Err(EExpr::RecordUpdateAccumulator(loc_field.region)),
+            Err(FoundApplyValue) => Err(EExpr::RecordUpdateOldBuilderField(loc_field.region)),
         }
     });
 
@@ -3634,7 +3703,7 @@ fn new_record_builder_help<'a>(
                 region: loc_field.region,
                 value: builder_field,
             }),
-            Err(FoundApplyValue) => Err(EExpr::RecordBuilderAccumulator(loc_field.region)),
+            Err(FoundApplyValue) => Err(EExpr::RecordBuilderOldBuilderField(loc_field.region)),
         }
     });
 
@@ -3654,7 +3723,12 @@ fn old_record_builder_help<'a>(
                 region: loc_field.region,
                 value: builder_field,
             }),
-            Err(FoundOptionalValue) => Err(EExpr::OptionalValueInRecordBuilder(loc_field.region)),
+            Err(NotOldBuilderFieldValue::FoundOptionalValue) => {
+                Err(EExpr::OptionalValueInOldRecordBuilder(loc_field.region))
+            }
+            Err(NotOldBuilderFieldValue::FoundIgnoredValue) => {
+                Err(EExpr::IgnoredValueInOldRecordBuilder(loc_field.region))
+            }
         }
     });
 

crates/compiler/parse/src/highlight.rs

@@ -74,7 +74,7 @@ pub fn highlight(text: &str) -> Vec<Loc<Token>> {
     let header_keywords = HEADER_KEYWORDS.iter().copied().collect::<HashSet<_>>();
     let body_keywords = KEYWORDS.iter().copied().collect::<HashSet<_>>();
 
-    if let Ok((_prog, _, new_state)) = crate::module::header().parse(&arena, state.clone(), 0) {
+    if let Ok((_prog, _, new_state)) = crate::header::header().parse(&arena, state.clone(), 0) {
         let inner_state =
             State::new(text[..state.bytes().len() - new_state.bytes().len()].as_bytes());
         highlight_inner(&arena, inner_state, &mut tokens, &header_keywords);

crates/compiler/parse/src/lib.rs

@@ -13,11 +13,10 @@ pub mod header;
 pub mod highlight;
 pub mod ident;
 pub mod keyword;
-pub mod module;
+pub mod normalize;
 pub mod number_literal;
 pub mod pattern;
 pub mod problems;
-pub mod remove_spaces;
 pub mod src64;
 pub mod state;
 pub mod string_literal;

crates/compiler/parse/src/module.rs

@@ -1,945 +0,0 @@
-use crate::ast::{Collection, CommentOrNewline, Defs, Header, Module, Spaced, Spaces};
-use crate::blankspace::{space0_around_ee, space0_before_e, space0_e};
-use crate::expr::merge_spaces;
-use crate::header::{
-    package_entry, package_name, AppHeader, ExposedName, ExposesKeyword, GeneratesKeyword,
-    HostedHeader, ImportsCollection, ImportsEntry, ImportsKeyword, ImportsKeywordItem, Keyword,
-    KeywordItem, ModuleHeader, ModuleName, ModuleParams, PackageEntry, PackageHeader,
-    PackagesKeyword, PlatformHeader, PlatformRequires, ProvidesKeyword, ProvidesTo,
-    RequiresKeyword, To, ToKeyword, TypedIdent, WithKeyword,
-};
-use crate::ident::{self, lowercase_ident, unqualified_ident, uppercase, UppercaseIdent};
-use crate::parser::Progress::{self, *};
-use crate::parser::{
-    and, backtrackable, byte, collection_trailing_sep_e, increment_min_indent, loc, map,
-    map_with_arena, optional, reset_min_indent, skip_first, skip_second, specialize_err, succeed,
-    two_bytes, zero_or_more, EExposes, EGenerates, EGeneratesWith, EHeader, EImports, EPackages,
-    EParams, EProvides, ERequires, ETypedIdent, Parser, SourceError, SpaceProblem, SyntaxError,
-};
-use crate::pattern::record_pattern_fields;
-use crate::state::State;
-use crate::string_literal::{self, parse_str_literal};
-use crate::type_annotation;
-use roc_region::all::{Loc, Position, Region};
-
-fn end_of_file<'a>() -> impl Parser<'a, (), SyntaxError<'a>> {
-    |_arena, state: State<'a>, _min_indent: u32| {
-        if state.has_reached_end() {
-            Ok((NoProgress, (), state))
-        } else {
-            Err((NoProgress, SyntaxError::NotEndOfFile(state.pos())))
-        }
-    }
-}
-
-pub fn parse_module_defs<'a>(
-    arena: &'a bumpalo::Bump,
-    state: State<'a>,
-    defs: Defs<'a>,
-) -> Result<Defs<'a>, SyntaxError<'a>> {
-    let min_indent = 0;
-    match crate::expr::parse_top_level_defs(arena, state.clone(), defs) {
-        Ok((_, defs, state)) => match end_of_file().parse(arena, state, min_indent) {
-            Ok(_) => Ok(defs),
-            Err((_, fail)) => Err(fail),
-        },
-        Err((_, fail)) => Err(SyntaxError::Expr(fail, state.pos())),
-    }
-}
-
-pub fn parse_header<'a>(
-    arena: &'a bumpalo::Bump,
-    state: State<'a>,
-) -> Result<(Module<'a>, State<'a>), SourceError<'a, EHeader<'a>>> {
-    let min_indent = 0;
-    match header().parse(arena, state.clone(), min_indent) {
-        Ok((_, module, state)) => Ok((module, state)),
-        Err((_, fail)) => Err(SourceError::new(fail, &state)),
-    }
-}
-
-pub fn header<'a>() -> impl Parser<'a, Module<'a>, EHeader<'a>> {
-    use crate::parser::keyword;
-
-    record!(Module {
-        comments: space0_e(EHeader::IndentStart),
-        header: one_of![
-            map(
-                skip_first(
-                    keyword("module", EHeader::Start),
-                    increment_min_indent(module_header())
-                ),
-                Header::Module
-            ),
-            map(
-                skip_first(
-                    keyword("interface", EHeader::Start),
-                    increment_min_indent(interface_header())
-                ),
-                Header::Module
-            ),
-            map(
-                skip_first(
-                    keyword("app", EHeader::Start),
-                    increment_min_indent(one_of![app_header(), old_app_header()])
-                ),
-                Header::App
-            ),
-            map(
-                skip_first(
-                    keyword("package", EHeader::Start),
-                    increment_min_indent(one_of![package_header(), old_package_header()])
-                ),
-                Header::Package
-            ),
-            map(
-                skip_first(
-                    keyword("platform", EHeader::Start),
-                    increment_min_indent(platform_header())
-                ),
-                Header::Platform
-            ),
-            map(
-                skip_first(
-                    keyword("hosted", EHeader::Start),
-                    increment_min_indent(hosted_header())
-                ),
-                Header::Hosted
-            ),
-        ]
-    })
-}
-
-#[inline(always)]
-fn module_header<'a>() -> impl Parser<'a, ModuleHeader<'a>, EHeader<'a>> {
-    record!(ModuleHeader {
-        after_keyword: space0_e(EHeader::IndentStart),
-        params: optional(specialize_err(EHeader::Params, module_params())),
-        exposes: specialize_err(EHeader::Exposes, exposes_list()),
-        interface_imports: succeed(None)
-    })
-    .trace("module_header")
-}
-
-fn module_params<'a>() -> impl Parser<'a, ModuleParams<'a>, EParams<'a>> {
-    record!(ModuleParams {
-        params: specialize_err(EParams::Pattern, record_pattern_fields()),
-        before_arrow: skip_second(
-            space0_e(EParams::BeforeArrow),
-            loc(two_bytes(b'-', b'>', EParams::Arrow))
-        ),
-        after_arrow: space0_e(EParams::AfterArrow),
-    })
-}
-
-// TODO does this need to be a macro?
-macro_rules! merge_n_spaces {
-    ($arena:expr, $($slice:expr),*) => {
-        {
-            let mut merged = bumpalo::collections::Vec::with_capacity_in(0 $(+ $slice.len())*, $arena);
-            $(merged.extend_from_slice($slice);)*
-            merged.into_bump_slice()
-        }
-    };
-}
-
-/// Parse old interface headers so we can format them into module headers
-#[inline(always)]
-fn interface_header<'a>() -> impl Parser<'a, ModuleHeader<'a>, EHeader<'a>> {
-    let after_keyword = map_with_arena(
-        and(
-            skip_second(
-                space0_e(EHeader::IndentStart),
-                loc(module_name_help(EHeader::ModuleName)),
-            ),
-            specialize_err(EHeader::Exposes, exposes_kw()),
-        ),
-        |arena: &'a bumpalo::Bump,
-         (before_name, kw): (&'a [CommentOrNewline<'a>], Spaces<'a, ExposesKeyword>)| {
-            merge_n_spaces!(arena, before_name, kw.before, kw.after)
-        },
-    );
-
-    record!(ModuleHeader {
-        after_keyword: after_keyword,
-        params: succeed(None),
-        exposes: specialize_err(EHeader::Exposes, exposes_list()).trace("exposes_list"),
-        interface_imports: map(
-            specialize_err(EHeader::Imports, imports()),
-            imports_none_if_empty
-        )
-        .trace("imports"),
-    })
-    .trace("interface_header")
-}
-
-fn imports_none_if_empty(value: ImportsKeywordItem<'_>) -> Option<ImportsKeywordItem<'_>> {
-    if value.item.is_empty() {
-        None
-    } else {
-        Some(value)
-    }
-}
-
-#[inline(always)]
-fn hosted_header<'a>() -> impl Parser<'a, HostedHeader<'a>, EHeader<'a>> {
-    record!(HostedHeader {
-        before_name: space0_e(EHeader::IndentStart),
-        name: loc(module_name_help(EHeader::ModuleName)),
-        exposes: specialize_err(EHeader::Exposes, exposes_values_kw()),
-        imports: specialize_err(EHeader::Imports, imports()),
-        generates: specialize_err(EHeader::Generates, generates()),
-        generates_with: specialize_err(EHeader::GeneratesWith, generates_with()),
-    })
-    .trace("hosted_header")
-}
-
-fn chomp_module_name(buffer: &[u8]) -> Result<&str, Progress> {
-    use encode_unicode::CharExt;
-
-    let mut chomped = 0;
-
-    if let Ok((first_letter, width)) = char::from_utf8_slice_start(&buffer[chomped..]) {
-        if first_letter.is_uppercase() {
-            chomped += width;
-        } else {
-            return Err(Progress::NoProgress);
-        }
-    }
-
-    while let Ok((ch, width)) = char::from_utf8_slice_start(&buffer[chomped..]) {
-        // After the first character, only these are allowed:
-        //
-        // * Unicode alphabetic chars - you might include `鹏` if that's clear to your readers
-        // * ASCII digits - e.g. `1` but not `¾`, both of which pass .is_numeric()
-        // * A '.' separating module parts
-        if ch.is_alphabetic() || ch.is_ascii_digit() {
-            chomped += width;
-        } else if ch == '.' {
-            chomped += width;
-
-            if let Ok((first_letter, width)) = char::from_utf8_slice_start(&buffer[chomped..]) {
-                if first_letter.is_uppercase() {
-                    chomped += width;
-                } else if first_letter == '{' {
-                    // the .{ starting a `Foo.{ bar, baz }` importing clauses
-                    chomped -= width;
-                    break;
-                } else {
-                    return Err(Progress::MadeProgress);
-                }
-            }
-        } else {
-            // we're done
-            break;
-        }
-    }
-
-    let name = unsafe { std::str::from_utf8_unchecked(&buffer[..chomped]) };
-
-    Ok(name)
-}
-
-#[inline(always)]
-fn module_name<'a>() -> impl Parser<'a, ModuleName<'a>, ()> {
-    |_, mut state: State<'a>, _min_indent: u32| match chomp_module_name(state.bytes()) {
-        Ok(name) => {
-            let width = name.len();
-            state = state.advance(width);
-
-            Ok((MadeProgress, ModuleName::new(name), state))
-        }
-        Err(progress) => Err((progress, ())),
-    }
-}
-
-#[inline(always)]
-fn app_header<'a>() -> impl Parser<'a, AppHeader<'a>, EHeader<'a>> {
-    record!(AppHeader {
-        before_provides: space0_e(EHeader::IndentStart),
-        provides: specialize_err(EHeader::Exposes, exposes_list()),
-        before_packages: space0_e(EHeader::IndentStart),
-        packages: specialize_err(EHeader::Packages, loc(packages_collection())),
-        old_imports: succeed(None),
-        old_provides_to_new_package: succeed(None),
-    })
-    .trace("app_header")
-}
-
-struct OldAppHeader<'a> {
-    pub before_name: &'a [CommentOrNewline<'a>],
-    pub packages: Option<Loc<OldAppPackages<'a>>>,
-    pub imports: Option<KeywordItem<'a, ImportsKeyword, ImportsCollection<'a>>>,
-    pub provides: ProvidesTo<'a>,
-}
-
-type OldAppPackages<'a> =
-    KeywordItem<'a, PackagesKeyword, Collection<'a, Loc<Spaced<'a, PackageEntry<'a>>>>>;
-
-#[inline(always)]
-fn old_app_header<'a>() -> impl Parser<'a, AppHeader<'a>, EHeader<'a>> {
-    let old = record!(OldAppHeader {
-        before_name: skip_second(
-            space0_e(EHeader::IndentStart),
-            loc(crate::parser::specialize_err(
-                EHeader::AppName,
-                string_literal::parse_str_literal()
-            ))
-        ),
-        packages: optional(specialize_err(EHeader::Packages, loc(packages()))),
-        imports: optional(specialize_err(EHeader::Imports, imports())),
-        provides: specialize_err(EHeader::Provides, provides_to()),
-    });
-
-    map_with_arena(old, |arena: &'a bumpalo::Bump, old: OldAppHeader<'a>| {
-        let mut before_packages: &'a [CommentOrNewline] = &[];
-
-        let packages = match old.packages {
-            Some(packages) => {
-                before_packages = merge_spaces(
-                    arena,
-                    packages.value.keyword.before,
-                    packages.value.keyword.after,
-                );
-
-                if let To::ExistingPackage(platform_shorthand) = old.provides.to.value {
-                    packages.map(|coll| {
-                        coll.item.map_items(arena, |loc_spaced_pkg| {
-                            if loc_spaced_pkg.value.item().shorthand == platform_shorthand {
-                                loc_spaced_pkg.map(|spaced_pkg| {
-                                    spaced_pkg.map(arena, |pkg| {
-                                        let mut new_pkg = *pkg;
-                                        new_pkg.platform_marker = Some(merge_spaces(
-                                            arena,
-                                            old.provides.to_keyword.before,
-                                            old.provides.to_keyword.after,
-                                        ));
-                                        new_pkg
-                                    })
-                                })
-                            } else {
-                                *loc_spaced_pkg
-                            }
-                        })
-                    })
-                } else {
-                    packages.map(|kw| kw.item)
-                }
-            }
-            None => Loc {
-                region: Region::zero(),
-                value: Collection::empty(),
-            },
-        };
-
-        let provides = match old.provides.types {
-            Some(types) => {
-                let mut combined_items = bumpalo::collections::Vec::with_capacity_in(
-                    old.provides.entries.items.len() + types.items.len(),
-                    arena,
-                );
-
-                combined_items.extend_from_slice(old.provides.entries.items);
-
-                for loc_spaced_type_ident in types.items {
-                    combined_items.push(loc_spaced_type_ident.map(|spaced_type_ident| {
-                        spaced_type_ident.map(arena, |type_ident| {
-                            ExposedName::new(From::from(*type_ident))
-                        })
-                    }));
-                }
-
-                let value_comments = old.provides.entries.final_comments();
-                let type_comments = types.final_comments();
-
-                let mut combined_comments = bumpalo::collections::Vec::with_capacity_in(
-                    value_comments.len() + type_comments.len(),
-                    arena,
-                );
-                combined_comments.extend_from_slice(value_comments);
-                combined_comments.extend_from_slice(type_comments);
-
-                Collection::with_items_and_comments(
-                    arena,
-                    combined_items.into_bump_slice(),
-                    combined_comments.into_bump_slice(),
-                )
-            }
-            None => old.provides.entries,
-        };
-
-        AppHeader {
-            before_provides: merge_spaces(
-                arena,
-                old.before_name,
-                old.provides.provides_keyword.before,
-            ),
-            provides,
-            before_packages: merge_spaces(
-                arena,
-                before_packages,
-                old.provides.provides_keyword.after,
-            ),
-            packages,
-            old_imports: old.imports.and_then(imports_none_if_empty),
-            old_provides_to_new_package: match old.provides.to.value {
-                To::NewPackage(new_pkg) => Some(new_pkg),
-                To::ExistingPackage(_) => None,
-            },
-        }
-    })
-}
-
-#[inline(always)]
-fn package_header<'a>() -> impl Parser<'a, PackageHeader<'a>, EHeader<'a>> {
-    record!(PackageHeader {
-        before_exposes: space0_e(EHeader::IndentStart),
-        exposes: specialize_err(EHeader::Exposes, exposes_module_collection()),
-        before_packages: space0_e(EHeader::IndentStart),
-        packages: specialize_err(EHeader::Packages, loc(packages_collection())),
-    })
-    .trace("package_header")
-}
-
-#[derive(Debug, Clone, PartialEq)]
-struct OldPackageHeader<'a> {
-    before_name: &'a [CommentOrNewline<'a>],
-    exposes: KeywordItem<'a, ExposesKeyword, Collection<'a, Loc<Spaced<'a, ModuleName<'a>>>>>,
-    packages:
-        Loc<KeywordItem<'a, PackagesKeyword, Collection<'a, Loc<Spaced<'a, PackageEntry<'a>>>>>>,
-}
-
-#[inline(always)]
-fn old_package_header<'a>() -> impl Parser<'a, PackageHeader<'a>, EHeader<'a>> {
-    map_with_arena(
-        record!(OldPackageHeader {
-            before_name: skip_second(
-                space0_e(EHeader::IndentStart),
-                specialize_err(EHeader::PackageName, package_name())
-            ),
-            exposes: specialize_err(EHeader::Exposes, exposes_modules()),
-            packages: specialize_err(EHeader::Packages, loc(packages())),
-        }),
-        |arena: &'a bumpalo::Bump, old: OldPackageHeader<'a>| {
-            let before_exposes = merge_n_spaces!(
-                arena,
-                old.before_name,
-                old.exposes.keyword.before,
-                old.exposes.keyword.after
-            );
-            let before_packages = merge_spaces(
-                arena,
-                old.packages.value.keyword.before,
-                old.packages.value.keyword.after,
-            );
-
-            PackageHeader {
-                before_exposes,
-                exposes: old.exposes.item,
-                before_packages,
-                packages: old.packages.map(|kw| kw.item),
-            }
-        },
-    )
-    .trace("old_package_header")
-}
-
-#[inline(always)]
-fn platform_header<'a>() -> impl Parser<'a, PlatformHeader<'a>, EHeader<'a>> {
-    record!(PlatformHeader {
-        before_name: space0_e(EHeader::IndentStart),
-        name: loc(specialize_err(EHeader::PlatformName, package_name())),
-        requires: specialize_err(EHeader::Requires, requires()),
-        exposes: specialize_err(EHeader::Exposes, exposes_modules()),
-        packages: specialize_err(EHeader::Packages, packages()),
-        imports: specialize_err(EHeader::Imports, imports()),
-        provides: specialize_err(EHeader::Provides, provides_exposed()),
-    })
-    .trace("platform_header")
-}
-
-fn provides_to_package<'a>() -> impl Parser<'a, To<'a>, EProvides<'a>> {
-    one_of![
-        specialize_err(
-            |_, pos| EProvides::Identifier(pos),
-            map(lowercase_ident(), To::ExistingPackage)
-        ),
-        specialize_err(EProvides::Package, map(package_name(), To::NewPackage))
-    ]
-}
-
-#[inline(always)]
-fn provides_to<'a>() -> impl Parser<'a, ProvidesTo<'a>, EProvides<'a>> {
-    record!(ProvidesTo {
-        provides_keyword: spaces_around_keyword(
-            ProvidesKeyword,
-            EProvides::Provides,
-            EProvides::IndentProvides,
-            EProvides::IndentListStart
-        ),
-        entries: collection_trailing_sep_e(
-            byte(b'[', EProvides::ListStart),
-            exposes_entry(EProvides::Identifier),
-            byte(b',', EProvides::ListEnd),
-            byte(b']', EProvides::ListEnd),
-            Spaced::SpaceBefore
-        ),
-        types: optional(backtrackable(provides_types())),
-        to_keyword: spaces_around_keyword(
-            ToKeyword,
-            EProvides::To,
-            EProvides::IndentTo,
-            EProvides::IndentListStart
-        ),
-        to: loc(provides_to_package()),
-    })
-    .trace("provides_to")
-}
-
-fn provides_exposed<'a>() -> impl Parser<
-    'a,
-    KeywordItem<'a, ProvidesKeyword, Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>>,
-    EProvides<'a>,
-> {
-    record!(KeywordItem {
-        keyword: spaces_around_keyword(
-            ProvidesKeyword,
-            EProvides::Provides,
-            EProvides::IndentProvides,
-            EProvides::IndentListStart
-        ),
-        item: collection_trailing_sep_e(
-            byte(b'[', EProvides::ListStart),
-            exposes_entry(EProvides::Identifier),
-            byte(b',', EProvides::ListEnd),
-            byte(b']', EProvides::ListEnd),
-            Spaced::SpaceBefore
-        ),
-    })
-}
-
-#[inline(always)]
-fn provides_types<'a>(
-) -> impl Parser<'a, Collection<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>>, EProvides<'a>> {
-    skip_first(
-        // We only support spaces here, not newlines, because this is not intended
-        // to be the design forever. Someday it will hopefully work like Elm,
-        // where platform authors can provide functions like Browser.sandbox which
-        // present an API based on ordinary-looking type variables.
-        zero_or_more(byte(
-            b' ',
-            // HACK: If this errors, EProvides::Provides is not an accurate reflection
-            // of what went wrong. However, this is both skipped and zero_or_more,
-            // so this error should never be visible to anyone in practice!
-            EProvides::Provides,
-        )),
-        collection_trailing_sep_e(
-            byte(b'{', EProvides::ListStart),
-            provides_type_entry(EProvides::Identifier),
-            byte(b',', EProvides::ListEnd),
-            byte(b'}', EProvides::ListEnd),
-            Spaced::SpaceBefore,
-        ),
-    )
-}
-
-fn provides_type_entry<'a, F, E>(
-    to_expectation: F,
-) -> impl Parser<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>, E>
-where
-    F: Fn(Position) -> E,
-    F: Copy,
-    E: 'a,
-{
-    loc(map(
-        specialize_err(move |_, pos| to_expectation(pos), ident::uppercase()),
-        Spaced::Item,
-    ))
-}
-
-fn exposes_entry<'a, F, E>(
-    to_expectation: F,
-) -> impl Parser<'a, Loc<Spaced<'a, ExposedName<'a>>>, E>
-where
-    F: Fn(Position) -> E,
-    F: Copy,
-    E: 'a,
-{
-    loc(map(
-        specialize_err(move |_, pos| to_expectation(pos), unqualified_ident()),
-        |n| Spaced::Item(ExposedName::new(n)),
-    ))
-}
-
-#[inline(always)]
-fn requires<'a>(
-) -> impl Parser<'a, KeywordItem<'a, RequiresKeyword, PlatformRequires<'a>>, ERequires<'a>> {
-    record!(KeywordItem {
-        keyword: spaces_around_keyword(
-            RequiresKeyword,
-            ERequires::Requires,
-            ERequires::IndentRequires,
-            ERequires::IndentListStart
-        ),
-        item: platform_requires(),
-    })
-}
-
-#[inline(always)]
-fn platform_requires<'a>() -> impl Parser<'a, PlatformRequires<'a>, ERequires<'a>> {
-    record!(PlatformRequires {
-        rigids: skip_second(requires_rigids(), space0_e(ERequires::ListStart)),
-        signature: requires_typed_ident()
-    })
-}
-
-#[inline(always)]
-fn requires_rigids<'a>(
-) -> impl Parser<'a, Collection<'a, Loc<Spaced<'a, UppercaseIdent<'a>>>>, ERequires<'a>> {
-    collection_trailing_sep_e(
-        byte(b'{', ERequires::ListStart),
-        specialize_err(
-            |_, pos| ERequires::Rigid(pos),
-            loc(map(ident::uppercase(), Spaced::Item)),
-        ),
-        byte(b',', ERequires::ListEnd),
-        byte(b'}', ERequires::ListEnd),
-        Spaced::SpaceBefore,
-    )
-}
-
-#[inline(always)]
-fn requires_typed_ident<'a>() -> impl Parser<'a, Loc<Spaced<'a, TypedIdent<'a>>>, ERequires<'a>> {
-    skip_first(
-        byte(b'{', ERequires::ListStart),
-        skip_second(
-            reset_min_indent(space0_around_ee(
-                specialize_err(ERequires::TypedIdent, loc(typed_ident())),
-                ERequires::ListStart,
-                ERequires::ListEnd,
-            )),
-            byte(b'}', ERequires::ListStart),
-        ),
-    )
-}
-
-#[inline(always)]
-fn exposes_values_kw<'a>() -> impl Parser<
-    'a,
-    KeywordItem<'a, ExposesKeyword, Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>>,
-    EExposes,
-> {
-    record!(KeywordItem {
-        keyword: exposes_kw(),
-        item: exposes_list()
-    })
-}
-
-#[inline(always)]
-fn exposes_kw<'a>() -> impl Parser<'a, Spaces<'a, ExposesKeyword>, EExposes> {
-    spaces_around_keyword(
-        ExposesKeyword,
-        EExposes::Exposes,
-        EExposes::IndentExposes,
-        EExposes::IndentListStart,
-    )
-}
-
-#[inline(always)]
-fn exposes_list<'a>() -> impl Parser<'a, Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>, EExposes>
-{
-    collection_trailing_sep_e(
-        byte(b'[', EExposes::ListStart),
-        exposes_entry(EExposes::Identifier),
-        byte(b',', EExposes::ListEnd),
-        byte(b']', EExposes::ListEnd),
-        Spaced::SpaceBefore,
-    )
-}
-
-pub fn spaces_around_keyword<'a, K: Keyword, E>(
-    keyword_item: K,
-    expectation: fn(Position) -> E,
-    indent_problem1: fn(Position) -> E,
-    indent_problem2: fn(Position) -> E,
-) -> impl Parser<'a, Spaces<'a, K>, E>
-where
-    E: 'a + SpaceProblem,
-{
-    map(
-        and(
-            skip_second(
-                // parse any leading space before the keyword
-                backtrackable(space0_e(indent_problem1)),
-                // parse the keyword
-                crate::parser::keyword(K::KEYWORD, expectation),
-            ),
-            // parse the trailing space
-            space0_e(indent_problem2),
-        ),
-        move |(before, after)| Spaces {
-            before,
-            item: keyword_item,
-            after,
-        },
-    )
-}
-
-#[inline(always)]
-fn exposes_modules<'a>() -> impl Parser<
-    'a,
-    KeywordItem<'a, ExposesKeyword, Collection<'a, Loc<Spaced<'a, ModuleName<'a>>>>>,
-    EExposes,
-> {
-    record!(KeywordItem {
-        keyword: spaces_around_keyword(
-            ExposesKeyword,
-            EExposes::Exposes,
-            EExposes::IndentExposes,
-            EExposes::IndentListStart
-        ),
-        item: exposes_module_collection(),
-    })
-}
-
-fn exposes_module_collection<'a>(
-) -> impl Parser<'a, Collection<'a, Loc<Spaced<'a, ModuleName<'a>>>>, EExposes> {
-    collection_trailing_sep_e(
-        byte(b'[', EExposes::ListStart),
-        exposes_module(EExposes::Identifier),
-        byte(b',', EExposes::ListEnd),
-        byte(b']', EExposes::ListEnd),
-        Spaced::SpaceBefore,
-    )
-}
-
-fn exposes_module<'a, F, E>(
-    to_expectation: F,
-) -> impl Parser<'a, Loc<Spaced<'a, ModuleName<'a>>>, E>
-where
-    F: Fn(Position) -> E,
-    F: Copy,
-    E: 'a,
-{
-    loc(map(
-        specialize_err(move |_, pos| to_expectation(pos), module_name()),
-        Spaced::Item,
-    ))
-}
-
-#[inline(always)]
-fn packages<'a>() -> impl Parser<
-    'a,
-    KeywordItem<'a, PackagesKeyword, Collection<'a, Loc<Spaced<'a, PackageEntry<'a>>>>>,
-    EPackages<'a>,
-> {
-    record!(KeywordItem {
-        keyword: packages_kw(),
-        item: packages_collection()
-    })
-}
-
-#[inline(always)]
-fn packages_kw<'a>() -> impl Parser<'a, Spaces<'a, PackagesKeyword>, EPackages<'a>> {
-    spaces_around_keyword(
-        PackagesKeyword,
-        EPackages::Packages,
-        EPackages::IndentPackages,
-        EPackages::IndentListStart,
-    )
-}
-
-#[inline(always)]
-fn packages_collection<'a>(
-) -> impl Parser<'a, Collection<'a, Loc<Spaced<'a, PackageEntry<'a>>>>, EPackages<'a>> {
-    collection_trailing_sep_e(
-        byte(b'{', EPackages::ListStart),
-        specialize_err(EPackages::PackageEntry, loc(package_entry())),
-        byte(b',', EPackages::ListEnd),
-        byte(b'}', EPackages::ListEnd),
-        Spaced::SpaceBefore,
-    )
-}
-
-#[inline(always)]
-fn generates<'a>(
-) -> impl Parser<'a, KeywordItem<'a, GeneratesKeyword, UppercaseIdent<'a>>, EGenerates> {
-    record!(KeywordItem {
-        keyword: spaces_around_keyword(
-            GeneratesKeyword,
-            EGenerates::Generates,
-            EGenerates::IndentGenerates,
-            EGenerates::IndentTypeStart
-        ),
-        item: specialize_err(|(), pos| EGenerates::Identifier(pos), uppercase())
-    })
-}
-
-#[inline(always)]
-fn generates_with<'a>() -> impl Parser<
-    'a,
-    KeywordItem<'a, WithKeyword, Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>>,
-    EGeneratesWith,
-> {
-    record!(KeywordItem {
-        keyword: spaces_around_keyword(
-            WithKeyword,
-            EGeneratesWith::With,
-            EGeneratesWith::IndentWith,
-            EGeneratesWith::IndentListStart
-        ),
-        item: collection_trailing_sep_e(
-            byte(b'[', EGeneratesWith::ListStart),
-            exposes_entry(EGeneratesWith::Identifier),
-            byte(b',', EGeneratesWith::ListEnd),
-            byte(b']', EGeneratesWith::ListEnd),
-            Spaced::SpaceBefore
-        )
-    })
-}
-
-#[inline(always)]
-fn imports<'a>() -> impl Parser<
-    'a,
-    KeywordItem<'a, ImportsKeyword, Collection<'a, Loc<Spaced<'a, ImportsEntry<'a>>>>>,
-    EImports,
-> {
-    record!(KeywordItem {
-        keyword: spaces_around_keyword(
-            ImportsKeyword,
-            EImports::Imports,
-            EImports::IndentImports,
-            EImports::IndentListStart
-        ),
-        item: collection_trailing_sep_e(
-            byte(b'[', EImports::ListStart),
-            loc(imports_entry()),
-            byte(b',', EImports::ListEnd),
-            byte(b']', EImports::ListEnd),
-            Spaced::SpaceBefore
-        )
-    })
-    .trace("imports")
-}
-
-#[inline(always)]
-pub fn typed_ident<'a>() -> impl Parser<'a, Spaced<'a, TypedIdent<'a>>, ETypedIdent<'a>> {
-    // e.g.
-    //
-    // printLine : Str -> Effect {}
-    map(
-        and(
-            and(
-                loc(specialize_err(
-                    |_, pos| ETypedIdent::Identifier(pos),
-                    lowercase_ident(),
-                )),
-                space0_e(ETypedIdent::IndentHasType),
-            ),
-            skip_first(
-                byte(b':', ETypedIdent::HasType),
-                space0_before_e(
-                    specialize_err(
-                        ETypedIdent::Type,
-                        reset_min_indent(type_annotation::located(true)),
-                    ),
-                    ETypedIdent::IndentType,
-                ),
-            ),
-        ),
-        |((ident, spaces_before_colon), ann)| {
-            Spaced::Item(TypedIdent {
-                ident,
-                spaces_before_colon,
-                ann,
-            })
-        },
-    )
-}
-
-fn shortname<'a>() -> impl Parser<'a, &'a str, EImports> {
-    specialize_err(|_, pos| EImports::Shorthand(pos), lowercase_ident())
-}
-
-pub fn module_name_help<'a, F, E>(to_expectation: F) -> impl Parser<'a, ModuleName<'a>, E>
-where
-    F: Fn(Position) -> E,
-    E: 'a,
-    F: 'a,
-{
-    specialize_err(move |_, pos| to_expectation(pos), module_name())
-}
-
-#[inline(always)]
-fn imports_entry<'a>() -> impl Parser<'a, Spaced<'a, ImportsEntry<'a>>, EImports> {
-    type Temp<'a> = (
-        (Option<&'a str>, ModuleName<'a>),
-        Option<Collection<'a, Loc<Spaced<'a, ExposedName<'a>>>>>,
-    );
-
-    let spaced_import = |((opt_shortname, module_name), opt_values): Temp<'a>| {
-        let exposed_values = opt_values.unwrap_or_else(Collection::empty);
-
-        let entry = match opt_shortname {
-            Some(shortname) => ImportsEntry::Package(shortname, module_name, exposed_values),
-
-            None => ImportsEntry::Module(module_name, exposed_values),
-        };
-
-        Spaced::Item(entry)
-    };
-
-    one_of!(
-        map(
-            and(
-                and(
-                    // e.g. `pf.`
-                    optional(backtrackable(skip_second(
-                        shortname(),
-                        byte(b'.', EImports::ShorthandDot)
-                    ))),
-                    // e.g. `Task`
-                    module_name_help(EImports::ModuleName)
-                ),
-                // e.g. `.{ Task, after}`
-                optional(skip_first(
-                    byte(b'.', EImports::ExposingDot),
-                    collection_trailing_sep_e(
-                        byte(b'{', EImports::SetStart),
-                        exposes_entry(EImports::Identifier),
-                        byte(b',', EImports::SetEnd),
-                        byte(b'}', EImports::SetEnd),
-                        Spaced::SpaceBefore
-                    )
-                ))
-            ),
-            spaced_import
-        )
-        .trace("normal_import"),
-        map(
-            and(
-                and(
-                    // e.g. "filename"
-                    // TODO: str literal allows for multiline strings. We probably don't want that for file names.
-                    specialize_err(|_, pos| EImports::StrLiteral(pos), parse_str_literal()),
-                    // e.g. as
-                    and(
-                        and(
-                            space0_e(EImports::AsKeyword),
-                            two_bytes(b'a', b's', EImports::AsKeyword)
-                        ),
-                        space0_e(EImports::AsKeyword)
-                    )
-                ),
-                // e.g. file : Str
-                specialize_err(|_, pos| EImports::TypedIdent(pos), typed_ident())
-            ),
-            |((file_name, _), typed_ident)| {
-                // TODO: look at blacking block strings during parsing.
-                Spaced::Item(ImportsEntry::IngestedFile(file_name, typed_ident))
-            }
-        )
-        .trace("ingest_file_import")
-    )
-    .trace("imports_entry")
-}

crates/compiler/parse/src/parser.rs

@@ -372,9 +372,11 @@ pub enum EExpr<'a> {
 
     InParens(EInParens<'a>, Position),
     Record(ERecord<'a>, Position),
-    OptionalValueInRecordBuilder(Region),
-    RecordUpdateAccumulator(Region),
-    RecordBuilderAccumulator(Region),
+    OptionalValueInOldRecordBuilder(Region),
+    IgnoredValueInOldRecordBuilder(Region),
+    RecordUpdateOldBuilderField(Region),
+    RecordUpdateIgnoredField(Region),
+    RecordBuilderOldBuilderField(Region),
 
     // SingleQuote errors are folded into the EString
     Str(EString<'a>, Position),
@@ -428,6 +430,7 @@ pub enum ERecord<'a> {
 
     Prefix(Position),
     Field(Position),
+    UnderscoreField(Position),
     Colon(Position),
     QuestionMark(Position),
     Arrow(Position),
@@ -577,6 +580,7 @@ pub enum EImportParams<'a> {
     RecordUpdateFound(Region),
     RecordBuilderFound(Region),
     RecordApplyFound(Region),
+    RecordIgnoredFieldFound(Region),
     Space(BadInputError, Position),
 }
 
@@ -735,6 +739,7 @@ pub enum ETypeAbilityImpl<'a> {
     Open(Position),
 
     Field(Position),
+    UnderscoreField(Position),
     Colon(Position),
     Arrow(Position),
     Optional(Position),
@@ -756,6 +761,7 @@ impl<'a> From<ERecord<'a>> for ETypeAbilityImpl<'a> {
             ERecord::End(p) => ETypeAbilityImpl::End(p),
             ERecord::Open(p) => ETypeAbilityImpl::Open(p),
             ERecord::Field(p) => ETypeAbilityImpl::Field(p),
+            ERecord::UnderscoreField(p) => ETypeAbilityImpl::UnderscoreField(p),
             ERecord::Colon(p) => ETypeAbilityImpl::Colon(p),
             ERecord::Arrow(p) => ETypeAbilityImpl::Arrow(p),
             ERecord::Space(s, p) => ETypeAbilityImpl::Space(s, p),

crates/compiler/parse/src/pattern.rs

@@ -25,6 +25,7 @@ pub enum PatternType {
     DefExpr,
     FunctionArg,
     WhenBranch,
+    ModuleParams,
 }
 
 pub fn closure_param<'a>() -> impl Parser<'a, Loc<Pattern<'a>>, EPattern<'a>> {

crates/compiler/parse/src/test_helpers.rs

@@ -1,6 +1,8 @@
 use crate::ast;
 use crate::ast::Defs;
-use crate::module::parse_module_defs;
+use crate::ast::Header;
+use crate::ast::SpacesBefore;
+use crate::header::parse_module_defs;
 use crate::parser::SourceError;
 use crate::parser::SyntaxError;
 use crate::state::State;
@@ -39,10 +41,10 @@ pub fn parse_defs_with<'a>(arena: &'a Bump, input: &'a str) -> Result<Defs<'a>,
 pub fn parse_header_with<'a>(
     arena: &'a Bump,
     input: &'a str,
-) -> Result<ast::Module<'a>, SyntaxError<'a>> {
+) -> Result<SpacesBefore<'a, Header<'a>>, SyntaxError<'a>> {
     let state = State::new(input.as_bytes());
 
-    match crate::module::parse_header(arena, state.clone()) {
+    match crate::header::parse_header(arena, state.clone()) {
         Ok((header, _)) => Ok(header),
         Err(fail) => Err(SyntaxError::Header(fail.problem)),
     }

crates/compiler/parse/src/type_annotation.rs

@@ -565,6 +565,9 @@ fn parse_implements_ability<'a>() -> impl Parser<'a, ImplementsAbility<'a>, ETyp
 fn ability_impl_field<'a>() -> impl Parser<'a, AssignedField<'a, Expr<'a>>, ERecord<'a>> {
     then(record_field(), move |arena, state, _, field| {
         match field.to_assigned_field(arena) {
+            Ok(AssignedField::IgnoredValue(_, _, _)) => {
+                Err((MadeProgress, ERecord::Field(state.pos())))
+            }
             Ok(assigned_field) => Ok((MadeProgress, assigned_field, state)),
             Err(FoundApplyValue) => Err((MadeProgress, ERecord::Field(state.pos()))),
         }

crates/compiler/parse/tests/test_parse.rs

@@ -22,7 +22,7 @@ mod test_parse {
     use roc_parse::ast::StrSegment::*;
     use roc_parse::ast::{self, EscapedChar};
     use roc_parse::ast::{CommentOrNewline, StrLiteral::*};
-    use roc_parse::module::parse_module_defs;
+    use roc_parse::header::parse_module_defs;
     use roc_parse::parser::SyntaxError;
     use roc_parse::state::State;
     use roc_parse::test_helpers::parse_expr_with;

crates/compiler/problem/src/can.rs

@@ -4,7 +4,7 @@ use std::path::PathBuf;
 use roc_collections::all::MutSet;
 use roc_module::called_via::BinOp;
 use roc_module::ident::{Ident, Lowercase, ModuleName, TagName};
-use roc_module::symbol::{ModuleId, ScopeModuleSource, Symbol};
+use roc_module::symbol::{ModuleId, Symbol};
 use roc_parse::ast::Base;
 use roc_parse::pattern::PatternType;
 use roc_region::all::{Loc, Region};
@@ -238,6 +238,13 @@ pub enum Problem {
     },
 }
 
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ScopeModuleSource {
+    Builtin,
+    Current,
+    Import(Region),
+}
+
 impl Problem {
     pub fn severity(&self) -> Severity {
         use Severity::{Fatal, RuntimeError, Warning};

crates/compiler/solve/src/module.rs

@@ -80,6 +80,10 @@ pub struct SolveConfig<'a> {
     #[cfg(debug_assertions)]
     /// The checkmate collector for this module.
     pub checkmate: Option<roc_checkmate::Collector>,
+
+    /// Module params
+    pub params_pattern: Option<roc_can::pattern::Pattern>,
+    pub module_params_vars: VecMap<ModuleId, Variable>,
 }
 
 pub struct SolveOutput {
@@ -144,6 +148,7 @@ pub fn exposed_types_storage_subs(
     home: ModuleId,
     solved_subs: &mut Solved<Subs>,
     exposed_vars_by_symbol: &[(Symbol, Variable)],
+    params_var: Option<Variable>,
     solved_implementations: &ResolvedImplementations,
     abilities_store: &AbilitiesStore,
 ) -> ExposedTypesStorageSubs {
@@ -156,6 +161,9 @@ pub fn exposed_types_storage_subs(
         stored_vars_by_symbol.insert(*symbol, new_var);
     }
 
+    let stored_params_var =
+        params_var.map(|params_var| storage_subs.import_variable_from(subs, params_var).variable);
+
     let mut stored_specialization_lambda_set_vars =
         VecMap::with_capacity(solved_implementations.len());
 
@@ -213,6 +221,7 @@ pub fn exposed_types_storage_subs(
         stored_vars_by_symbol,
         stored_specialization_lambda_set_vars,
         stored_ability_member_vars,
+        stored_params_var,
     }
 }
 

crates/compiler/solve/src/solve.rs

@@ -16,11 +16,12 @@ use roc_can::abilities::{AbilitiesStore, MemberSpecializationInfo};
 use roc_can::constraint::Constraint::{self, *};
 use roc_can::constraint::{Cycle, LetConstraint, OpportunisticResolve};
 use roc_can::expected::{Expected, PExpected};
+use roc_collections::VecMap;
 use roc_debug_flags::dbg_do;
 #[cfg(debug_assertions)]
 use roc_debug_flags::ROC_VERIFY_RIGID_LET_GENERALIZED;
 use roc_error_macros::internal_error;
-use roc_module::symbol::Symbol;
+use roc_module::symbol::{ModuleId, Symbol};
 use roc_problem::can::CycleEntry;
 use roc_region::all::Loc;
 use roc_solve_problem::TypeError;
@@ -129,15 +130,13 @@ fn run_help(
         exposed_by_module,
         derived_module,
         function_kind,
+        params_pattern,
+        module_params_vars,
         ..
     } = config;
 
     let mut pools = Pools::default();
 
-    let state = State {
-        scope: Scope::default(),
-        mark: Mark::NONE.next(),
-    };
     let rank = Rank::toplevel();
     let arena = Bump::new();
 
@@ -178,7 +177,6 @@ fn run_help(
     let state = solve(
         &mut env,
         types,
-        state,
         rank,
         problems,
         aliases,
@@ -186,6 +184,8 @@ fn run_help(
         abilities_store,
         &mut obligation_cache,
         &mut awaiting_specializations,
+        params_pattern,
+        module_params_vars,
     );
 
     RunSolveOutput {
@@ -236,7 +236,6 @@ enum Work<'a> {
 fn solve(
     env: &mut InferenceEnv,
     mut can_types: Types,
-    mut state: State,
     rank: Rank,
     problems: &mut Vec<TypeError>,
     aliases: &mut Aliases,
@@ -244,15 +243,24 @@ fn solve(
     abilities_store: &mut AbilitiesStore,
     obligation_cache: &mut ObligationCache,
     awaiting_specializations: &mut AwaitingSpecializations,
+    params_pattern: Option<roc_can::pattern::Pattern>,
+    module_params_vars: VecMap<ModuleId, Variable>,
 ) -> State {
+    let scope = Scope::new(params_pattern);
+
     let initial = Work::Constraint {
-        scope: &Scope::default(),
+        scope: &scope.clone(),
         rank,
         constraint,
     };
 
     let mut stack = vec![initial];
 
+    let mut state = State {
+        scope,
+        mark: Mark::NONE.next(),
+    };
+
     while let Some(work_item) = stack.pop() {
         let (scope, rank, constraint) = match work_item {
             Work::Constraint {
@@ -1392,6 +1400,86 @@ fn solve(
                     }
                 }
             }
+            ImportParams(opt_provided, module_id, region) => {
+                match (module_params_vars.get(module_id), opt_provided) {
+                    (Some(expected), Some(provided)) => {
+                        let actual = either_type_index_to_var(
+                            env,
+                            rank,
+                            problems,
+                            abilities_store,
+                            obligation_cache,
+                            &mut can_types,
+                            aliases,
+                            *provided,
+                        );
+
+                        match unify(
+                            &mut env.uenv(),
+                            actual,
+                            *expected,
+                            UnificationMode::EQ,
+                            Polarity::OF_VALUE,
+                        ) {
+                            Success {
+                                vars,
+                                must_implement_ability,
+                                lambda_sets_to_specialize,
+                                extra_metadata: _,
+                            } => {
+                                env.introduce(rank, &vars);
+
+                                problems.extend(obligation_cache.check_obligations(
+                                    env.subs,
+                                    abilities_store,
+                                    must_implement_ability,
+                                    AbilityImplError::DoesNotImplement,
+                                ));
+                                compact_lambdas_and_check_obligations(
+                                    env,
+                                    problems,
+                                    abilities_store,
+                                    obligation_cache,
+                                    awaiting_specializations,
+                                    lambda_sets_to_specialize,
+                                );
+
+                                state
+                            }
+
+                            Failure(vars, actual_type, expected_type, _) => {
+                                env.introduce(rank, &vars);
+
+                                problems.push(TypeError::ModuleParamsMismatch(
+                                    *region,
+                                    *module_id,
+                                    actual_type,
+                                    expected_type,
+                                ));
+
+                                state
+                            }
+                        }
+                    }
+                    (Some(expected), None) => {
+                        let expected_type = env.uenv().var_to_error_type(*expected, Polarity::Neg);
+
+                        problems.push(TypeError::MissingModuleParams(
+                            *region,
+                            *module_id,
+                            expected_type,
+                        ));
+
+                        state
+                    }
+                    (None, Some(_)) => {
+                        problems.push(TypeError::UnexpectedModuleParams(*region, *module_id));
+
+                        state
+                    }
+                    (None, None) => state,
+                }
+            }
         };
     }
 

crates/compiler/solve/src/solve/scope.rs

@@ -2,13 +2,43 @@ use roc_module::symbol::Symbol;
 use roc_types::subs::Variable;
 
 /// The scope of the solver, as symbols are introduced.
-#[derive(Clone, Debug, Default)]
+#[derive(Clone, Debug)]
 pub struct Scope {
     symbols: Vec<Symbol>,
     variables: Vec<Variable>,
 }
 
 impl Scope {
+    pub fn new(params_pattern: Option<roc_can::pattern::Pattern>) -> Self {
+        match params_pattern {
+            Some(params_pattern) => match params_pattern {
+                roc_can::pattern::Pattern::RecordDestructure {
+                    whole_var: _,
+                    ext_var: _,
+                    destructs,
+                } => {
+                    let mut symbols = Vec::with_capacity(destructs.len());
+                    let mut variables = Vec::with_capacity(destructs.len());
+
+                    for destruct in destructs {
+                        symbols.push(destruct.value.symbol);
+                        variables.push(destruct.value.var);
+                    }
+
+                    Self { symbols, variables }
+                }
+                _ => unreachable!(
+                    "other pattern types should have parsed: {:?}",
+                    params_pattern
+                ),
+            },
+            None => Self {
+                symbols: Vec::default(),
+                variables: Vec::default(),
+            },
+        }
+    }
+
     pub fn vars_by_symbol(&self) -> impl Iterator<Item = (Symbol, Variable)> + '_ {
         let it1 = self.symbols.iter().copied();
         let it2 = self.variables.iter().copied();

crates/compiler/solve_problem/src/lib.rs

@@ -2,7 +2,10 @@
 use std::{path::PathBuf, str::Utf8Error};
 
 use roc_can::expected::{Expected, PExpected};
-use roc_module::{ident::Lowercase, symbol::Symbol};
+use roc_module::{
+    ident::Lowercase,
+    symbol::{ModuleId, Symbol},
+};
 use roc_problem::{can::CycleEntry, Severity};
 use roc_region::all::Region;
 
@@ -33,6 +36,9 @@ pub enum TypeError {
     },
     IngestedFileBadUtf8(Box<PathBuf>, Utf8Error),
     IngestedFileUnsupportedType(Box<PathBuf>, ErrorType),
+    UnexpectedModuleParams(Region, ModuleId),
+    MissingModuleParams(Region, ModuleId, ErrorType),
+    ModuleParamsMismatch(Region, ModuleId, ErrorType, ErrorType),
 }
 
 impl TypeError {
@@ -52,6 +58,9 @@ impl TypeError {
             TypeError::Exhaustive(exhtv) => exhtv.severity(),
             TypeError::StructuralSpecialization { .. } => RuntimeError,
             TypeError::WrongSpecialization { .. } => RuntimeError,
+            TypeError::UnexpectedModuleParams(..) => Warning,
+            TypeError::MissingModuleParams(..) => RuntimeError,
+            TypeError::ModuleParamsMismatch(..) => RuntimeError,
             TypeError::IngestedFileBadUtf8(..) => Fatal,
             TypeError::IngestedFileUnsupportedType(..) => Fatal,
         }
@@ -66,7 +75,10 @@ impl TypeError {
             | TypeError::BadExprMissingAbility(region, ..)
             | TypeError::StructuralSpecialization { region, .. }
             | TypeError::WrongSpecialization { region, .. }
-            | TypeError::BadPatternMissingAbility(region, ..) => Some(*region),
+            | TypeError::BadPatternMissingAbility(region, ..)
+            | TypeError::UnexpectedModuleParams(region, ..)
+            | TypeError::MissingModuleParams(region, ..)
+            | TypeError::ModuleParamsMismatch(region, ..) => Some(*region),
             TypeError::UnfulfilledAbility(ab, ..) => ab.region(),
             TypeError::Exhaustive(e) => Some(e.region()),
             TypeError::CircularDef(c) => c.first().map(|ce| ce.symbol_region),

crates/compiler/test_derive/src/util.rs

@@ -405,7 +405,7 @@ fn check_derived_typechecks_and_golden(
     let mut def_types = Default::default();
     let mut rigid_vars = Default::default();
     let mut flex_vars = Default::default();
-    let (import_variables, abilities_store) = add_imports(
+    let (import_variables, imported_param_vars, abilities_store) = add_imports(
         test_module,
         &mut constraints,
         &mut test_subs,
@@ -438,6 +438,8 @@ fn check_derived_typechecks_and_golden(
         pending_derives: Default::default(),
         exposed_by_module: &exposed_for_module.exposed_by_module,
         derived_module: Default::default(),
+        params_pattern: None,
+        module_params_vars: imported_param_vars,
 
         #[cfg(debug_assertions)]
         checkmate: None,

crates/compiler/test_gen/src/gen_result.rs

@@ -354,3 +354,85 @@ fn roc_result_after_err() {
         RocResult<RocStr, i64>
     );
 }
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn roc_result_map_both() {
+    assert_evals_to!(
+        indoc!(
+            r#"
+            result : Result I64 I64
+            result = Ok 42
+
+            result |> Result.mapBoth Num.toStr Num.toStr
+            "#
+        ),
+        RocResult::ok(RocStr::from("42")),
+        RocResult<RocStr, RocStr>
+    );
+
+    assert_evals_to!(
+        indoc!(
+            r#"
+            result : Result I64 I64
+            result = Err 24
+
+            result |> Result.mapBoth Num.toStr Num.toStr
+            "#
+        ),
+        RocResult::err(RocStr::from("24")),
+        RocResult<RocStr, RocStr>
+    );
+}
+
+#[test]
+#[cfg(any(feature = "gen-llvm", feature = "gen-wasm", feature = "gen-dev"))]
+fn roc_result_map_two() {
+    assert_evals_to!(
+        indoc!(
+            r#"
+            first : Result I64 Str
+            first = Ok 24
+
+            second : Result I64 Str
+            second = Ok -10
+
+            Result.map2 first second \a, b -> a + b
+            "#
+        ),
+        RocResult::ok(14i64),
+        RocResult<i64, RocStr>
+    );
+
+    assert_evals_to!(
+        indoc!(
+            r#"
+            first : Result I64 Str
+            first = Err "foo"
+
+            second : Result I64 Str
+            second = Err "bar"
+
+            Result.map2 first second \a, b -> a + b
+            "#
+        ),
+        RocResult::err(RocStr::from("foo")),
+        RocResult<i64, RocStr>
+    );
+
+    assert_evals_to!(
+        indoc!(
+            r#"
+            first : Result I64 Str
+            first = Ok 42
+
+            second : Result I64 Str
+            second = Err "bar"
+
+            Result.map2 first second \a, b -> a + b
+            "#
+        ),
+        RocResult::err(RocStr::from("bar")),
+        RocResult<i64, RocStr>
+    );
+}

crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt

@@ -2,93 +2,93 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.23;
 
-procedure List.107 (List.536, List.537, List.538):
-    let List.640 : U64 = 0i64;
-    let List.641 : U64 = CallByName List.6 List.536;
-    let List.639 : [C U64, C U64] = CallByName List.80 List.536 List.537 List.538 List.640 List.641;
-    ret List.639;
+procedure List.110 (List.539, List.540, List.541):
+    let List.643 : U64 = 0i64;
+    let List.644 : U64 = CallByName List.6 List.539;
+    let List.642 : [C U64, C U64] = CallByName List.80 List.539 List.540 List.541 List.643 List.644;
+    ret List.642;
 
-procedure List.26 (List.204, List.205, List.206):
-    let List.633 : [C U64, C U64] = CallByName List.107 List.204 List.205 List.206;
-    let List.636 : U8 = 1i64;
-    let List.637 : U8 = GetTagId List.633;
-    let List.638 : Int1 = lowlevel Eq List.636 List.637;
-    if List.638 then
-        let List.207 : U64 = UnionAtIndex (Id 1) (Index 0) List.633;
-        ret List.207;
+procedure List.26 (List.207, List.208, List.209):
+    let List.636 : [C U64, C U64] = CallByName List.110 List.207 List.208 List.209;
+    let List.639 : U8 = 1i64;
+    let List.640 : U8 = GetTagId List.636;
+    let List.641 : Int1 = lowlevel Eq List.639 List.640;
+    if List.641 then
+        let List.210 : U64 = UnionAtIndex (Id 1) (Index 0) List.636;
+        ret List.210;
     else
-        let List.208 : U64 = UnionAtIndex (Id 0) (Index 0) List.633;
-        ret List.208;
+        let List.211 : U64 = UnionAtIndex (Id 0) (Index 0) List.636;
+        ret List.211;
 
-procedure List.38 (List.392, List.393):
-    let List.632 : U64 = CallByName List.6 List.392;
-    let List.394 : U64 = CallByName Num.77 List.632 List.393;
-    let List.622 : List U8 = CallByName List.43 List.392 List.394;
-    ret List.622;
-
-procedure List.43 (List.390, List.391):
-    let List.630 : U64 = CallByName List.6 List.390;
-    let List.629 : U64 = CallByName Num.77 List.630 List.391;
-    let List.624 : {U64, U64} = Struct {List.391, List.629};
-    let List.623 : List U8 = CallByName List.49 List.390 List.624;
-    ret List.623;
-
-procedure List.49 (List.468, List.469):
-    let List.626 : U64 = StructAtIndex 1 List.469;
-    let List.627 : U64 = StructAtIndex 0 List.469;
-    let List.625 : List U8 = CallByName List.72 List.468 List.626 List.627;
+procedure List.38 (List.395, List.396):
+    let List.635 : U64 = CallByName List.6 List.395;
+    let List.397 : U64 = CallByName Num.77 List.635 List.396;
+    let List.625 : List U8 = CallByName List.43 List.395 List.397;
     ret List.625;
 
-procedure List.6 (#Attr.2):
-    let List.631 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.631;
+procedure List.43 (List.393, List.394):
+    let List.633 : U64 = CallByName List.6 List.393;
+    let List.632 : U64 = CallByName Num.77 List.633 List.394;
+    let List.627 : {U64, U64} = Struct {List.394, List.632};
+    let List.626 : List U8 = CallByName List.49 List.393 List.627;
+    ret List.626;
 
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.654 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.654;
-
-procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
-    let List.628 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+procedure List.49 (List.471, List.472):
+    let List.629 : U64 = StructAtIndex 1 List.472;
+    let List.630 : U64 = StructAtIndex 0 List.472;
+    let List.628 : List U8 = CallByName List.72 List.471 List.629 List.630;
     ret List.628;
 
+procedure List.6 (#Attr.2):
+    let List.634 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.634;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.657 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.657;
+
+procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
+    let List.631 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
+    ret List.631;
+
 procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.642 List.539 List.540 List.541 List.542 List.543:
-        let List.644 : Int1 = CallByName Num.22 List.542 List.543;
-        if List.644 then
-            let List.653 : U8 = CallByName List.66 List.539 List.542;
-            let List.645 : [C U64, C U64] = CallByName Test.4 List.540 List.653;
-            let List.650 : U8 = 1i64;
-            let List.651 : U8 = GetTagId List.645;
-            let List.652 : Int1 = lowlevel Eq List.650 List.651;
-            if List.652 then
-                let List.544 : U64 = UnionAtIndex (Id 1) (Index 0) List.645;
-                let List.648 : U64 = 1i64;
-                let List.647 : U64 = CallByName Num.51 List.542 List.648;
-                jump List.642 List.539 List.544 List.541 List.647 List.543;
+    joinpoint List.645 List.542 List.543 List.544 List.545 List.546:
+        let List.647 : Int1 = CallByName Num.22 List.545 List.546;
+        if List.647 then
+            let List.656 : U8 = CallByName List.66 List.542 List.545;
+            let List.648 : [C U64, C U64] = CallByName Test.4 List.543 List.656;
+            let List.653 : U8 = 1i64;
+            let List.654 : U8 = GetTagId List.648;
+            let List.655 : Int1 = lowlevel Eq List.653 List.654;
+            if List.655 then
+                let List.547 : U64 = UnionAtIndex (Id 1) (Index 0) List.648;
+                let List.651 : U64 = 1i64;
+                let List.650 : U64 = CallByName Num.51 List.545 List.651;
+                jump List.645 List.542 List.547 List.544 List.650 List.546;
             else
-                dec List.539;
-                let List.545 : U64 = UnionAtIndex (Id 0) (Index 0) List.645;
-                let List.649 : [C U64, C U64] = TagId(0) List.545;
-                ret List.649;
+                dec List.542;
+                let List.548 : U64 = UnionAtIndex (Id 0) (Index 0) List.648;
+                let List.652 : [C U64, C U64] = TagId(0) List.548;
+                ret List.652;
         else
-            dec List.539;
-            let List.643 : [C U64, C U64] = TagId(1) List.540;
-            ret List.643;
+            dec List.542;
+            let List.646 : [C U64, C U64] = TagId(1) List.543;
+            ret List.646;
     in
     inc #Derived_gen.0;
-    jump List.642 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.645 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.77 (#Attr.2, #Attr.3):
-    let Num.280 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
+    ret Num.282;
 
 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.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
 
 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

@@ -1,59 +1,59 @@
-procedure List.18 (List.163, List.164, List.165):
-    let List.626 : U64 = 0i64;
-    let List.627 : U64 = CallByName List.6 List.163;
-    let List.625 : List {} = CallByName List.92 List.163 List.164 List.165 List.626 List.627;
-    ret List.625;
+procedure List.18 (List.166, List.167, List.168):
+    let List.629 : U64 = 0i64;
+    let List.630 : U64 = CallByName List.6 List.166;
+    let List.628 : List {} = CallByName List.95 List.166 List.167 List.168 List.629 List.630;
+    ret List.628;
 
-procedure List.275 (List.276, List.277, List.273):
-    let List.639 : {} = CallByName Test.2 List.277;
-    let List.638 : List {} = CallByName List.71 List.276 List.639;
-    ret List.638;
-
-procedure List.5 (List.272, List.273):
-    let List.274 : U64 = CallByName List.6 List.272;
-    let List.623 : List {} = CallByName List.68 List.274;
-    let List.622 : List {} = CallByName List.18 List.272 List.623 List.273;
-    ret List.622;
-
-procedure List.6 (#Attr.2):
-    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.636;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.635 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.635;
-
-procedure List.68 (#Attr.2):
-    let List.641 : List {} = lowlevel ListWithCapacity #Attr.2;
+procedure List.278 (List.279, List.280, List.276):
+    let List.642 : {} = CallByName Test.2 List.280;
+    let List.641 : List {} = CallByName List.71 List.279 List.642;
     ret List.641;
 
-procedure List.71 (#Attr.2, #Attr.3):
-    let List.640 : List {} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.640;
+procedure List.5 (List.275, List.276):
+    let List.277 : U64 = CallByName List.6 List.275;
+    let List.626 : List {} = CallByName List.68 List.277;
+    let List.625 : List {} = CallByName List.18 List.275 List.626 List.276;
+    ret List.625;
 
-procedure List.92 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
-    joinpoint List.628 List.166 List.167 List.168 List.169 List.170:
-        let List.630 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.630 then
-            let List.634 : [] = CallByName List.66 List.166 List.169;
-            let List.171 : List {} = CallByName List.275 List.167 List.634 List.168;
-            let List.633 : U64 = 1i64;
-            let List.632 : U64 = CallByName Num.51 List.169 List.633;
-            jump List.628 List.166 List.171 List.168 List.632 List.170;
+procedure List.6 (#Attr.2):
+    let List.639 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.639;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.638 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.638;
+
+procedure List.68 (#Attr.2):
+    let List.644 : List {} = lowlevel ListWithCapacity #Attr.2;
+    ret List.644;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.643 : List {} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.643;
+
+procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+    joinpoint List.631 List.169 List.170 List.171 List.172 List.173:
+        let List.633 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.633 then
+            let List.637 : [] = CallByName List.66 List.169 List.172;
+            let List.174 : List {} = CallByName List.278 List.170 List.637 List.171;
+            let List.636 : U64 = 1i64;
+            let List.635 : U64 = CallByName Num.51 List.172 List.636;
+            jump List.631 List.169 List.174 List.171 List.635 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.3;
-    jump List.628 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+    inc #Derived_gen.0;
+    jump List.631 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Test.2 (Test.3):
     let Test.7 : {} = Struct {};

crates/compiler/test_mono/generated/call_function_in_empty_list_unbound.txt

@@ -1,59 +1,59 @@
-procedure List.18 (List.163, List.164, List.165):
-    let List.626 : U64 = 0i64;
-    let List.627 : U64 = CallByName List.6 List.163;
-    let List.625 : List [] = CallByName List.92 List.163 List.164 List.165 List.626 List.627;
-    ret List.625;
+procedure List.18 (List.166, List.167, List.168):
+    let List.629 : U64 = 0i64;
+    let List.630 : U64 = CallByName List.6 List.166;
+    let List.628 : List [] = CallByName List.95 List.166 List.167 List.168 List.629 List.630;
+    ret List.628;
 
-procedure List.275 (List.276, List.277, List.273):
-    let List.639 : [] = CallByName Test.2 List.277;
-    let List.638 : List [] = CallByName List.71 List.276 List.639;
-    ret List.638;
-
-procedure List.5 (List.272, List.273):
-    let List.274 : U64 = CallByName List.6 List.272;
-    let List.623 : List [] = CallByName List.68 List.274;
-    let List.622 : List [] = CallByName List.18 List.272 List.623 List.273;
-    ret List.622;
-
-procedure List.6 (#Attr.2):
-    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.636;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.635 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.635;
-
-procedure List.68 (#Attr.2):
-    let List.641 : List [] = lowlevel ListWithCapacity #Attr.2;
+procedure List.278 (List.279, List.280, List.276):
+    let List.642 : [] = CallByName Test.2 List.280;
+    let List.641 : List [] = CallByName List.71 List.279 List.642;
     ret List.641;
 
-procedure List.71 (#Attr.2, #Attr.3):
-    let List.640 : List [] = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.640;
+procedure List.5 (List.275, List.276):
+    let List.277 : U64 = CallByName List.6 List.275;
+    let List.626 : List [] = CallByName List.68 List.277;
+    let List.625 : List [] = CallByName List.18 List.275 List.626 List.276;
+    ret List.625;
 
-procedure List.92 (#Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
-    joinpoint List.628 List.166 List.167 List.168 List.169 List.170:
-        let List.630 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.630 then
-            let List.634 : [] = CallByName List.66 List.166 List.169;
-            let List.171 : List [] = CallByName List.275 List.167 List.634 List.168;
-            let List.633 : U64 = 1i64;
-            let List.632 : U64 = CallByName Num.51 List.169 List.633;
-            jump List.628 List.166 List.171 List.168 List.632 List.170;
+procedure List.6 (#Attr.2):
+    let List.639 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.639;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.638 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.638;
+
+procedure List.68 (#Attr.2):
+    let List.644 : List [] = lowlevel ListWithCapacity #Attr.2;
+    ret List.644;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.643 : List [] = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.643;
+
+procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+    joinpoint List.631 List.169 List.170 List.171 List.172 List.173:
+        let List.633 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.633 then
+            let List.637 : [] = CallByName List.66 List.169 List.172;
+            let List.174 : List [] = CallByName List.278 List.170 List.637 List.171;
+            let List.636 : U64 = 1i64;
+            let List.635 : U64 = CallByName Num.51 List.172 List.636;
+            jump List.631 List.169 List.174 List.171 List.635 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.3;
-    jump List.628 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+    inc #Derived_gen.0;
+    jump List.631 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Test.2 (Test.3):
     let Test.7 : {} = Struct {};

crates/compiler/test_mono/generated/capture_void_layout_task.txt

@@ -1,40 +1,40 @@
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : [<r>C {}, C *self {{}, []}] = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : [<r>C {}, C *self {{}, []}] = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : [] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
-procedure List.92 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : [] = CallByName List.66 List.166 List.169;
-            let List.171 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.167 List.631 List.168;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : [] = CallByName List.66 List.169 List.172;
+            let List.174 : [<r>C {}, C *self {{}, []}] = CallByName Test.29 List.170 List.634 List.171;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.11;
-    jump List.625 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
+    inc #Derived_gen.13;
+    jump List.628 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 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

@@ -2,112 +2,112 @@ procedure Bool.1 ():
     let Bool.24 : Int1 = false;
     ret Bool.24;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.642 : U64 = 0i64;
-    let List.643 : U64 = CallByName List.6 List.163;
-    let List.641 : List Str = CallByName List.92 List.163 List.164 List.165 List.642 List.643;
-    ret List.641;
+procedure List.18 (List.166, List.167, List.168):
+    let List.645 : U64 = 0i64;
+    let List.646 : U64 = CallByName List.6 List.166;
+    let List.644 : List Str = CallByName List.95 List.166 List.167 List.168 List.645 List.646;
+    ret List.644;
 
-procedure List.2 (List.111, List.112):
-    let List.636 : U64 = CallByName List.6 List.111;
-    let List.632 : Int1 = CallByName Num.22 List.112 List.636;
-    if List.632 then
-        let List.634 : Str = CallByName List.66 List.111 List.112;
-        inc List.634;
-        let List.633 : [C {}, C Str] = TagId(1) List.634;
-        ret List.633;
+procedure List.2 (List.114, List.115):
+    let List.639 : U64 = CallByName List.6 List.114;
+    let List.635 : Int1 = CallByName Num.22 List.115 List.639;
+    if List.635 then
+        let List.637 : Str = CallByName List.66 List.114 List.115;
+        inc List.637;
+        let List.636 : [C {}, C Str] = TagId(1) List.637;
+        ret List.636;
     else
-        let List.631 : {} = Struct {};
-        let List.630 : [C {}, C Str] = TagId(0) List.631;
-        ret List.630;
+        let List.634 : {} = Struct {};
+        let List.633 : [C {}, C Str] = TagId(0) List.634;
+        ret List.633;
 
-procedure List.275 (List.276, List.277, List.273):
-    let List.655 : Str = CallByName Test.10 List.277;
-    let List.654 : List Str = CallByName List.71 List.276 List.655;
-    ret List.654;
-
-procedure List.5 (List.272, List.273):
-    let List.274 : U64 = CallByName List.6 List.272;
-    let List.639 : List Str = CallByName List.68 List.274;
-    let List.638 : List Str = CallByName List.18 List.272 List.639 List.273;
-    ret List.638;
-
-procedure List.6 (#Attr.2):
-    let List.637 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.637;
-
-procedure List.6 (#Attr.2):
-    let List.652 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.652;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.635;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.651 : [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.651;
-
-procedure List.68 (#Attr.2):
-    let List.657 : List Str = lowlevel ListWithCapacity #Attr.2;
+procedure List.278 (List.279, List.280, List.276):
+    let List.658 : Str = CallByName Test.10 List.280;
+    let List.657 : List Str = CallByName List.71 List.279 List.658;
     ret List.657;
 
+procedure List.5 (List.275, List.276):
+    let List.277 : U64 = CallByName List.6 List.275;
+    let List.642 : List Str = CallByName List.68 List.277;
+    let List.641 : List Str = CallByName List.18 List.275 List.642 List.276;
+    ret List.641;
+
+procedure List.6 (#Attr.2):
+    let List.640 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.640;
+
+procedure List.6 (#Attr.2):
+    let List.655 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.655;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.638 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.638;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.654 : [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.654;
+
+procedure List.68 (#Attr.2):
+    let List.660 : List Str = lowlevel ListWithCapacity #Attr.2;
+    ret List.660;
+
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.656 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.656;
+    let List.659 : List Str = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.659;
 
-procedure List.9 (List.383):
-    let List.629 : U64 = 0i64;
-    let List.622 : [C {}, C Str] = CallByName List.2 List.383 List.629;
-    let List.626 : U8 = 1i64;
-    let List.627 : U8 = GetTagId List.622;
-    let List.628 : Int1 = lowlevel Eq List.626 List.627;
-    if List.628 then
-        let List.384 : Str = UnionAtIndex (Id 1) (Index 0) List.622;
-        let List.623 : [C {}, C Str] = TagId(1) List.384;
-        ret List.623;
+procedure List.9 (List.386):
+    let List.632 : U64 = 0i64;
+    let List.625 : [C {}, C Str] = CallByName List.2 List.386 List.632;
+    let List.629 : U8 = 1i64;
+    let List.630 : U8 = GetTagId List.625;
+    let List.631 : Int1 = lowlevel Eq List.629 List.630;
+    if List.631 then
+        let List.387 : Str = UnionAtIndex (Id 1) (Index 0) List.625;
+        let List.626 : [C {}, C Str] = TagId(1) List.387;
+        ret List.626;
     else
-        dec List.622;
-        let List.625 : {} = Struct {};
-        let List.624 : [C {}, C Str] = TagId(0) List.625;
-        ret List.624;
+        dec List.625;
+        let List.628 : {} = Struct {};
+        let List.627 : [C {}, C Str] = TagId(0) List.628;
+        ret List.627;
 
-procedure List.92 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
-    joinpoint List.644 List.166 List.167 List.168 List.169 List.170:
-        let List.646 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.646 then
-            let List.650 : [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = CallByName List.66 List.166 List.169;
-            inc List.650;
-            let List.171 : List Str = CallByName List.275 List.167 List.650 List.168;
-            let List.649 : U64 = 1i64;
-            let List.648 : U64 = CallByName Num.51 List.169 List.649;
-            jump List.644 List.166 List.171 List.168 List.648 List.170;
+procedure List.95 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
+    joinpoint List.647 List.169 List.170 List.171 List.172 List.173:
+        let List.649 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.649 then
+            let List.653 : [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = CallByName List.66 List.169 List.172;
+            inc List.653;
+            let List.174 : List Str = CallByName List.278 List.170 List.653 List.171;
+            let List.652 : U64 = 1i64;
+            let List.651 : U64 = CallByName Num.51 List.172 List.652;
+            jump List.647 List.169 List.174 List.171 List.651 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
     inc #Derived_gen.4;
-    jump List.644 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
+    jump List.647 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
-procedure Result.5 (Result.10, Result.11):
-    let Result.37 : U8 = 1i64;
-    let Result.38 : U8 = GetTagId Result.10;
-    let Result.39 : Int1 = lowlevel Eq Result.37 Result.38;
-    if Result.39 then
-        dec Result.11;
-        let Result.12 : Str = UnionAtIndex (Id 1) (Index 0) Result.10;
-        ret Result.12;
+procedure Result.5 (Result.13, Result.14):
+    let Result.57 : U8 = 1i64;
+    let Result.58 : U8 = GetTagId Result.13;
+    let Result.59 : Int1 = lowlevel Eq Result.57 Result.58;
+    if Result.59 then
+        dec Result.14;
+        let Result.15 : Str = UnionAtIndex (Id 1) (Index 0) Result.13;
+        ret Result.15;
     else
-        dec Result.10;
-        ret Result.11;
+        dec Result.13;
+        ret Result.14;
 
 procedure Test.10 (Test.11):
     let Test.12 : Str = CallByName Test.2 Test.11;

crates/compiler/test_mono/generated/choose_i128_layout.txt

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

crates/compiler/test_mono/generated/closure_in_list.txt

@@ -1,6 +1,6 @@
 procedure List.6 (#Attr.2):
-    let List.622 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.622;
+    let List.625 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.625;
 
 procedure Test.1 (Test.5):
     let Test.2 : I64 = 41i64;

crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt

@@ -2,47 +2,47 @@ procedure Bool.2 ():
     let Bool.23 : Int1 = true;
     ret Bool.23;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : Int1 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
-procedure List.92 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : Int1 = CallByName List.66 List.166 List.169;
-            let List.171 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.167 List.631 List.168;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : Int1 = CallByName List.66 List.169 List.172;
+            let List.174 : [<rnw><null>, C *self Int1, C *self Int1] = CallByName Test.6 List.170 List.634 List.171;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
     inc #Derived_gen.5;
-    jump List.625 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
+    jump List.628 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.234 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.234;
+    let Str.238 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.238;
 
 procedure Test.1 (Test.5):
     ret Test.5;

crates/compiler/test_mono/generated/dbg_in_expect.txt

@@ -2,50 +2,50 @@ procedure Bool.2 ():
     let Bool.23 : Int1 = true;
     ret Bool.23;
 
-procedure Inspect.246 (Inspect.247, Inspect.245):
+procedure Inspect.250 (Inspect.251, Inspect.249):
+    let Inspect.323 : Str = "\"";
+    let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
+    dec Inspect.323;
+    let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
     let Inspect.319 : Str = "\"";
-    let Inspect.318 : Str = CallByName Inspect.59 Inspect.247 Inspect.319;
+    let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
     dec Inspect.319;
-    let Inspect.314 : Str = CallByName Inspect.59 Inspect.318 Inspect.245;
-    let Inspect.315 : Str = "\"";
-    let Inspect.313 : Str = CallByName Inspect.59 Inspect.314 Inspect.315;
-    dec Inspect.315;
-    ret Inspect.313;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.43 (Inspect.245):
-    let Inspect.309 : Str = CallByName Inspect.30 Inspect.245;
-    ret Inspect.309;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : Str = CallByName Inspect.43 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName Inspect.246 Inspect.304 Inspect.308;
-    dec Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.317 : Str = CallByName Str.3 Inspect.296 Inspect.292;
     ret Inspect.317;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.47 (Inspect.249):
+    let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
+    ret Inspect.313;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
+    dec Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.321;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.1 ():
     let Test.4 : Str = "";

crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt

@@ -1,47 +1,47 @@
-procedure Inspect.246 (Inspect.247, Inspect.245):
+procedure Inspect.250 (Inspect.251, Inspect.249):
+    let Inspect.323 : Str = "\"";
+    let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
+    dec Inspect.323;
+    let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
     let Inspect.319 : Str = "\"";
-    let Inspect.318 : Str = CallByName Inspect.59 Inspect.247 Inspect.319;
+    let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
     dec Inspect.319;
-    let Inspect.314 : Str = CallByName Inspect.59 Inspect.318 Inspect.245;
-    let Inspect.315 : Str = "\"";
-    let Inspect.313 : Str = CallByName Inspect.59 Inspect.314 Inspect.315;
-    dec Inspect.315;
-    ret Inspect.313;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.43 (Inspect.245):
-    let Inspect.309 : Str = CallByName Inspect.30 Inspect.245;
-    ret Inspect.309;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : Str = CallByName Inspect.43 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName Inspect.246 Inspect.304 Inspect.308;
-    dec Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.317 : Str = CallByName Str.3 Inspect.296 Inspect.292;
     ret Inspect.317;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.47 (Inspect.249):
+    let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
+    ret Inspect.313;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
+    dec Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.321;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.0 ():
     let Test.3 : Str = "";

crates/compiler/test_mono/generated/dict.txt

@@ -1,37 +1,37 @@
-procedure Dict.1 (Dict.723):
-    let Dict.732 : List {U32, U32} = Array [];
-    let Dict.733 : List {[], []} = Array [];
-    let Dict.734 : U64 = 0i64;
-    let Dict.44 : Float32 = CallByName Dict.44;
-    let Dict.45 : U8 = CallByName Dict.45;
-    let Dict.731 : {List {U32, U32}, List {[], []}, U64, Float32, U8} = Struct {Dict.732, Dict.733, Dict.734, Dict.44, Dict.45};
-    ret Dict.731;
-
-procedure Dict.4 (Dict.729):
-    let Dict.156 : List {[], []} = StructAtIndex 1 Dict.729;
-    let #Derived_gen.0 : List {U32, U32} = StructAtIndex 0 Dict.729;
-    dec #Derived_gen.0;
-    let Dict.730 : U64 = CallByName List.6 Dict.156;
-    dec Dict.156;
-    ret Dict.730;
-
-procedure Dict.44 ():
-    let Dict.738 : Float32 = 0.8f64;
+procedure Dict.1 (Dict.730):
+    let Dict.739 : List {U32, U32} = Array [];
+    let Dict.740 : List {[], []} = Array [];
+    let Dict.741 : U64 = 0i64;
+    let Dict.51 : Float32 = CallByName Dict.51;
+    let Dict.52 : U8 = CallByName Dict.52;
+    let Dict.738 : {List {U32, U32}, List {[], []}, U64, Float32, U8} = Struct {Dict.739, Dict.740, Dict.741, Dict.51, Dict.52};
     ret Dict.738;
 
-procedure Dict.45 ():
-    let Dict.736 : U8 = 64i64;
-    let Dict.737 : U8 = 3i64;
-    let Dict.735 : U8 = CallByName Num.75 Dict.736 Dict.737;
-    ret Dict.735;
+procedure Dict.4 (Dict.736):
+    let Dict.163 : List {[], []} = StructAtIndex 1 Dict.736;
+    let #Derived_gen.0 : List {U32, U32} = StructAtIndex 0 Dict.736;
+    dec #Derived_gen.0;
+    let Dict.737 : U64 = CallByName List.6 Dict.163;
+    dec Dict.163;
+    ret Dict.737;
+
+procedure Dict.51 ():
+    let Dict.745 : Float32 = 0.8f64;
+    ret Dict.745;
+
+procedure Dict.52 ():
+    let Dict.743 : U8 = 64i64;
+    let Dict.744 : U8 = 3i64;
+    let Dict.742 : U8 = CallByName Num.75 Dict.743 Dict.744;
+    ret Dict.742;
 
 procedure List.6 (#Attr.2):
-    let List.622 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.622;
+    let List.625 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.625;
 
 procedure Num.75 (#Attr.2, #Attr.3):
-    let Num.279 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U8 = lowlevel NumSubWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Test.0 ():
     let Test.3 : {} = Struct {};

crates/compiler/test_mono/generated/empty_list_of_function_type.txt

@@ -2,29 +2,29 @@ procedure Bool.1 ():
     let Bool.23 : Int1 = false;
     ret Bool.23;
 
-procedure List.2 (List.111, List.112):
-    let List.628 : U64 = CallByName List.6 List.111;
-    let List.624 : Int1 = CallByName Num.22 List.112 List.628;
-    if List.624 then
-        let List.626 : {} = CallByName List.66 List.111 List.112;
-        let List.625 : [C {}, C {}] = TagId(1) List.626;
-        ret List.625;
+procedure List.2 (List.114, List.115):
+    let List.631 : U64 = CallByName List.6 List.114;
+    let List.627 : Int1 = CallByName Num.22 List.115 List.631;
+    if List.627 then
+        let List.629 : {} = CallByName List.66 List.114 List.115;
+        let List.628 : [C {}, C {}] = TagId(1) List.629;
+        ret List.628;
     else
-        let List.623 : {} = Struct {};
-        let List.622 : [C {}, C {}] = TagId(0) List.623;
-        ret List.622;
+        let List.626 : {} = Struct {};
+        let List.625 : [C {}, C {}] = TagId(0) List.626;
+        ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.629 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.629;
+    let List.632 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.632;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.627 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.627;
+    let List.630 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.630;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.279 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Test.2 (Test.5):
     let Test.17 : Str = "bar";

crates/compiler/test_mono/generated/encode.txt

@@ -1,16 +1,16 @@
-procedure List.4 (List.127, List.128):
-    let List.625 : U64 = 1i64;
-    let List.623 : List U8 = CallByName List.70 List.127 List.625;
-    let List.622 : List U8 = CallByName List.71 List.623 List.128;
-    ret List.622;
+procedure List.4 (List.130, List.131):
+    let List.628 : U64 = 1i64;
+    let List.626 : List U8 = CallByName List.70 List.130 List.628;
+    let List.625 : List U8 = CallByName List.71 List.626 List.131;
+    ret List.625;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.626 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.626;
+    let List.629 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.629;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.624 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.624;
+    let List.627 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.627;
 
 procedure Test.23 (Test.24, Test.35, Test.22):
     let Test.37 : List U8 = CallByName List.4 Test.24 Test.22;

crates/compiler/test_mono/generated/encode_derived_nested_record_string.txt

@@ -7,7 +7,7 @@ procedure #Derived.2 (#Derived.3, #Derived.4, #Derived.1):
     let #Derived_gen.8 : Str = CallByName #Derived.5 #Derived.1;
     let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
     let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
-    let #Derived_gen.4 : List {Str, Str} = CallByName Test.21 #Derived_gen.5;
+    let #Derived_gen.4 : List {Str, Str} = CallByName Test.22 #Derived_gen.5;
     let #Derived_gen.3 : List U8 = CallByName Encode.24 #Derived.3 #Derived_gen.4 #Derived.4;
     dec #Derived_gen.4;
     ret #Derived_gen.3;
@@ -18,263 +18,263 @@ procedure #Derived.5 (#Derived.6):
 
 procedure #Derived.7 (#Derived.8, #Derived.9, #Derived.6):
     let #Derived_gen.17 : Str = "b";
-    let #Derived_gen.18 : Str = CallByName Test.19 #Derived.6;
+    let #Derived_gen.18 : Str = CallByName Test.20 #Derived.6;
     let #Derived_gen.16 : {Str, Str} = Struct {#Derived_gen.17, #Derived_gen.18};
     let #Derived_gen.15 : List {Str, Str} = Array [#Derived_gen.16];
-    let #Derived_gen.14 : List {Str, Str} = CallByName Test.21 #Derived_gen.15;
+    let #Derived_gen.14 : List {Str, Str} = CallByName Test.22 #Derived_gen.15;
     let #Derived_gen.13 : List U8 = CallByName Encode.24 #Derived.8 #Derived_gen.14 #Derived.9;
     dec #Derived_gen.14;
     ret #Derived_gen.13;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.111 : List U8 = CallByName #Derived.2 Encode.99 Encode.101 Encode.107;
-    ret Encode.111;
-
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.113 : List U8 = CallByName Test.67 Encode.99 Encode.101 Encode.107;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.113 : List U8 = CallByName #Derived.2 Encode.101 Encode.103 Encode.109;
     ret Encode.113;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.116 : List U8 = CallByName #Derived.7 Encode.99 Encode.101 Encode.107;
-    ret Encode.116;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.115 : List U8 = CallByName Test.68 Encode.101 Encode.103 Encode.109;
+    ret Encode.115;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.119 : List U8 = CallByName Test.67 Encode.99 Encode.101 Encode.107;
-    ret Encode.119;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.118 : List U8 = CallByName #Derived.7 Encode.101 Encode.103 Encode.109;
+    ret Encode.118;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.124 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
-    ret Encode.124;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.121 : List U8 = CallByName Test.68 Encode.101 Encode.103 Encode.109;
+    ret Encode.121;
 
-procedure Encode.26 (Encode.105, Encode.106):
-    let Encode.109 : List U8 = Array [];
-    let Encode.110 : Str = CallByName #Derived.0 Encode.105;
-    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
-    ret Encode.108;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.126 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
+    ret Encode.126;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Encode.26 (Encode.107, Encode.108):
+    let Encode.111 : List U8 = Array [];
+    let Encode.112 : Str = CallByName #Derived.0 Encode.107;
+    let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
+    ret Encode.110;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.649 : U64 = 0i64;
-    let List.650 : U64 = CallByName List.6 List.163;
-    let List.648 : List U8 = CallByName List.92 List.163 List.164 List.165 List.649 List.650;
-    ret List.648;
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
-procedure List.4 (List.127, List.128):
-    let List.670 : U64 = 1i64;
-    let List.669 : List U8 = CallByName List.70 List.127 List.670;
-    let List.668 : List U8 = CallByName List.71 List.669 List.128;
-    ret List.668;
+procedure List.18 (List.166, List.167, List.168):
+    let List.652 : U64 = 0i64;
+    let List.653 : U64 = CallByName List.6 List.166;
+    let List.651 : List U8 = CallByName List.95 List.166 List.167 List.168 List.652 List.653;
+    ret List.651;
+
+procedure List.4 (List.130, List.131):
+    let List.673 : U64 = 1i64;
+    let List.672 : List U8 = CallByName List.70 List.130 List.673;
+    let List.671 : List U8 = CallByName List.71 List.672 List.131;
+    ret List.671;
 
 procedure List.6 (#Attr.2):
-    let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.647;
+    let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.650;
 
 procedure List.6 (#Attr.2):
-    let List.673 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.673;
+    let List.676 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.676;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.658 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.658;
+    let List.661 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.661;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.664 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.664;
+    let List.667 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.667;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.662 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.662;
+    let List.665 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.665;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.672 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.672;
+    let List.675 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.675;
 
-procedure List.92 (#Derived_gen.29, #Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33):
-    joinpoint List.651 List.166 List.167 List.168 List.169 List.170:
-        let List.653 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.653 then
-            let List.657 : {Str, Str} = CallByName List.66 List.166 List.169;
-            inc List.657;
-            let List.171 : List U8 = CallByName Test.70 List.167 List.657;
-            let List.656 : U64 = 1i64;
-            let List.655 : U64 = CallByName Num.51 List.169 List.656;
-            jump List.651 List.166 List.171 List.168 List.655 List.170;
+procedure List.95 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : List U8 = CallByName Test.71 List.170 List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.29;
-    jump List.651 #Derived_gen.29 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33;
+    inc #Derived_gen.26;
+    jump List.628 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
 
-procedure List.92 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_gen.40, #Derived_gen.41):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : List U8 = CallByName Test.70 List.167 List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43, #Derived_gen.44):
+    joinpoint List.654 List.169 List.170 List.171 List.172 List.173:
+        let List.656 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.656 then
+            let List.660 : {Str, Str} = CallByName List.66 List.169 List.172;
+            inc List.660;
+            let List.174 : List U8 = CallByName Test.71 List.170 List.660;
+            let List.659 : U64 = 1i64;
+            let List.658 : U64 = CallByName Num.51 List.172 List.659;
+            jump List.654 List.169 List.174 List.171 List.658 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.37;
-    jump List.625 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41;
+    inc #Derived_gen.40;
+    jump List.654 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44;
 
 procedure Num.127 (#Attr.2):
-    let Num.284 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.284;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.286 : 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.51 (#Attr.2, #Attr.3):
-    let Num.285 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.285;
+    let Num.287 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.287;
 
 procedure Num.96 (#Attr.2):
-    let Num.283 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.283;
+    let Num.285 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.285;
 
 procedure Str.12 (#Attr.2):
-    let Str.244 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.244;
+    let Str.248 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.248;
 
 procedure Str.36 (#Attr.2):
-    let Str.245 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.245;
+    let Str.249 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.249;
 
 procedure Str.43 (#Attr.2):
-    let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.239;
+    let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.243;
 
-procedure Str.9 (Str.67):
-    let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
-    let Str.236 : Int1 = StructAtIndex 2 Str.68;
-    if Str.236 then
-        let Str.238 : Str = StructAtIndex 1 Str.68;
-        let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
-        ret Str.237;
+procedure Str.9 (Str.71):
+    let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
+    let Str.240 : Int1 = StructAtIndex 2 Str.72;
+    if Str.240 then
+        let Str.242 : Str = StructAtIndex 1 Str.72;
+        let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
+        ret Str.241;
     else
-        let Str.234 : U8 = StructAtIndex 3 Str.68;
-        let Str.235 : U64 = StructAtIndex 0 Str.68;
-        let #Derived_gen.45 : Str = StructAtIndex 1 Str.68;
+        let Str.238 : U8 = StructAtIndex 3 Str.72;
+        let Str.239 : U64 = StructAtIndex 0 Str.72;
+        let #Derived_gen.45 : Str = StructAtIndex 1 Str.72;
         dec #Derived_gen.45;
-        let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
-        let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
-        ret Str.232;
+        let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
+        let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
+        ret Str.236;
 
-procedure Test.19 (Test.55):
-    let Test.324 : Str = CallByName Encode.23 Test.55;
-    ret Test.324;
+procedure Test.20 (Test.56):
+    let Test.325 : Str = CallByName Encode.23 Test.56;
+    ret Test.325;
 
-procedure Test.2 ():
-    let Test.257 : {} = Struct {};
-    ret Test.257;
+procedure Test.22 (Test.67):
+    let Test.261 : List {Str, Str} = CallByName Encode.23 Test.67;
+    ret Test.261;
 
-procedure Test.21 (Test.66):
-    let Test.260 : List {Str, Str} = CallByName Encode.23 Test.66;
-    ret Test.260;
+procedure Test.22 (Test.67):
+    let Test.293 : List {Str, Str} = CallByName Encode.23 Test.67;
+    ret Test.293;
 
-procedure Test.21 (Test.66):
-    let Test.292 : List {Str, Str} = CallByName Encode.23 Test.66;
-    ret Test.292;
+procedure Test.3 ():
+    let Test.258 : {} = Struct {};
+    ret Test.258;
 
-procedure Test.3 (Test.48, Test.49, Test.50):
-    let Test.321 : U8 = CallByName Num.127 Test.49;
-    let Test.318 : List U8 = CallByName List.4 Test.48 Test.321;
-    let Test.320 : Str = CallByName Num.96 Test.50;
-    let Test.319 : List U8 = CallByName Str.12 Test.320;
-    let Test.316 : List U8 = CallByName List.8 Test.318 Test.319;
-    let Test.317 : U8 = 32i64;
-    let Test.315 : List U8 = CallByName List.4 Test.316 Test.317;
-    ret Test.315;
+procedure Test.4 (Test.49, Test.50, Test.51):
+    let Test.322 : U8 = CallByName Num.127 Test.50;
+    let Test.319 : List U8 = CallByName List.4 Test.49 Test.322;
+    let Test.321 : Str = CallByName Num.96 Test.51;
+    let Test.320 : List U8 = CallByName Str.12 Test.321;
+    let Test.317 : List U8 = CallByName List.8 Test.319 Test.320;
+    let Test.318 : U8 = 32i64;
+    let Test.316 : List U8 = CallByName List.4 Test.317 Test.318;
+    ret Test.316;
 
-procedure Test.56 (Test.57, Test.274, Test.55):
-    let Test.313 : I64 = 115i64;
-    let Test.314 : U64 = CallByName Str.36 Test.55;
-    let Test.311 : List U8 = CallByName Test.3 Test.57 Test.313 Test.314;
-    let Test.312 : List U8 = CallByName Str.12 Test.55;
-    let Test.309 : List U8 = CallByName List.8 Test.311 Test.312;
-    let Test.310 : U8 = 32i64;
-    let Test.308 : List U8 = CallByName List.4 Test.309 Test.310;
-    ret Test.308;
+procedure Test.57 (Test.58, Test.275, Test.56):
+    let Test.314 : I64 = 115i64;
+    let Test.315 : U64 = CallByName Str.36 Test.56;
+    let Test.312 : List U8 = CallByName Test.4 Test.58 Test.314 Test.315;
+    let Test.313 : List U8 = CallByName Str.12 Test.56;
+    let Test.310 : List U8 = CallByName List.8 Test.312 Test.313;
+    let Test.311 : U8 = 32i64;
+    let Test.309 : List U8 = CallByName List.4 Test.310 Test.311;
+    ret Test.309;
 
-procedure Test.67 (Test.68, Test.262, Test.66):
-    let Test.290 : I64 = 114i64;
-    let Test.291 : U64 = CallByName List.6 Test.66;
-    let Test.69 : List U8 = CallByName Test.3 Test.68 Test.290 Test.291;
-    let Test.265 : {} = Struct {};
-    let Test.264 : List U8 = CallByName List.18 Test.66 Test.69 Test.265;
-    ret Test.264;
+procedure Test.68 (Test.69, Test.263, Test.67):
+    let Test.291 : I64 = 114i64;
+    let Test.292 : U64 = CallByName List.6 Test.67;
+    let Test.70 : List U8 = CallByName Test.4 Test.69 Test.291 Test.292;
+    let Test.266 : {} = Struct {};
+    let Test.265 : List U8 = CallByName List.18 Test.67 Test.70 Test.266;
+    ret Test.265;
 
-procedure Test.67 (Test.68, Test.262, Test.66):
-    let Test.322 : I64 = 114i64;
-    let Test.323 : U64 = CallByName List.6 Test.66;
-    let Test.69 : List U8 = CallByName Test.3 Test.68 Test.322 Test.323;
-    let Test.297 : {} = Struct {};
-    let Test.296 : List U8 = CallByName List.18 Test.66 Test.69 Test.297;
-    ret Test.296;
+procedure Test.68 (Test.69, Test.263, Test.67):
+    let Test.323 : I64 = 114i64;
+    let Test.324 : U64 = CallByName List.6 Test.67;
+    let Test.70 : List U8 = CallByName Test.4 Test.69 Test.323 Test.324;
+    let Test.298 : {} = Struct {};
+    let Test.297 : List U8 = CallByName List.18 Test.67 Test.70 Test.298;
+    ret Test.297;
 
-procedure Test.70 (Test.71, Test.266):
-    let Test.72 : Str = StructAtIndex 0 Test.266;
-    let Test.73 : Str = StructAtIndex 1 Test.266;
-    let Test.270 : Str = CallByName Test.19 Test.72;
-    let Test.271 : {} = Struct {};
-    let Test.268 : List U8 = CallByName Encode.24 Test.71 Test.270 Test.271;
-    let Test.269 : {} = Struct {};
-    let Test.267 : List U8 = CallByName Encode.24 Test.268 Test.73 Test.269;
-    ret Test.267;
+procedure Test.71 (Test.72, Test.267):
+    let Test.73 : Str = StructAtIndex 0 Test.267;
+    let Test.74 : Str = StructAtIndex 1 Test.267;
+    let Test.271 : Str = CallByName Test.20 Test.73;
+    let Test.272 : {} = Struct {};
+    let Test.269 : List U8 = CallByName Encode.24 Test.72 Test.271 Test.272;
+    let Test.270 : {} = Struct {};
+    let Test.268 : List U8 = CallByName Encode.24 Test.269 Test.74 Test.270;
+    ret Test.268;
 
-procedure Test.70 (Test.71, Test.266):
-    let Test.72 : Str = StructAtIndex 0 Test.266;
-    let Test.73 : Str = StructAtIndex 1 Test.266;
-    let Test.302 : Str = CallByName Test.19 Test.72;
-    let Test.303 : {} = Struct {};
-    let Test.300 : List U8 = CallByName Encode.24 Test.71 Test.302 Test.303;
-    let Test.301 : {} = Struct {};
-    let Test.299 : List U8 = CallByName Encode.24 Test.300 Test.73 Test.301;
-    ret Test.299;
+procedure Test.71 (Test.72, Test.267):
+    let Test.73 : Str = StructAtIndex 0 Test.267;
+    let Test.74 : Str = StructAtIndex 1 Test.267;
+    let Test.303 : Str = CallByName Test.20 Test.73;
+    let Test.304 : {} = Struct {};
+    let Test.301 : List U8 = CallByName Encode.24 Test.72 Test.303 Test.304;
+    let Test.302 : {} = Struct {};
+    let Test.300 : List U8 = CallByName Encode.24 Test.301 Test.74 Test.302;
+    ret Test.300;
 
 procedure Test.0 ():
-    let Test.259 : Str = "bar";
-    let Test.256 : {} = CallByName Test.2;
-    let Test.254 : List U8 = CallByName Encode.26 Test.259 Test.256;
-    let Test.209 : [C {U64, U8}, C Str] = CallByName Str.9 Test.254;
-    let Test.251 : U8 = 1i64;
-    let Test.252 : U8 = GetTagId Test.209;
-    let Test.253 : Int1 = lowlevel Eq Test.251 Test.252;
-    if Test.253 then
-        let Test.210 : Str = UnionAtIndex (Id 1) (Index 0) Test.209;
-        ret Test.210;
+    let Test.260 : Str = "bar";
+    let Test.257 : {} = CallByName Test.3;
+    let Test.255 : List U8 = CallByName Encode.26 Test.260 Test.257;
+    let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.255;
+    let Test.252 : U8 = 1i64;
+    let Test.253 : U8 = GetTagId Test.210;
+    let Test.254 : Int1 = lowlevel Eq Test.252 Test.253;
+    if Test.254 then
+        let Test.211 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
+        ret Test.211;
     else
-        dec Test.209;
-        let Test.250 : Str = "<bad>";
-        ret Test.250;
+        dec Test.210;
+        let Test.251 : Str = "<bad>";
+        ret Test.251;

crates/compiler/test_mono/generated/encode_derived_record_one_field_string.txt

@@ -4,196 +4,196 @@ procedure #Derived.0 (#Derived.1):
 
 procedure #Derived.2 (#Derived.3, #Derived.4, #Derived.1):
     let #Derived_gen.7 : Str = "a";
-    let #Derived_gen.8 : Str = CallByName Test.19 #Derived.1;
+    let #Derived_gen.8 : Str = CallByName Test.20 #Derived.1;
     let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
     let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
-    let #Derived_gen.4 : List {Str, Str} = CallByName Test.21 #Derived_gen.5;
+    let #Derived_gen.4 : List {Str, Str} = CallByName Test.22 #Derived_gen.5;
     let #Derived_gen.3 : List U8 = CallByName Encode.24 #Derived.3 #Derived_gen.4 #Derived.4;
     dec #Derived_gen.4;
     ret #Derived_gen.3;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.111 : List U8 = CallByName #Derived.2 Encode.99 Encode.101 Encode.107;
-    ret Encode.111;
-
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.113 : List U8 = CallByName Test.67 Encode.99 Encode.101 Encode.107;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.113 : List U8 = CallByName #Derived.2 Encode.101 Encode.103 Encode.109;
     ret Encode.113;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.118 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
-    ret Encode.118;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.115 : List U8 = CallByName Test.68 Encode.101 Encode.103 Encode.109;
+    ret Encode.115;
 
-procedure Encode.26 (Encode.105, Encode.106):
-    let Encode.109 : List U8 = Array [];
-    let Encode.110 : Str = CallByName #Derived.0 Encode.105;
-    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
-    ret Encode.108;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.120 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
+    ret Encode.120;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Encode.26 (Encode.107, Encode.108):
+    let Encode.111 : List U8 = Array [];
+    let Encode.112 : Str = CallByName #Derived.0 Encode.107;
+    let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
+    ret Encode.110;
 
-procedure List.4 (List.127, List.128):
-    let List.644 : U64 = 1i64;
-    let List.643 : List U8 = CallByName List.70 List.127 List.644;
-    let List.642 : List U8 = CallByName List.71 List.643 List.128;
-    ret List.642;
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
+
+procedure List.4 (List.130, List.131):
+    let List.647 : U64 = 1i64;
+    let List.646 : List U8 = CallByName List.70 List.130 List.647;
+    let List.645 : List U8 = CallByName List.71 List.646 List.131;
+    ret List.645;
 
 procedure List.6 (#Attr.2):
-    let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.647;
+    let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.650;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.638 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.638;
+    let List.641 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.641;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.636 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.636;
+    let List.639 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.639;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.646 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.646;
+    let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.649;
 
-procedure List.92 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : List U8 = CallByName Test.70 List.167 List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : List U8 = CallByName Test.71 List.170 List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
     inc #Derived_gen.13;
-    jump List.625 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
+    jump List.628 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
 
 procedure Num.127 (#Attr.2):
-    let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.280;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.282 : 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.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.96 (#Attr.2):
-    let Num.279 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.279;
+    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.281;
 
 procedure Str.12 (#Attr.2):
-    let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.241;
+    let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.245;
 
 procedure Str.36 (#Attr.2):
-    let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.242;
+    let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.246;
 
 procedure Str.43 (#Attr.2):
-    let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.239;
+    let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.243;
 
-procedure Str.9 (Str.67):
-    let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
-    let Str.236 : Int1 = StructAtIndex 2 Str.68;
-    if Str.236 then
-        let Str.238 : Str = StructAtIndex 1 Str.68;
-        let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
-        ret Str.237;
+procedure Str.9 (Str.71):
+    let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
+    let Str.240 : Int1 = StructAtIndex 2 Str.72;
+    if Str.240 then
+        let Str.242 : Str = StructAtIndex 1 Str.72;
+        let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
+        ret Str.241;
     else
-        let Str.234 : U8 = StructAtIndex 3 Str.68;
-        let Str.235 : U64 = StructAtIndex 0 Str.68;
-        let #Derived_gen.24 : Str = StructAtIndex 1 Str.68;
+        let Str.238 : U8 = StructAtIndex 3 Str.72;
+        let Str.239 : U64 = StructAtIndex 0 Str.72;
+        let #Derived_gen.24 : Str = StructAtIndex 1 Str.72;
         dec #Derived_gen.24;
-        let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
-        let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
-        ret Str.232;
+        let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
+        let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
+        ret Str.236;
 
-procedure Test.19 (Test.55):
-    let Test.291 : Str = CallByName Encode.23 Test.55;
-    ret Test.291;
+procedure Test.20 (Test.56):
+    let Test.292 : Str = CallByName Encode.23 Test.56;
+    ret Test.292;
 
-procedure Test.2 ():
-    let Test.257 : {} = Struct {};
-    ret Test.257;
+procedure Test.22 (Test.67):
+    let Test.260 : List {Str, Str} = CallByName Encode.23 Test.67;
+    ret Test.260;
 
-procedure Test.21 (Test.66):
-    let Test.259 : List {Str, Str} = CallByName Encode.23 Test.66;
-    ret Test.259;
+procedure Test.3 ():
+    let Test.258 : {} = Struct {};
+    ret Test.258;
 
-procedure Test.3 (Test.48, Test.49, Test.50):
-    let Test.288 : U8 = CallByName Num.127 Test.49;
-    let Test.285 : List U8 = CallByName List.4 Test.48 Test.288;
-    let Test.287 : Str = CallByName Num.96 Test.50;
-    let Test.286 : List U8 = CallByName Str.12 Test.287;
-    let Test.283 : List U8 = CallByName List.8 Test.285 Test.286;
-    let Test.284 : U8 = 32i64;
-    let Test.282 : List U8 = CallByName List.4 Test.283 Test.284;
-    ret Test.282;
+procedure Test.4 (Test.49, Test.50, Test.51):
+    let Test.289 : U8 = CallByName Num.127 Test.50;
+    let Test.286 : List U8 = CallByName List.4 Test.49 Test.289;
+    let Test.288 : Str = CallByName Num.96 Test.51;
+    let Test.287 : List U8 = CallByName Str.12 Test.288;
+    let Test.284 : List U8 = CallByName List.8 Test.286 Test.287;
+    let Test.285 : U8 = 32i64;
+    let Test.283 : List U8 = CallByName List.4 Test.284 Test.285;
+    ret Test.283;
 
-procedure Test.56 (Test.57, Test.273, Test.55):
-    let Test.280 : I64 = 115i64;
-    let Test.281 : U64 = CallByName Str.36 Test.55;
-    let Test.278 : List U8 = CallByName Test.3 Test.57 Test.280 Test.281;
-    let Test.279 : List U8 = CallByName Str.12 Test.55;
-    let Test.276 : List U8 = CallByName List.8 Test.278 Test.279;
-    let Test.277 : U8 = 32i64;
-    let Test.275 : List U8 = CallByName List.4 Test.276 Test.277;
-    ret Test.275;
+procedure Test.57 (Test.58, Test.274, Test.56):
+    let Test.281 : I64 = 115i64;
+    let Test.282 : U64 = CallByName Str.36 Test.56;
+    let Test.279 : List U8 = CallByName Test.4 Test.58 Test.281 Test.282;
+    let Test.280 : List U8 = CallByName Str.12 Test.56;
+    let Test.277 : List U8 = CallByName List.8 Test.279 Test.280;
+    let Test.278 : U8 = 32i64;
+    let Test.276 : List U8 = CallByName List.4 Test.277 Test.278;
+    ret Test.276;
 
-procedure Test.67 (Test.68, Test.261, Test.66):
-    let Test.289 : I64 = 114i64;
-    let Test.290 : U64 = CallByName List.6 Test.66;
-    let Test.69 : List U8 = CallByName Test.3 Test.68 Test.289 Test.290;
-    let Test.264 : {} = Struct {};
-    let Test.263 : List U8 = CallByName List.18 Test.66 Test.69 Test.264;
-    ret Test.263;
+procedure Test.68 (Test.69, Test.262, Test.67):
+    let Test.290 : I64 = 114i64;
+    let Test.291 : U64 = CallByName List.6 Test.67;
+    let Test.70 : List U8 = CallByName Test.4 Test.69 Test.290 Test.291;
+    let Test.265 : {} = Struct {};
+    let Test.264 : List U8 = CallByName List.18 Test.67 Test.70 Test.265;
+    ret Test.264;
 
-procedure Test.70 (Test.71, Test.265):
-    let Test.72 : Str = StructAtIndex 0 Test.265;
-    let Test.73 : Str = StructAtIndex 1 Test.265;
-    let Test.269 : Str = CallByName Test.19 Test.72;
-    let Test.270 : {} = Struct {};
-    let Test.267 : List U8 = CallByName Encode.24 Test.71 Test.269 Test.270;
-    let Test.268 : {} = Struct {};
-    let Test.266 : List U8 = CallByName Encode.24 Test.267 Test.73 Test.268;
-    ret Test.266;
+procedure Test.71 (Test.72, Test.266):
+    let Test.73 : Str = StructAtIndex 0 Test.266;
+    let Test.74 : Str = StructAtIndex 1 Test.266;
+    let Test.270 : Str = CallByName Test.20 Test.73;
+    let Test.271 : {} = Struct {};
+    let Test.268 : List U8 = CallByName Encode.24 Test.72 Test.270 Test.271;
+    let Test.269 : {} = Struct {};
+    let Test.267 : List U8 = CallByName Encode.24 Test.268 Test.74 Test.269;
+    ret Test.267;
 
 procedure Test.0 ():
-    let Test.258 : Str = "foo";
-    let Test.256 : {} = CallByName Test.2;
-    let Test.254 : List U8 = CallByName Encode.26 Test.258 Test.256;
-    let Test.209 : [C {U64, U8}, C Str] = CallByName Str.9 Test.254;
-    let Test.251 : U8 = 1i64;
-    let Test.252 : U8 = GetTagId Test.209;
-    let Test.253 : Int1 = lowlevel Eq Test.251 Test.252;
-    if Test.253 then
-        let Test.210 : Str = UnionAtIndex (Id 1) (Index 0) Test.209;
-        ret Test.210;
+    let Test.259 : Str = "foo";
+    let Test.257 : {} = CallByName Test.3;
+    let Test.255 : List U8 = CallByName Encode.26 Test.259 Test.257;
+    let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.255;
+    let Test.252 : U8 = 1i64;
+    let Test.253 : U8 = GetTagId Test.210;
+    let Test.254 : Int1 = lowlevel Eq Test.252 Test.253;
+    if Test.254 then
+        let Test.211 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
+        ret Test.211;
     else
-        dec Test.209;
-        let Test.250 : Str = "<bad>";
-        ret Test.250;
+        dec Test.210;
+        let Test.251 : Str = "<bad>";
+        ret Test.251;

crates/compiler/test_mono/generated/encode_derived_record_two_field_strings.txt

@@ -6,203 +6,203 @@ procedure #Derived.2 (#Derived.3, #Derived.4, #Derived.1):
     let #Derived_gen.11 : Str = "a";
     let #Derived_gen.13 : Str = StructAtIndex 0 #Derived.1;
     inc #Derived_gen.13;
-    let #Derived_gen.12 : Str = CallByName Test.19 #Derived_gen.13;
+    let #Derived_gen.12 : Str = CallByName Test.20 #Derived_gen.13;
     let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.11, #Derived_gen.12};
     let #Derived_gen.8 : Str = "b";
     let #Derived_gen.10 : Str = StructAtIndex 1 #Derived.1;
     dec #Derived_gen.13;
-    let #Derived_gen.9 : Str = CallByName Test.19 #Derived_gen.10;
+    let #Derived_gen.9 : Str = CallByName Test.20 #Derived_gen.10;
     let #Derived_gen.7 : {Str, Str} = Struct {#Derived_gen.8, #Derived_gen.9};
     let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6, #Derived_gen.7];
-    let #Derived_gen.4 : List {Str, Str} = CallByName Test.21 #Derived_gen.5;
+    let #Derived_gen.4 : List {Str, Str} = CallByName Test.22 #Derived_gen.5;
     let #Derived_gen.3 : List U8 = CallByName Encode.24 #Derived.3 #Derived_gen.4 #Derived.4;
     dec #Derived_gen.4;
     ret #Derived_gen.3;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.111 : List U8 = CallByName #Derived.2 Encode.99 Encode.101 Encode.107;
-    ret Encode.111;
-
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.113 : List U8 = CallByName Test.67 Encode.99 Encode.101 Encode.107;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.113 : List U8 = CallByName #Derived.2 Encode.101 Encode.103 Encode.109;
     ret Encode.113;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.119 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
-    ret Encode.119;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.115 : List U8 = CallByName Test.68 Encode.101 Encode.103 Encode.109;
+    ret Encode.115;
 
-procedure Encode.26 (Encode.105, Encode.106):
-    let Encode.109 : List U8 = Array [];
-    let Encode.110 : {Str, Str} = CallByName #Derived.0 Encode.105;
-    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
-    ret Encode.108;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.121 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
+    ret Encode.121;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Encode.26 (Encode.107, Encode.108):
+    let Encode.111 : List U8 = Array [];
+    let Encode.112 : {Str, Str} = CallByName #Derived.0 Encode.107;
+    let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
+    ret Encode.110;
 
-procedure List.4 (List.127, List.128):
-    let List.644 : U64 = 1i64;
-    let List.643 : List U8 = CallByName List.70 List.127 List.644;
-    let List.642 : List U8 = CallByName List.71 List.643 List.128;
-    ret List.642;
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
+
+procedure List.4 (List.130, List.131):
+    let List.647 : U64 = 1i64;
+    let List.646 : List U8 = CallByName List.70 List.130 List.647;
+    let List.645 : List U8 = CallByName List.71 List.646 List.131;
+    ret List.645;
 
 procedure List.6 (#Attr.2):
-    let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.647;
+    let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.650;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.638 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.638;
+    let List.641 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.641;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.636 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.636;
+    let List.639 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.639;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.646 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.646;
+    let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.649;
 
-procedure List.92 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : List U8 = CallByName Test.70 List.167 List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.17, #Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : List U8 = CallByName Test.71 List.170 List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
     inc #Derived_gen.17;
-    jump List.625 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
+    jump List.628 #Derived_gen.17 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21;
 
 procedure Num.127 (#Attr.2):
-    let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.280;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.282 : 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.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.96 (#Attr.2):
-    let Num.279 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.279;
+    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.281;
 
 procedure Str.12 (#Attr.2):
-    let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.241;
+    let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.245;
 
 procedure Str.36 (#Attr.2):
-    let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.242;
+    let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.246;
 
 procedure Str.43 (#Attr.2):
-    let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.239;
+    let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.243;
 
-procedure Str.9 (Str.67):
-    let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
-    let Str.236 : Int1 = StructAtIndex 2 Str.68;
-    if Str.236 then
-        let Str.238 : Str = StructAtIndex 1 Str.68;
-        let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
-        ret Str.237;
+procedure Str.9 (Str.71):
+    let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
+    let Str.240 : Int1 = StructAtIndex 2 Str.72;
+    if Str.240 then
+        let Str.242 : Str = StructAtIndex 1 Str.72;
+        let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
+        ret Str.241;
     else
-        let Str.234 : U8 = StructAtIndex 3 Str.68;
-        let Str.235 : U64 = StructAtIndex 0 Str.68;
-        let #Derived_gen.28 : Str = StructAtIndex 1 Str.68;
+        let Str.238 : U8 = StructAtIndex 3 Str.72;
+        let Str.239 : U64 = StructAtIndex 0 Str.72;
+        let #Derived_gen.28 : Str = StructAtIndex 1 Str.72;
         dec #Derived_gen.28;
-        let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
-        let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
-        ret Str.232;
+        let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
+        let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
+        ret Str.236;
 
-procedure Test.19 (Test.55):
-    let Test.295 : Str = CallByName Encode.23 Test.55;
-    ret Test.295;
+procedure Test.20 (Test.56):
+    let Test.296 : Str = CallByName Encode.23 Test.56;
+    ret Test.296;
 
-procedure Test.2 ():
-    let Test.257 : {} = Struct {};
-    ret Test.257;
+procedure Test.22 (Test.67):
+    let Test.261 : List {Str, Str} = CallByName Encode.23 Test.67;
+    ret Test.261;
 
-procedure Test.21 (Test.66):
-    let Test.260 : List {Str, Str} = CallByName Encode.23 Test.66;
-    ret Test.260;
+procedure Test.3 ():
+    let Test.258 : {} = Struct {};
+    ret Test.258;
 
-procedure Test.3 (Test.48, Test.49, Test.50):
-    let Test.289 : U8 = CallByName Num.127 Test.49;
-    let Test.286 : List U8 = CallByName List.4 Test.48 Test.289;
-    let Test.288 : Str = CallByName Num.96 Test.50;
-    let Test.287 : List U8 = CallByName Str.12 Test.288;
-    let Test.284 : List U8 = CallByName List.8 Test.286 Test.287;
-    let Test.285 : U8 = 32i64;
-    let Test.283 : List U8 = CallByName List.4 Test.284 Test.285;
-    ret Test.283;
+procedure Test.4 (Test.49, Test.50, Test.51):
+    let Test.290 : U8 = CallByName Num.127 Test.50;
+    let Test.287 : List U8 = CallByName List.4 Test.49 Test.290;
+    let Test.289 : Str = CallByName Num.96 Test.51;
+    let Test.288 : List U8 = CallByName Str.12 Test.289;
+    let Test.285 : List U8 = CallByName List.8 Test.287 Test.288;
+    let Test.286 : U8 = 32i64;
+    let Test.284 : List U8 = CallByName List.4 Test.285 Test.286;
+    ret Test.284;
 
-procedure Test.56 (Test.57, Test.274, Test.55):
-    let Test.281 : I64 = 115i64;
-    let Test.282 : U64 = CallByName Str.36 Test.55;
-    let Test.279 : List U8 = CallByName Test.3 Test.57 Test.281 Test.282;
-    let Test.280 : List U8 = CallByName Str.12 Test.55;
-    let Test.277 : List U8 = CallByName List.8 Test.279 Test.280;
-    let Test.278 : U8 = 32i64;
-    let Test.276 : List U8 = CallByName List.4 Test.277 Test.278;
-    ret Test.276;
+procedure Test.57 (Test.58, Test.275, Test.56):
+    let Test.282 : I64 = 115i64;
+    let Test.283 : U64 = CallByName Str.36 Test.56;
+    let Test.280 : List U8 = CallByName Test.4 Test.58 Test.282 Test.283;
+    let Test.281 : List U8 = CallByName Str.12 Test.56;
+    let Test.278 : List U8 = CallByName List.8 Test.280 Test.281;
+    let Test.279 : U8 = 32i64;
+    let Test.277 : List U8 = CallByName List.4 Test.278 Test.279;
+    ret Test.277;
 
-procedure Test.67 (Test.68, Test.262, Test.66):
-    let Test.290 : I64 = 114i64;
-    let Test.291 : U64 = CallByName List.6 Test.66;
-    let Test.69 : List U8 = CallByName Test.3 Test.68 Test.290 Test.291;
-    let Test.265 : {} = Struct {};
-    let Test.264 : List U8 = CallByName List.18 Test.66 Test.69 Test.265;
-    ret Test.264;
+procedure Test.68 (Test.69, Test.263, Test.67):
+    let Test.291 : I64 = 114i64;
+    let Test.292 : U64 = CallByName List.6 Test.67;
+    let Test.70 : List U8 = CallByName Test.4 Test.69 Test.291 Test.292;
+    let Test.266 : {} = Struct {};
+    let Test.265 : List U8 = CallByName List.18 Test.67 Test.70 Test.266;
+    ret Test.265;
 
-procedure Test.70 (Test.71, Test.266):
-    let Test.72 : Str = StructAtIndex 0 Test.266;
-    let Test.73 : Str = StructAtIndex 1 Test.266;
-    let Test.270 : Str = CallByName Test.19 Test.72;
-    let Test.271 : {} = Struct {};
-    let Test.268 : List U8 = CallByName Encode.24 Test.71 Test.270 Test.271;
-    let Test.269 : {} = Struct {};
-    let Test.267 : List U8 = CallByName Encode.24 Test.268 Test.73 Test.269;
-    ret Test.267;
+procedure Test.71 (Test.72, Test.267):
+    let Test.73 : Str = StructAtIndex 0 Test.267;
+    let Test.74 : Str = StructAtIndex 1 Test.267;
+    let Test.271 : Str = CallByName Test.20 Test.73;
+    let Test.272 : {} = Struct {};
+    let Test.269 : List U8 = CallByName Encode.24 Test.72 Test.271 Test.272;
+    let Test.270 : {} = Struct {};
+    let Test.268 : List U8 = CallByName Encode.24 Test.269 Test.74 Test.270;
+    ret Test.268;
 
 procedure Test.0 ():
-    let Test.258 : Str = "foo";
-    let Test.259 : Str = "bar";
-    let Test.255 : {Str, Str} = Struct {Test.258, Test.259};
-    let Test.256 : {} = CallByName Test.2;
-    let Test.254 : List U8 = CallByName Encode.26 Test.255 Test.256;
-    let Test.209 : [C {U64, U8}, C Str] = CallByName Str.9 Test.254;
-    let Test.251 : U8 = 1i64;
-    let Test.252 : U8 = GetTagId Test.209;
-    let Test.253 : Int1 = lowlevel Eq Test.251 Test.252;
-    if Test.253 then
-        let Test.210 : Str = UnionAtIndex (Id 1) (Index 0) Test.209;
-        ret Test.210;
+    let Test.259 : Str = "foo";
+    let Test.260 : Str = "bar";
+    let Test.256 : {Str, Str} = Struct {Test.259, Test.260};
+    let Test.257 : {} = CallByName Test.3;
+    let Test.255 : List U8 = CallByName Encode.26 Test.256 Test.257;
+    let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.255;
+    let Test.252 : U8 = 1i64;
+    let Test.253 : U8 = GetTagId Test.210;
+    let Test.254 : Int1 = lowlevel Eq Test.252 Test.253;
+    if Test.254 then
+        let Test.211 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
+        ret Test.211;
     else
-        dec Test.209;
-        let Test.250 : Str = "<bad>";
-        ret Test.250;
+        dec Test.210;
+        let Test.251 : Str = "<bad>";
+        ret Test.251;

crates/compiler/test_mono/generated/encode_derived_string.txt

@@ -1,110 +1,110 @@
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.111 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
-    ret Encode.111;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.113 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
+    ret Encode.113;
 
-procedure Encode.26 (Encode.105, Encode.106):
-    let Encode.109 : List U8 = Array [];
-    let Encode.110 : Str = CallByName Test.19 Encode.105;
-    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
-    ret Encode.108;
+procedure Encode.26 (Encode.107, Encode.108):
+    let Encode.111 : List U8 = Array [];
+    let Encode.112 : Str = CallByName Test.20 Encode.107;
+    let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
+    ret Encode.110;
 
-procedure List.4 (List.127, List.128):
-    let List.632 : U64 = 1i64;
-    let List.631 : List U8 = CallByName List.70 List.127 List.632;
-    let List.630 : List U8 = CallByName List.71 List.631 List.128;
-    ret List.630;
+procedure List.4 (List.130, List.131):
+    let List.635 : U64 = 1i64;
+    let List.634 : List U8 = CallByName List.70 List.130 List.635;
+    let List.633 : List U8 = CallByName List.71 List.634 List.131;
+    ret List.633;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.626 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.626;
+    let List.629 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.629;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.624 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.624;
+    let List.627 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.627;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.634 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.634;
+    let List.637 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.637;
 
 procedure Num.127 (#Attr.2):
-    let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.280;
+    let Num.282 : U8 = lowlevel NumIntCast #Attr.2;
+    ret Num.282;
 
 procedure Num.96 (#Attr.2):
-    let Num.279 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.279;
+    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.281;
 
 procedure Str.12 (#Attr.2):
-    let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.241;
+    let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.245;
 
 procedure Str.36 (#Attr.2):
-    let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.242;
+    let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.246;
 
 procedure Str.43 (#Attr.2):
-    let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.239;
+    let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.243;
 
-procedure Str.9 (Str.67):
-    let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
-    let Str.236 : Int1 = StructAtIndex 2 Str.68;
-    if Str.236 then
-        let Str.238 : Str = StructAtIndex 1 Str.68;
-        let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
-        ret Str.237;
+procedure Str.9 (Str.71):
+    let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
+    let Str.240 : Int1 = StructAtIndex 2 Str.72;
+    if Str.240 then
+        let Str.242 : Str = StructAtIndex 1 Str.72;
+        let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
+        ret Str.241;
     else
-        let Str.234 : U8 = StructAtIndex 3 Str.68;
-        let Str.235 : U64 = StructAtIndex 0 Str.68;
-        let #Derived_gen.3 : Str = StructAtIndex 1 Str.68;
+        let Str.238 : U8 = StructAtIndex 3 Str.72;
+        let Str.239 : U64 = StructAtIndex 0 Str.72;
+        let #Derived_gen.3 : Str = StructAtIndex 1 Str.72;
         dec #Derived_gen.3;
-        let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
-        let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
-        ret Str.232;
+        let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
+        let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
+        ret Str.236;
 
-procedure Test.19 (Test.55):
-    let Test.258 : Str = CallByName Encode.23 Test.55;
+procedure Test.20 (Test.56):
+    let Test.259 : Str = CallByName Encode.23 Test.56;
+    ret Test.259;
+
+procedure Test.3 ():
+    let Test.258 : {} = Struct {};
     ret Test.258;
 
-procedure Test.2 ():
-    let Test.257 : {} = Struct {};
-    ret Test.257;
+procedure Test.4 (Test.49, Test.50, Test.51):
+    let Test.276 : U8 = CallByName Num.127 Test.50;
+    let Test.273 : List U8 = CallByName List.4 Test.49 Test.276;
+    let Test.275 : Str = CallByName Num.96 Test.51;
+    let Test.274 : List U8 = CallByName Str.12 Test.275;
+    let Test.271 : List U8 = CallByName List.8 Test.273 Test.274;
+    let Test.272 : U8 = 32i64;
+    let Test.270 : List U8 = CallByName List.4 Test.271 Test.272;
+    ret Test.270;
 
-procedure Test.3 (Test.48, Test.49, Test.50):
-    let Test.275 : U8 = CallByName Num.127 Test.49;
-    let Test.272 : List U8 = CallByName List.4 Test.48 Test.275;
-    let Test.274 : Str = CallByName Num.96 Test.50;
-    let Test.273 : List U8 = CallByName Str.12 Test.274;
-    let Test.270 : List U8 = CallByName List.8 Test.272 Test.273;
-    let Test.271 : U8 = 32i64;
-    let Test.269 : List U8 = CallByName List.4 Test.270 Test.271;
-    ret Test.269;
-
-procedure Test.56 (Test.57, Test.260, Test.55):
-    let Test.267 : I64 = 115i64;
-    let Test.268 : U64 = CallByName Str.36 Test.55;
-    let Test.265 : List U8 = CallByName Test.3 Test.57 Test.267 Test.268;
-    let Test.266 : List U8 = CallByName Str.12 Test.55;
-    let Test.263 : List U8 = CallByName List.8 Test.265 Test.266;
-    let Test.264 : U8 = 32i64;
-    let Test.262 : List U8 = CallByName List.4 Test.263 Test.264;
-    ret Test.262;
+procedure Test.57 (Test.58, Test.261, Test.56):
+    let Test.268 : I64 = 115i64;
+    let Test.269 : U64 = CallByName Str.36 Test.56;
+    let Test.266 : List U8 = CallByName Test.4 Test.58 Test.268 Test.269;
+    let Test.267 : List U8 = CallByName Str.12 Test.56;
+    let Test.264 : List U8 = CallByName List.8 Test.266 Test.267;
+    let Test.265 : U8 = 32i64;
+    let Test.263 : List U8 = CallByName List.4 Test.264 Test.265;
+    ret Test.263;
 
 procedure Test.0 ():
-    let Test.255 : Str = "abc";
-    let Test.256 : {} = CallByName Test.2;
-    let Test.254 : List U8 = CallByName Encode.26 Test.255 Test.256;
-    let Test.209 : [C {U64, U8}, C Str] = CallByName Str.9 Test.254;
-    let Test.251 : U8 = 1i64;
-    let Test.252 : U8 = GetTagId Test.209;
-    let Test.253 : Int1 = lowlevel Eq Test.251 Test.252;
-    if Test.253 then
-        let Test.210 : Str = UnionAtIndex (Id 1) (Index 0) Test.209;
-        ret Test.210;
+    let Test.256 : Str = "abc";
+    let Test.257 : {} = CallByName Test.3;
+    let Test.255 : List U8 = CallByName Encode.26 Test.256 Test.257;
+    let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.255;
+    let Test.252 : U8 = 1i64;
+    let Test.253 : U8 = GetTagId Test.210;
+    let Test.254 : Int1 = lowlevel Eq Test.252 Test.253;
+    if Test.254 then
+        let Test.211 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
+        ret Test.211;
     else
-        dec Test.209;
-        let Test.250 : Str = "<bad>";
-        ret Test.250;
+        dec Test.210;
+        let Test.251 : Str = "<bad>";
+        ret Test.251;

crates/compiler/test_mono/generated/encode_derived_tag_one_field_string.txt

@@ -8,212 +8,212 @@ procedure #Derived.3 (#Derived.4, #Derived.5, #Derived.1):
         ret #Derived_gen.3;
     in
     let #Derived_gen.7 : Str = "A";
-    let #Derived_gen.9 : Str = CallByName Test.19 #Derived.1;
+    let #Derived_gen.9 : Str = CallByName Test.20 #Derived.1;
     let #Derived_gen.8 : List Str = Array [#Derived_gen.9];
-    let #Derived_gen.6 : {List Str, {}} = CallByName Test.23 #Derived_gen.7 #Derived_gen.8;
+    let #Derived_gen.6 : {List Str, {}} = CallByName Test.24 #Derived_gen.7 #Derived_gen.8;
     jump #Derived_gen.5 #Derived_gen.6;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.111 : List U8 = CallByName #Derived.3 Encode.99 Encode.101 Encode.107;
-    ret Encode.111;
-
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.113 : List U8 = CallByName Test.60 Encode.99 Encode.101 Encode.107;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.113 : List U8 = CallByName #Derived.3 Encode.101 Encode.103 Encode.109;
     ret Encode.113;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.117 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
-    ret Encode.117;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.115 : List U8 = CallByName Test.61 Encode.101 Encode.103 Encode.109;
+    ret Encode.115;
 
-procedure Encode.26 (Encode.105, Encode.106):
-    let Encode.109 : List U8 = Array [];
-    let Encode.110 : Str = CallByName #Derived.0 Encode.105;
-    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
-    ret Encode.108;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.119 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
+    ret Encode.119;
+
+procedure Encode.26 (Encode.107, Encode.108):
+    let Encode.111 : List U8 = Array [];
+    let Encode.112 : Str = CallByName #Derived.0 Encode.107;
+    let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
+    ret Encode.110;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.648 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.648;
+    let List.651 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    ret List.651;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
-procedure List.4 (List.127, List.128):
-    let List.644 : U64 = 1i64;
-    let List.643 : List U8 = CallByName List.70 List.127 List.644;
-    let List.642 : List U8 = CallByName List.71 List.643 List.128;
-    ret List.642;
+procedure List.4 (List.130, List.131):
+    let List.647 : U64 = 1i64;
+    let List.646 : List U8 = CallByName List.70 List.130 List.647;
+    let List.645 : List U8 = CallByName List.71 List.646 List.131;
+    ret List.645;
 
 procedure List.6 (#Attr.2):
-    let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.647;
+    let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.650;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.638 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.638;
+    let List.641 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.641;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.636 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.636;
+    let List.639 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.639;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.646 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.646;
+    let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.649;
 
-procedure List.92 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : Str = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : List U8 = CallByName Test.63 List.167 List.631 List.168;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : Str = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : List U8 = CallByName Test.64 List.170 List.634 List.171;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.13;
-    jump List.625 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
+    inc #Derived_gen.10;
+    jump List.628 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
 
 procedure Num.127 (#Attr.2):
-    let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.280;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.282 : 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.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.96 (#Attr.2):
-    let Num.279 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.279;
+    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.281;
 
 procedure Str.12 (#Attr.2):
-    let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.241;
+    let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.245;
 
 procedure Str.36 (#Attr.2):
-    let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.242;
+    let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.246;
 
 procedure Str.43 (#Attr.2):
-    let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.239;
+    let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.243;
 
-procedure Str.9 (Str.67):
-    let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
-    let Str.236 : Int1 = StructAtIndex 2 Str.68;
-    if Str.236 then
-        let Str.238 : Str = StructAtIndex 1 Str.68;
-        let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
-        ret Str.237;
+procedure Str.9 (Str.71):
+    let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
+    let Str.240 : Int1 = StructAtIndex 2 Str.72;
+    if Str.240 then
+        let Str.242 : Str = StructAtIndex 1 Str.72;
+        let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
+        ret Str.241;
     else
-        let Str.234 : U8 = StructAtIndex 3 Str.68;
-        let Str.235 : U64 = StructAtIndex 0 Str.68;
-        let #Derived_gen.27 : Str = StructAtIndex 1 Str.68;
+        let Str.238 : U8 = StructAtIndex 3 Str.72;
+        let Str.239 : U64 = StructAtIndex 0 Str.72;
+        let #Derived_gen.27 : Str = StructAtIndex 1 Str.72;
         dec #Derived_gen.27;
-        let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
-        let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
-        ret Str.232;
+        let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
+        let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
+        ret Str.236;
 
-procedure Test.19 (Test.55):
-    let Test.296 : Str = CallByName Encode.23 Test.55;
-    ret Test.296;
+procedure Test.20 (Test.56):
+    let Test.297 : Str = CallByName Encode.23 Test.56;
+    ret Test.297;
 
-procedure Test.2 ():
-    let Test.258 : {} = Struct {};
-    ret Test.258;
+procedure Test.21 (Test.59, Test.60):
+    inc Test.59;
+    let Test.266 : {List Str, {}} = Struct {Test.59, Test.60};
+    let Test.265 : {List Str, {}} = CallByName Encode.23 Test.266;
+    ret Test.265;
 
-procedure Test.20 (Test.58, Test.59):
-    inc Test.58;
-    let Test.265 : {List Str, {}} = Struct {Test.58, Test.59};
-    let Test.264 : {List Str, {}} = CallByName Encode.23 Test.265;
-    ret Test.264;
+procedure Test.23 (Test.75):
+    let Test.264 : {} = Struct {};
+    let Test.263 : {List Str, {}} = CallByName Test.21 Test.75 Test.264;
+    ret Test.263;
 
-procedure Test.22 (Test.74):
-    let Test.263 : {} = Struct {};
-    let Test.262 : {List Str, {}} = CallByName Test.20 Test.74 Test.263;
-    ret Test.262;
+procedure Test.24 (Test.78, Test.79):
+    let Test.285 : Str = CallByName Test.20 Test.78;
+    let Test.262 : List Str = CallByName List.13 Test.79 Test.285;
+    let Test.261 : {List Str, {}} = CallByName Test.23 Test.262;
+    dec Test.262;
+    ret Test.261;
 
-procedure Test.23 (Test.77, Test.78):
-    let Test.284 : Str = CallByName Test.19 Test.77;
-    let Test.261 : List Str = CallByName List.13 Test.78 Test.284;
-    let Test.260 : {List Str, {}} = CallByName Test.22 Test.261;
-    dec Test.261;
-    ret Test.260;
+procedure Test.3 ():
+    let Test.259 : {} = Struct {};
+    ret Test.259;
 
-procedure Test.3 (Test.48, Test.49, Test.50):
-    let Test.282 : U8 = CallByName Num.127 Test.49;
-    let Test.279 : List U8 = CallByName List.4 Test.48 Test.282;
-    let Test.281 : Str = CallByName Num.96 Test.50;
-    let Test.280 : List U8 = CallByName Str.12 Test.281;
-    let Test.277 : List U8 = CallByName List.8 Test.279 Test.280;
-    let Test.278 : U8 = 32i64;
-    let Test.276 : List U8 = CallByName List.4 Test.277 Test.278;
-    ret Test.276;
+procedure Test.4 (Test.49, Test.50, Test.51):
+    let Test.283 : U8 = CallByName Num.127 Test.50;
+    let Test.280 : List U8 = CallByName List.4 Test.49 Test.283;
+    let Test.282 : Str = CallByName Num.96 Test.51;
+    let Test.281 : List U8 = CallByName Str.12 Test.282;
+    let Test.278 : List U8 = CallByName List.8 Test.280 Test.281;
+    let Test.279 : U8 = 32i64;
+    let Test.277 : List U8 = CallByName List.4 Test.278 Test.279;
+    ret Test.277;
 
-procedure Test.56 (Test.57, Test.287, Test.55):
-    let Test.294 : I64 = 115i64;
-    let Test.295 : U64 = CallByName Str.36 Test.55;
-    let Test.292 : List U8 = CallByName Test.3 Test.57 Test.294 Test.295;
-    let Test.293 : List U8 = CallByName Str.12 Test.55;
-    let Test.290 : List U8 = CallByName List.8 Test.292 Test.293;
-    let Test.291 : U8 = 32i64;
-    let Test.289 : List U8 = CallByName List.4 Test.290 Test.291;
-    ret Test.289;
+procedure Test.57 (Test.58, Test.288, Test.56):
+    let Test.295 : I64 = 115i64;
+    let Test.296 : U64 = CallByName Str.36 Test.56;
+    let Test.293 : List U8 = CallByName Test.4 Test.58 Test.295 Test.296;
+    let Test.294 : List U8 = CallByName Str.12 Test.56;
+    let Test.291 : List U8 = CallByName List.8 Test.293 Test.294;
+    let Test.292 : U8 = 32i64;
+    let Test.290 : List U8 = CallByName List.4 Test.291 Test.292;
+    ret Test.290;
 
-procedure Test.60 (Test.61, Test.266, #Attr.12):
-    let Test.59 : {} = StructAtIndex 1 #Attr.12;
-    let Test.58 : List Str = StructAtIndex 0 #Attr.12;
-    let Test.274 : I64 = 108i64;
-    let Test.275 : U64 = CallByName List.6 Test.58;
-    let Test.62 : List U8 = CallByName Test.3 Test.61 Test.274 Test.275;
-    let Test.268 : List U8 = CallByName List.18 Test.58 Test.62 Test.59;
-    dec Test.58;
-    ret Test.268;
+procedure Test.61 (Test.62, Test.267, #Attr.12):
+    let Test.60 : {} = StructAtIndex 1 #Attr.12;
+    let Test.59 : List Str = StructAtIndex 0 #Attr.12;
+    let Test.275 : I64 = 108i64;
+    let Test.276 : U64 = CallByName List.6 Test.59;
+    let Test.63 : List U8 = CallByName Test.4 Test.62 Test.275 Test.276;
+    let Test.269 : List U8 = CallByName List.18 Test.59 Test.63 Test.60;
+    dec Test.59;
+    ret Test.269;
 
-procedure Test.63 (Test.64, Test.65, Test.59):
-    let Test.272 : Str = CallByName Test.75 Test.65;
-    let Test.273 : {} = Struct {};
-    let Test.271 : List U8 = CallByName Encode.24 Test.64 Test.272 Test.273;
-    ret Test.271;
+procedure Test.64 (Test.65, Test.66, Test.60):
+    let Test.273 : Str = CallByName Test.76 Test.66;
+    let Test.274 : {} = Struct {};
+    let Test.272 : List U8 = CallByName Encode.24 Test.65 Test.273 Test.274;
+    ret Test.272;
 
-procedure Test.75 (Test.76):
-    ret Test.76;
+procedure Test.76 (Test.77):
+    ret Test.77;
 
 procedure Test.0 ():
-    let Test.259 : Str = "foo";
-    let Test.257 : {} = CallByName Test.2;
-    let Test.256 : List U8 = CallByName Encode.26 Test.259 Test.257;
-    let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.256;
-    let Test.253 : U8 = 1i64;
-    let Test.254 : U8 = GetTagId Test.210;
-    let Test.255 : Int1 = lowlevel Eq Test.253 Test.254;
-    if Test.255 then
-        let Test.212 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
-        ret Test.212;
+    let Test.260 : Str = "foo";
+    let Test.258 : {} = CallByName Test.3;
+    let Test.257 : List U8 = CallByName Encode.26 Test.260 Test.258;
+    let Test.211 : [C {U64, U8}, C Str] = CallByName Str.9 Test.257;
+    let Test.254 : U8 = 1i64;
+    let Test.255 : U8 = GetTagId Test.211;
+    let Test.256 : Int1 = lowlevel Eq Test.254 Test.255;
+    if Test.256 then
+        let Test.213 : Str = UnionAtIndex (Id 1) (Index 0) Test.211;
+        ret Test.213;
     else
-        dec Test.210;
-        let Test.252 : Str = "<bad>";
-        ret Test.252;
+        dec Test.211;
+        let Test.253 : Str = "<bad>";
+        ret Test.253;

crates/compiler/test_mono/generated/encode_derived_tag_two_payloads_string.txt

@@ -10,215 +10,215 @@ procedure #Derived.4 (#Derived.5, #Derived.6, #Derived.1):
     let #Derived.2 : Str = StructAtIndex 0 #Derived.1;
     let #Derived.3 : Str = StructAtIndex 1 #Derived.1;
     let #Derived_gen.7 : Str = "A";
-    let #Derived_gen.9 : Str = CallByName Test.19 #Derived.2;
-    let #Derived_gen.10 : Str = CallByName Test.19 #Derived.3;
+    let #Derived_gen.9 : Str = CallByName Test.20 #Derived.2;
+    let #Derived_gen.10 : Str = CallByName Test.20 #Derived.3;
     let #Derived_gen.8 : List Str = Array [#Derived_gen.9, #Derived_gen.10];
-    let #Derived_gen.6 : {List Str, {}} = CallByName Test.23 #Derived_gen.7 #Derived_gen.8;
+    let #Derived_gen.6 : {List Str, {}} = CallByName Test.24 #Derived_gen.7 #Derived_gen.8;
     jump #Derived_gen.5 #Derived_gen.6;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.23 (Encode.98):
-    ret Encode.98;
+procedure Encode.23 (Encode.100):
+    ret Encode.100;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.111 : List U8 = CallByName #Derived.4 Encode.99 Encode.101 Encode.107;
-    ret Encode.111;
-
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.113 : List U8 = CallByName Test.60 Encode.99 Encode.101 Encode.107;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.113 : List U8 = CallByName #Derived.4 Encode.101 Encode.103 Encode.109;
     ret Encode.113;
 
-procedure Encode.24 (Encode.99, Encode.107, Encode.101):
-    let Encode.118 : List U8 = CallByName Test.56 Encode.99 Encode.101 Encode.107;
-    ret Encode.118;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.115 : List U8 = CallByName Test.61 Encode.101 Encode.103 Encode.109;
+    ret Encode.115;
 
-procedure Encode.26 (Encode.105, Encode.106):
-    let Encode.109 : List U8 = Array [];
-    let Encode.110 : {Str, Str} = CallByName #Derived.0 Encode.105;
-    let Encode.108 : List U8 = CallByName Encode.24 Encode.109 Encode.110 Encode.106;
-    ret Encode.108;
+procedure Encode.24 (Encode.101, Encode.109, Encode.103):
+    let Encode.120 : List U8 = CallByName Test.57 Encode.101 Encode.103 Encode.109;
+    ret Encode.120;
+
+procedure Encode.26 (Encode.107, Encode.108):
+    let Encode.111 : List U8 = Array [];
+    let Encode.112 : {Str, Str} = CallByName #Derived.0 Encode.107;
+    let Encode.110 : List U8 = CallByName Encode.24 Encode.111 Encode.112 Encode.108;
+    ret Encode.110;
 
 procedure List.13 (#Attr.2, #Attr.3):
-    let List.648 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
-    ret List.648;
+    let List.651 : List Str = lowlevel ListPrepend #Attr.2 #Attr.3;
+    ret List.651;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : List U8 = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : List U8 = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
-procedure List.4 (List.127, List.128):
-    let List.644 : U64 = 1i64;
-    let List.643 : List U8 = CallByName List.70 List.127 List.644;
-    let List.642 : List U8 = CallByName List.71 List.643 List.128;
-    ret List.642;
+procedure List.4 (List.130, List.131):
+    let List.647 : U64 = 1i64;
+    let List.646 : List U8 = CallByName List.70 List.130 List.647;
+    let List.645 : List U8 = CallByName List.71 List.646 List.131;
+    ret List.645;
 
 procedure List.6 (#Attr.2):
-    let List.647 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.647;
+    let List.650 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.650;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
 procedure List.70 (#Attr.2, #Attr.3):
-    let List.638 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
-    ret List.638;
+    let List.641 : List U8 = lowlevel ListReserve #Attr.2 #Attr.3;
+    ret List.641;
 
 procedure List.71 (#Attr.2, #Attr.3):
-    let List.636 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.636;
+    let List.639 : List U8 = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.639;
 
 procedure List.8 (#Attr.2, #Attr.3):
-    let List.646 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
-    ret List.646;
+    let List.649 : List U8 = lowlevel ListConcat #Attr.2 #Attr.3;
+    ret List.649;
 
-procedure List.92 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : Str = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : List U8 = CallByName Test.63 List.167 List.631 List.168;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14, #Derived_gen.15):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : Str = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : List U8 = CallByName Test.64 List.170 List.634 List.171;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.14;
-    jump List.625 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
+    inc #Derived_gen.11;
+    jump List.628 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15;
 
 procedure Num.127 (#Attr.2):
-    let Num.280 : U8 = lowlevel NumIntCast #Attr.2;
-    ret Num.280;
-
-procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    let Num.282 : 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.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.96 (#Attr.2):
-    let Num.279 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.279;
+    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.281;
 
 procedure Str.12 (#Attr.2):
-    let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.241;
+    let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.245;
 
 procedure Str.36 (#Attr.2):
-    let Str.242 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
-    ret Str.242;
+    let Str.246 : U64 = lowlevel StrCountUtf8Bytes #Attr.2;
+    ret Str.246;
 
 procedure Str.43 (#Attr.2):
-    let Str.239 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
-    ret Str.239;
+    let Str.243 : {U64, Str, Int1, U8} = lowlevel StrFromUtf8 #Attr.2;
+    ret Str.243;
 
-procedure Str.9 (Str.67):
-    let Str.68 : {U64, Str, Int1, U8} = CallByName Str.43 Str.67;
-    let Str.236 : Int1 = StructAtIndex 2 Str.68;
-    if Str.236 then
-        let Str.238 : Str = StructAtIndex 1 Str.68;
-        let Str.237 : [C {U64, U8}, C Str] = TagId(1) Str.238;
-        ret Str.237;
+procedure Str.9 (Str.71):
+    let Str.72 : {U64, Str, Int1, U8} = CallByName Str.43 Str.71;
+    let Str.240 : Int1 = StructAtIndex 2 Str.72;
+    if Str.240 then
+        let Str.242 : Str = StructAtIndex 1 Str.72;
+        let Str.241 : [C {U64, U8}, C Str] = TagId(1) Str.242;
+        ret Str.241;
     else
-        let Str.234 : U8 = StructAtIndex 3 Str.68;
-        let Str.235 : U64 = StructAtIndex 0 Str.68;
-        let #Derived_gen.28 : Str = StructAtIndex 1 Str.68;
+        let Str.238 : U8 = StructAtIndex 3 Str.72;
+        let Str.239 : U64 = StructAtIndex 0 Str.72;
+        let #Derived_gen.28 : Str = StructAtIndex 1 Str.72;
         dec #Derived_gen.28;
-        let Str.233 : {U64, U8} = Struct {Str.235, Str.234};
-        let Str.232 : [C {U64, U8}, C Str] = TagId(0) Str.233;
-        ret Str.232;
+        let Str.237 : {U64, U8} = Struct {Str.239, Str.238};
+        let Str.236 : [C {U64, U8}, C Str] = TagId(0) Str.237;
+        ret Str.236;
 
-procedure Test.19 (Test.55):
-    let Test.300 : Str = CallByName Encode.23 Test.55;
-    ret Test.300;
+procedure Test.20 (Test.56):
+    let Test.301 : Str = CallByName Encode.23 Test.56;
+    ret Test.301;
 
-procedure Test.2 ():
-    let Test.258 : {} = Struct {};
-    ret Test.258;
+procedure Test.21 (Test.59, Test.60):
+    inc Test.59;
+    let Test.267 : {List Str, {}} = Struct {Test.59, Test.60};
+    let Test.266 : {List Str, {}} = CallByName Encode.23 Test.267;
+    ret Test.266;
 
-procedure Test.20 (Test.58, Test.59):
-    inc Test.58;
-    let Test.266 : {List Str, {}} = Struct {Test.58, Test.59};
-    let Test.265 : {List Str, {}} = CallByName Encode.23 Test.266;
-    ret Test.265;
+procedure Test.23 (Test.75):
+    let Test.265 : {} = Struct {};
+    let Test.264 : {List Str, {}} = CallByName Test.21 Test.75 Test.265;
+    ret Test.264;
 
-procedure Test.22 (Test.74):
-    let Test.264 : {} = Struct {};
-    let Test.263 : {List Str, {}} = CallByName Test.20 Test.74 Test.264;
-    ret Test.263;
+procedure Test.24 (Test.78, Test.79):
+    let Test.286 : Str = CallByName Test.20 Test.78;
+    let Test.263 : List Str = CallByName List.13 Test.79 Test.286;
+    let Test.262 : {List Str, {}} = CallByName Test.23 Test.263;
+    dec Test.263;
+    ret Test.262;
 
-procedure Test.23 (Test.77, Test.78):
-    let Test.285 : Str = CallByName Test.19 Test.77;
-    let Test.262 : List Str = CallByName List.13 Test.78 Test.285;
-    let Test.261 : {List Str, {}} = CallByName Test.22 Test.262;
-    dec Test.262;
-    ret Test.261;
+procedure Test.3 ():
+    let Test.259 : {} = Struct {};
+    ret Test.259;
 
-procedure Test.3 (Test.48, Test.49, Test.50):
-    let Test.283 : U8 = CallByName Num.127 Test.49;
-    let Test.280 : List U8 = CallByName List.4 Test.48 Test.283;
-    let Test.282 : Str = CallByName Num.96 Test.50;
-    let Test.281 : List U8 = CallByName Str.12 Test.282;
-    let Test.278 : List U8 = CallByName List.8 Test.280 Test.281;
-    let Test.279 : U8 = 32i64;
-    let Test.277 : List U8 = CallByName List.4 Test.278 Test.279;
-    ret Test.277;
+procedure Test.4 (Test.49, Test.50, Test.51):
+    let Test.284 : U8 = CallByName Num.127 Test.50;
+    let Test.281 : List U8 = CallByName List.4 Test.49 Test.284;
+    let Test.283 : Str = CallByName Num.96 Test.51;
+    let Test.282 : List U8 = CallByName Str.12 Test.283;
+    let Test.279 : List U8 = CallByName List.8 Test.281 Test.282;
+    let Test.280 : U8 = 32i64;
+    let Test.278 : List U8 = CallByName List.4 Test.279 Test.280;
+    ret Test.278;
 
-procedure Test.56 (Test.57, Test.288, Test.55):
-    let Test.295 : I64 = 115i64;
-    let Test.296 : U64 = CallByName Str.36 Test.55;
-    let Test.293 : List U8 = CallByName Test.3 Test.57 Test.295 Test.296;
-    let Test.294 : List U8 = CallByName Str.12 Test.55;
-    let Test.291 : List U8 = CallByName List.8 Test.293 Test.294;
-    let Test.292 : U8 = 32i64;
-    let Test.290 : List U8 = CallByName List.4 Test.291 Test.292;
-    ret Test.290;
+procedure Test.57 (Test.58, Test.289, Test.56):
+    let Test.296 : I64 = 115i64;
+    let Test.297 : U64 = CallByName Str.36 Test.56;
+    let Test.294 : List U8 = CallByName Test.4 Test.58 Test.296 Test.297;
+    let Test.295 : List U8 = CallByName Str.12 Test.56;
+    let Test.292 : List U8 = CallByName List.8 Test.294 Test.295;
+    let Test.293 : U8 = 32i64;
+    let Test.291 : List U8 = CallByName List.4 Test.292 Test.293;
+    ret Test.291;
 
-procedure Test.60 (Test.61, Test.267, #Attr.12):
-    let Test.59 : {} = StructAtIndex 1 #Attr.12;
-    let Test.58 : List Str = StructAtIndex 0 #Attr.12;
-    let Test.275 : I64 = 108i64;
-    let Test.276 : U64 = CallByName List.6 Test.58;
-    let Test.62 : List U8 = CallByName Test.3 Test.61 Test.275 Test.276;
-    let Test.269 : List U8 = CallByName List.18 Test.58 Test.62 Test.59;
-    dec Test.58;
-    ret Test.269;
+procedure Test.61 (Test.62, Test.268, #Attr.12):
+    let Test.60 : {} = StructAtIndex 1 #Attr.12;
+    let Test.59 : List Str = StructAtIndex 0 #Attr.12;
+    let Test.276 : I64 = 108i64;
+    let Test.277 : U64 = CallByName List.6 Test.59;
+    let Test.63 : List U8 = CallByName Test.4 Test.62 Test.276 Test.277;
+    let Test.270 : List U8 = CallByName List.18 Test.59 Test.63 Test.60;
+    dec Test.59;
+    ret Test.270;
 
-procedure Test.63 (Test.64, Test.65, Test.59):
-    let Test.273 : Str = CallByName Test.75 Test.65;
-    let Test.274 : {} = Struct {};
-    let Test.272 : List U8 = CallByName Encode.24 Test.64 Test.273 Test.274;
-    ret Test.272;
+procedure Test.64 (Test.65, Test.66, Test.60):
+    let Test.274 : Str = CallByName Test.76 Test.66;
+    let Test.275 : {} = Struct {};
+    let Test.273 : List U8 = CallByName Encode.24 Test.65 Test.274 Test.275;
+    ret Test.273;
 
-procedure Test.75 (Test.76):
-    ret Test.76;
+procedure Test.76 (Test.77):
+    ret Test.77;
 
 procedure Test.0 ():
+    let Test.261 : Str = "foo";
     let Test.260 : Str = "foo";
-    let Test.259 : Str = "foo";
-    let Test.209 : {Str, Str} = Struct {Test.259, Test.260};
-    let Test.257 : {} = CallByName Test.2;
-    let Test.256 : List U8 = CallByName Encode.26 Test.209 Test.257;
-    let Test.210 : [C {U64, U8}, C Str] = CallByName Str.9 Test.256;
-    let Test.253 : U8 = 1i64;
-    let Test.254 : U8 = GetTagId Test.210;
-    let Test.255 : Int1 = lowlevel Eq Test.253 Test.254;
-    if Test.255 then
-        let Test.212 : Str = UnionAtIndex (Id 1) (Index 0) Test.210;
-        ret Test.212;
+    let Test.210 : {Str, Str} = Struct {Test.260, Test.261};
+    let Test.258 : {} = CallByName Test.3;
+    let Test.257 : List U8 = CallByName Encode.26 Test.210 Test.258;
+    let Test.211 : [C {U64, U8}, C Str] = CallByName Str.9 Test.257;
+    let Test.254 : U8 = 1i64;
+    let Test.255 : U8 = GetTagId Test.211;
+    let Test.256 : Int1 = lowlevel Eq Test.254 Test.255;
+    if Test.256 then
+        let Test.213 : Str = UnionAtIndex (Id 1) (Index 0) Test.211;
+        ret Test.213;
     else
-        dec Test.210;
-        let Test.252 : Str = "<bad>";
-        ret Test.252;
+        dec Test.211;
+        let Test.253 : Str = "<bad>";
+        ret Test.253;

crates/compiler/test_mono/generated/factorial.txt

@@ -1,10 +1,10 @@
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.280 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.279 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.281;
 
 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.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
 
 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.280 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : U8 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.282;
 
 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.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
 
 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.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.283;
 
 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.280 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Test.2 (Test.3, Test.1):
     let Test.18 : Int1 = false;

crates/compiler/test_mono/generated/inspect_derived_list.txt

@@ -3,13 +3,13 @@ procedure #Derived.0 (#Derived.1):
     ret #Derived_gen.0;
 
 procedure #Derived.3 (#Derived.2):
-    let #Derived_gen.7 : I64 = CallByName Inspect.53 #Derived.2;
+    let #Derived_gen.7 : I64 = CallByName Inspect.57 #Derived.2;
     ret #Derived_gen.7;
 
 procedure #Derived.4 (#Derived.5, #Derived.1):
     let #Derived_gen.5 : {} = Struct {};
     let #Derived_gen.6 : {} = Struct {};
-    let #Derived_gen.4 : {List I64, {}, {}} = CallByName Inspect.36 #Derived.1 #Derived_gen.5 #Derived_gen.6;
+    let #Derived_gen.4 : {List I64, {}, {}} = CallByName Inspect.40 #Derived.1 #Derived_gen.5 #Derived_gen.6;
     let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.5;
     ret #Derived_gen.3;
 
@@ -21,165 +21,165 @@ procedure Bool.2 ():
     let Bool.23 : Int1 = true;
     ret Bool.23;
 
-procedure Inspect.152 (Inspect.153, #Attr.12):
-    let Inspect.151 : {} = StructAtIndex 2 #Attr.12;
-    let Inspect.150 : {} = StructAtIndex 1 #Attr.12;
-    let Inspect.149 : List I64 = StructAtIndex 0 #Attr.12;
-    let Inspect.343 : Str = "[";
-    let Inspect.324 : Str = CallByName Inspect.59 Inspect.153 Inspect.343;
-    dec Inspect.343;
-    let Inspect.325 : {List I64, {}, {}} = Struct {Inspect.149, Inspect.150, Inspect.151};
-    let Inspect.320 : {Str, Int1} = CallByName Inspect.154 Inspect.324 Inspect.325;
-    dec Inspect.324;
-    let Inspect.321 : {} = Struct {};
-    let Inspect.316 : Str = CallByName Inspect.163 Inspect.320;
-    let Inspect.317 : Str = "]";
-    let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
-    dec Inspect.317;
-    ret Inspect.315;
-
-procedure Inspect.154 (Inspect.155, #Attr.12):
-    let Inspect.151 : {} = StructAtIndex 2 #Attr.12;
-    let Inspect.150 : {} = StructAtIndex 1 #Attr.12;
-    let Inspect.149 : List I64 = StructAtIndex 0 #Attr.12;
-    let Inspect.342 : Int1 = CallByName Bool.1;
-    inc Inspect.155;
-    let Inspect.328 : {Str, Int1} = Struct {Inspect.155, Inspect.342};
-    let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.149 Inspect.328 Inspect.151;
-    dec Inspect.149;
-    ret Inspect.327;
-
-procedure Inspect.156 (Inspect.330, Inspect.159, Inspect.151):
-    let Inspect.157 : Str = StructAtIndex 0 Inspect.330;
-    let Inspect.158 : Int1 = StructAtIndex 1 Inspect.330;
-    joinpoint Inspect.340 Inspect.160:
-        let Inspect.337 : I64 = CallByName #Derived.3 Inspect.159;
-        let Inspect.333 : Str = CallByName Inspect.31 Inspect.337 Inspect.160;
-        let Inspect.334 : {} = Struct {};
-        let Inspect.332 : {Str, Int1} = CallByName Inspect.161 Inspect.333;
-        dec Inspect.333;
-        ret Inspect.332;
-    in
-    if Inspect.158 then
-        let Inspect.341 : Str = ", ";
-        let Inspect.339 : Str = CallByName Inspect.59 Inspect.157 Inspect.341;
-        dec Inspect.341;
-        jump Inspect.340 Inspect.339;
-    else
-        jump Inspect.340 Inspect.157;
-
-procedure Inspect.161 (Inspect.162):
-    let Inspect.336 : Int1 = CallByName Bool.2;
-    inc Inspect.162;
-    let Inspect.335 : {Str, Int1} = Struct {Inspect.162, Inspect.336};
-    ret Inspect.335;
-
-procedure Inspect.163 (Inspect.322):
-    let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
-    ret Inspect.323;
-
-procedure Inspect.274 (Inspect.275, Inspect.273):
-    let Inspect.349 : Str = CallByName Num.96 Inspect.273;
-    let Inspect.348 : Str = CallByName Inspect.59 Inspect.275 Inspect.349;
-    dec Inspect.349;
-    ret Inspect.348;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.310 : Str = CallByName Inspect.152 Inspect.145 Inspect.299;
-    ret Inspect.310;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.338 : Str = CallByName Inspect.274 Inspect.145 Inspect.299;
-    ret Inspect.338;
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.36 (Inspect.149, Inspect.150, Inspect.151):
-    inc Inspect.149;
-    let Inspect.312 : {List I64, {}, {}} = Struct {Inspect.149, Inspect.150, Inspect.151};
-    let Inspect.311 : {List I64, {}, {}} = CallByName Inspect.30 Inspect.312;
-    ret Inspect.311;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : List I64 = CallByName #Derived.0 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName #Derived.4 Inspect.304 Inspect.308;
-    dec Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.53 (Inspect.273):
-    let Inspect.344 : I64 = CallByName Inspect.30 Inspect.273;
-    ret Inspect.344;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
+procedure Inspect.156 (Inspect.157, #Attr.12):
+    let Inspect.155 : {} = StructAtIndex 2 #Attr.12;
+    let Inspect.154 : {} = StructAtIndex 1 #Attr.12;
+    let Inspect.153 : List I64 = StructAtIndex 0 #Attr.12;
+    let Inspect.347 : Str = "[";
+    let Inspect.328 : Str = CallByName Inspect.63 Inspect.157 Inspect.347;
+    dec Inspect.347;
+    let Inspect.329 : {List I64, {}, {}} = Struct {Inspect.153, Inspect.154, Inspect.155};
+    let Inspect.324 : {Str, Int1} = CallByName Inspect.158 Inspect.328 Inspect.329;
+    dec Inspect.328;
+    let Inspect.325 : {} = Struct {};
+    let Inspect.320 : Str = CallByName Inspect.167 Inspect.324;
+    let Inspect.321 : Str = "]";
+    let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
+    dec Inspect.321;
     ret Inspect.319;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.158 (Inspect.159, #Attr.12):
+    let Inspect.155 : {} = StructAtIndex 2 #Attr.12;
+    let Inspect.154 : {} = StructAtIndex 1 #Attr.12;
+    let Inspect.153 : List I64 = StructAtIndex 0 #Attr.12;
+    let Inspect.346 : Int1 = CallByName Bool.1;
+    inc Inspect.159;
+    let Inspect.332 : {Str, Int1} = Struct {Inspect.159, Inspect.346};
+    let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.153 Inspect.332 Inspect.155;
+    dec Inspect.153;
+    ret Inspect.331;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Inspect.160 (Inspect.334, Inspect.163, Inspect.155):
+    let Inspect.161 : Str = StructAtIndex 0 Inspect.334;
+    let Inspect.162 : Int1 = StructAtIndex 1 Inspect.334;
+    joinpoint Inspect.344 Inspect.164:
+        let Inspect.341 : I64 = CallByName #Derived.3 Inspect.163;
+        let Inspect.337 : Str = CallByName Inspect.31 Inspect.341 Inspect.164;
+        let Inspect.338 : {} = Struct {};
+        let Inspect.336 : {Str, Int1} = CallByName Inspect.165 Inspect.337;
+        dec Inspect.337;
+        ret Inspect.336;
+    in
+    if Inspect.162 then
+        let Inspect.345 : Str = ", ";
+        let Inspect.343 : Str = CallByName Inspect.63 Inspect.161 Inspect.345;
+        dec Inspect.345;
+        jump Inspect.344 Inspect.343;
+    else
+        jump Inspect.344 Inspect.161;
+
+procedure Inspect.165 (Inspect.166):
+    let Inspect.340 : Int1 = CallByName Bool.2;
+    inc Inspect.166;
+    let Inspect.339 : {Str, Int1} = Struct {Inspect.166, Inspect.340};
+    ret Inspect.339;
+
+procedure Inspect.167 (Inspect.326):
+    let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
+    ret Inspect.327;
+
+procedure Inspect.278 (Inspect.279, Inspect.277):
+    let Inspect.353 : Str = CallByName Num.96 Inspect.277;
+    let Inspect.352 : Str = CallByName Inspect.63 Inspect.279 Inspect.353;
+    dec Inspect.353;
+    ret Inspect.352;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.314 : Str = CallByName Inspect.156 Inspect.149 Inspect.303;
+    ret Inspect.314;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.342 : Str = CallByName Inspect.278 Inspect.149 Inspect.303;
+    ret Inspect.342;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.40 (Inspect.153, Inspect.154, Inspect.155):
+    inc Inspect.153;
+    let Inspect.316 : {List I64, {}, {}} = Struct {Inspect.153, Inspect.154, Inspect.155};
+    let Inspect.315 : {List I64, {}, {}} = CallByName Inspect.30 Inspect.316;
+    ret Inspect.315;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : List I64 = CallByName #Derived.0 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName #Derived.4 Inspect.308 Inspect.312;
+    dec Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.57 (Inspect.277):
+    let Inspect.348 : I64 = CallByName Inspect.30 Inspect.277;
+    ret Inspect.348;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.323;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
-procedure List.92 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : I64 = CallByName List.66 List.166 List.169;
-            let List.171 : {Str, Int1} = CallByName Inspect.156 List.167 List.631 List.168;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22, #Derived_gen.23):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : I64 = CallByName List.66 List.169 List.172;
+            let List.174 : {Str, Int1} = CallByName Inspect.160 List.170 List.634 List.171;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
     inc #Derived_gen.19;
-    jump List.625 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
+    jump List.628 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22 #Derived_gen.23;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.280 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.96 (#Attr.2):
-    let Num.279 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.279;
+    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.281;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.0 ():
     let Test.2 : List I64 = Array [1i64, 2i64, 3i64];

crates/compiler/test_mono/generated/inspect_derived_nested_record_string.txt

@@ -7,7 +7,7 @@ procedure #Derived.2 (#Derived.3, #Derived.1):
     let #Derived_gen.8 : Str = CallByName #Derived.4 #Derived.1;
     let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
     let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
-    let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.5;
+    let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.45 #Derived_gen.5;
     let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
     dec #Derived_gen.4;
     ret #Derived_gen.3;
@@ -18,10 +18,10 @@ procedure #Derived.4 (#Derived.5):
 
 procedure #Derived.6 (#Derived.7, #Derived.5):
     let #Derived_gen.17 : Str = "b";
-    let #Derived_gen.18 : Str = CallByName Inspect.43 #Derived.5;
+    let #Derived_gen.18 : Str = CallByName Inspect.47 #Derived.5;
     let #Derived_gen.16 : {Str, Str} = Struct {#Derived_gen.17, #Derived_gen.18};
     let #Derived_gen.15 : List {Str, Str} = Array [#Derived_gen.16];
-    let #Derived_gen.14 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.15;
+    let #Derived_gen.14 : List {Str, Str} = CallByName Inspect.45 #Derived_gen.15;
     let #Derived_gen.13 : Str = CallByName Inspect.31 #Derived_gen.14 #Derived.7;
     dec #Derived_gen.14;
     ret #Derived_gen.13;
@@ -34,266 +34,266 @@ procedure Bool.2 ():
     let Bool.25 : Int1 = true;
     ret Bool.25;
 
-procedure Inspect.225 (Inspect.226, Inspect.224):
-    let Inspect.348 : Str = "{";
-    let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.348;
-    dec Inspect.348;
-    let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
-    dec Inspect.324;
-    let Inspect.321 : {} = Struct {};
-    let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
-    let Inspect.317 : Str = "}";
-    let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
-    dec Inspect.317;
-    ret Inspect.315;
+procedure Inspect.229 (Inspect.230, Inspect.228):
+    let Inspect.352 : Str = "{";
+    let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.352;
+    dec Inspect.352;
+    let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
+    dec Inspect.328;
+    let Inspect.325 : {} = Struct {};
+    let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
+    let Inspect.321 : Str = "}";
+    let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
+    dec Inspect.321;
+    ret Inspect.319;
 
-procedure Inspect.225 (Inspect.226, Inspect.224):
-    let Inspect.388 : Str = "{";
-    let Inspect.364 : Str = CallByName Inspect.59 Inspect.226 Inspect.388;
-    dec Inspect.388;
-    let Inspect.360 : {Str, Int1} = CallByName Inspect.227 Inspect.364 Inspect.224;
-    dec Inspect.364;
-    let Inspect.361 : {} = Struct {};
-    let Inspect.356 : Str = CallByName Inspect.239 Inspect.360;
-    let Inspect.357 : Str = "}";
-    let Inspect.355 : Str = CallByName Inspect.59 Inspect.356 Inspect.357;
-    dec Inspect.357;
-    ret Inspect.355;
-
-procedure Inspect.227 (Inspect.228, Inspect.224):
-    let Inspect.347 : Int1 = CallByName Bool.1;
-    inc Inspect.228;
-    let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.347};
-    let Inspect.329 : {} = Struct {};
-    let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
-    ret Inspect.327;
-
-procedure Inspect.227 (Inspect.228, Inspect.224):
-    let Inspect.387 : Int1 = CallByName Bool.1;
-    inc Inspect.228;
-    let Inspect.368 : {Str, Int1} = Struct {Inspect.228, Inspect.387};
-    let Inspect.369 : {} = Struct {};
-    let Inspect.367 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.368 Inspect.369;
-    ret Inspect.367;
-
-procedure Inspect.229 (Inspect.330, Inspect.331):
-    let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
-    let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
-    let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
-    let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
-    joinpoint Inspect.345 Inspect.234:
-        let Inspect.342 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
-        dec Inspect.232;
-        let Inspect.343 : Str = ": ";
-        let Inspect.337 : Str = CallByName Inspect.59 Inspect.342 Inspect.343;
-        dec Inspect.343;
-        let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
-        let Inspect.334 : {} = Struct {};
-        let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
-        dec Inspect.333;
-        ret Inspect.332;
-    in
-    if Inspect.231 then
-        let Inspect.346 : Str = ", ";
-        let Inspect.344 : Str = CallByName Inspect.59 Inspect.230 Inspect.346;
-        dec Inspect.346;
-        jump Inspect.345 Inspect.344;
-    else
-        jump Inspect.345 Inspect.230;
-
-procedure Inspect.229 (Inspect.330, Inspect.331):
-    let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
-    let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
-    let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
-    let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
-    joinpoint Inspect.385 Inspect.234:
-        let Inspect.382 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
-        dec Inspect.232;
-        let Inspect.383 : Str = ": ";
-        let Inspect.377 : Str = CallByName Inspect.59 Inspect.382 Inspect.383;
-        dec Inspect.383;
-        let Inspect.373 : Str = CallByName Inspect.235 Inspect.377 Inspect.233;
-        dec Inspect.233;
-        let Inspect.374 : {} = Struct {};
-        let Inspect.372 : {Str, Int1} = CallByName Inspect.237 Inspect.373;
-        dec Inspect.373;
-        ret Inspect.372;
-    in
-    if Inspect.231 then
-        let Inspect.386 : Str = ", ";
-        let Inspect.384 : Str = CallByName Inspect.59 Inspect.230 Inspect.386;
-        dec Inspect.386;
-        jump Inspect.385 Inspect.384;
-    else
-        jump Inspect.385 Inspect.230;
-
-procedure Inspect.235 (Inspect.236, Inspect.233):
-    let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
-    ret Inspect.340;
-
-procedure Inspect.235 (Inspect.236, Inspect.233):
-    let Inspect.380 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
-    ret Inspect.380;
-
-procedure Inspect.237 (Inspect.238):
-    let Inspect.376 : Int1 = CallByName Bool.2;
-    inc Inspect.238;
-    let Inspect.375 : {Str, Int1} = Struct {Inspect.238, Inspect.376};
-    ret Inspect.375;
-
-procedure Inspect.239 (Inspect.322):
-    let Inspect.363 : Str = StructAtIndex 0 Inspect.322;
-    ret Inspect.363;
-
-procedure Inspect.246 (Inspect.247, Inspect.245):
-    let Inspect.397 : Str = "\"";
-    let Inspect.396 : Str = CallByName Inspect.59 Inspect.247 Inspect.397;
-    dec Inspect.397;
-    let Inspect.394 : Str = CallByName Inspect.59 Inspect.396 Inspect.245;
-    let Inspect.395 : Str = "\"";
-    let Inspect.393 : Str = CallByName Inspect.59 Inspect.394 Inspect.395;
-    dec Inspect.395;
-    ret Inspect.393;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
-    ret Inspect.310;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.341 : Str = CallByName #Derived.6 Inspect.145 Inspect.299;
-    ret Inspect.341;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.350 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
-    ret Inspect.350;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.381 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
-    ret Inspect.381;
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.41 (Inspect.224):
-    let Inspect.311 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
-    ret Inspect.311;
-
-procedure Inspect.41 (Inspect.224):
-    let Inspect.351 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
-    ret Inspect.351;
-
-procedure Inspect.43 (Inspect.245):
-    let Inspect.389 : Str = CallByName Inspect.30 Inspect.245;
-    ret Inspect.389;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : Str = CallByName #Derived.0 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.359 : Str = CallByName Str.3 Inspect.296 Inspect.292;
+procedure Inspect.229 (Inspect.230, Inspect.228):
+    let Inspect.392 : Str = "{";
+    let Inspect.368 : Str = CallByName Inspect.63 Inspect.230 Inspect.392;
+    dec Inspect.392;
+    let Inspect.364 : {Str, Int1} = CallByName Inspect.231 Inspect.368 Inspect.228;
+    dec Inspect.368;
+    let Inspect.365 : {} = Struct {};
+    let Inspect.360 : Str = CallByName Inspect.243 Inspect.364;
+    let Inspect.361 : Str = "}";
+    let Inspect.359 : Str = CallByName Inspect.63 Inspect.360 Inspect.361;
+    dec Inspect.361;
     ret Inspect.359;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.231 (Inspect.232, Inspect.228):
+    let Inspect.351 : Int1 = CallByName Bool.1;
+    inc Inspect.232;
+    let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.351};
+    let Inspect.333 : {} = Struct {};
+    let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
+    ret Inspect.331;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Inspect.231 (Inspect.232, Inspect.228):
+    let Inspect.391 : Int1 = CallByName Bool.1;
+    inc Inspect.232;
+    let Inspect.372 : {Str, Int1} = Struct {Inspect.232, Inspect.391};
+    let Inspect.373 : {} = Struct {};
+    let Inspect.371 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.372 Inspect.373;
+    ret Inspect.371;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.635 : U64 = 0i64;
-    let List.636 : U64 = CallByName List.6 List.163;
-    let List.634 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.635 List.636;
-    ret List.634;
+procedure Inspect.233 (Inspect.334, Inspect.335):
+    let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
+    let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
+    let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
+    let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
+    joinpoint Inspect.349 Inspect.238:
+        let Inspect.346 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
+        dec Inspect.236;
+        let Inspect.347 : Str = ": ";
+        let Inspect.341 : Str = CallByName Inspect.63 Inspect.346 Inspect.347;
+        dec Inspect.347;
+        let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
+        let Inspect.338 : {} = Struct {};
+        let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
+        dec Inspect.337;
+        ret Inspect.336;
+    in
+    if Inspect.235 then
+        let Inspect.350 : Str = ", ";
+        let Inspect.348 : Str = CallByName Inspect.63 Inspect.234 Inspect.350;
+        dec Inspect.350;
+        jump Inspect.349 Inspect.348;
+    else
+        jump Inspect.349 Inspect.234;
+
+procedure Inspect.233 (Inspect.334, Inspect.335):
+    let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
+    let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
+    let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
+    let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
+    joinpoint Inspect.389 Inspect.238:
+        let Inspect.386 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
+        dec Inspect.236;
+        let Inspect.387 : Str = ": ";
+        let Inspect.381 : Str = CallByName Inspect.63 Inspect.386 Inspect.387;
+        dec Inspect.387;
+        let Inspect.377 : Str = CallByName Inspect.239 Inspect.381 Inspect.237;
+        dec Inspect.237;
+        let Inspect.378 : {} = Struct {};
+        let Inspect.376 : {Str, Int1} = CallByName Inspect.241 Inspect.377;
+        dec Inspect.377;
+        ret Inspect.376;
+    in
+    if Inspect.235 then
+        let Inspect.390 : Str = ", ";
+        let Inspect.388 : Str = CallByName Inspect.63 Inspect.234 Inspect.390;
+        dec Inspect.390;
+        jump Inspect.389 Inspect.388;
+    else
+        jump Inspect.389 Inspect.234;
+
+procedure Inspect.239 (Inspect.240, Inspect.237):
+    let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
+    ret Inspect.344;
+
+procedure Inspect.239 (Inspect.240, Inspect.237):
+    let Inspect.384 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
+    ret Inspect.384;
+
+procedure Inspect.241 (Inspect.242):
+    let Inspect.380 : Int1 = CallByName Bool.2;
+    inc Inspect.242;
+    let Inspect.379 : {Str, Int1} = Struct {Inspect.242, Inspect.380};
+    ret Inspect.379;
+
+procedure Inspect.243 (Inspect.326):
+    let Inspect.367 : Str = StructAtIndex 0 Inspect.326;
+    ret Inspect.367;
+
+procedure Inspect.250 (Inspect.251, Inspect.249):
+    let Inspect.401 : Str = "\"";
+    let Inspect.400 : Str = CallByName Inspect.63 Inspect.251 Inspect.401;
+    dec Inspect.401;
+    let Inspect.398 : Str = CallByName Inspect.63 Inspect.400 Inspect.249;
+    let Inspect.399 : Str = "\"";
+    let Inspect.397 : Str = CallByName Inspect.63 Inspect.398 Inspect.399;
+    dec Inspect.399;
+    ret Inspect.397;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
+    ret Inspect.314;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.345 : Str = CallByName #Derived.6 Inspect.149 Inspect.303;
+    ret Inspect.345;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.354 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
+    ret Inspect.354;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.385 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
+    ret Inspect.385;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.45 (Inspect.228):
+    let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
+    ret Inspect.315;
+
+procedure Inspect.45 (Inspect.228):
+    let Inspect.355 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
+    ret Inspect.355;
+
+procedure Inspect.47 (Inspect.249):
+    let Inspect.393 : Str = CallByName Inspect.30 Inspect.249;
+    ret Inspect.393;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : Str = CallByName #Derived.0 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.363 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.363;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
+
+procedure List.18 (List.166, List.167, List.168):
+    let List.638 : U64 = 0i64;
+    let List.639 : U64 = CallByName List.6 List.166;
+    let List.637 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.638 List.639;
+    ret List.637;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.6 (#Attr.2):
-    let List.645 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.645;
+    let List.648 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.648;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.644 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.644;
+    let List.647 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.647;
 
-procedure List.92 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
-    joinpoint List.637 List.166 List.167 List.168 List.169 List.170:
-        let List.639 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.639 then
-            let List.643 : {Str, Str} = CallByName List.66 List.166 List.169;
-            inc List.643;
-            let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.643;
-            let List.642 : U64 = 1i64;
-            let List.641 : U64 = CallByName Num.51 List.169 List.642;
-            jump List.637 List.166 List.171 List.168 List.641 List.170;
+procedure List.95 (#Derived_gen.22, #Derived_gen.23, #Derived_gen.24, #Derived_gen.25, #Derived_gen.26):
+    joinpoint List.640 List.169 List.170 List.171 List.172 List.173:
+        let List.642 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.642 then
+            let List.646 : {Str, Str} = CallByName List.66 List.169 List.172;
+            inc List.646;
+            let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.646;
+            let List.645 : U64 = 1i64;
+            let List.644 : U64 = CallByName Num.51 List.172 List.645;
+            jump List.640 List.169 List.174 List.171 List.644 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.26;
-    jump List.637 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
+    inc #Derived_gen.22;
+    jump List.640 #Derived_gen.22 #Derived_gen.23 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26;
 
-procedure List.92 (#Derived_gen.39, #Derived_gen.40, #Derived_gen.41, #Derived_gen.42, #Derived_gen.43):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46, #Derived_gen.47):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.39;
-    jump List.625 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41 #Derived_gen.42 #Derived_gen.43;
+    inc #Derived_gen.43;
+    jump List.628 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46 #Derived_gen.47;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.284;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.233 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.233;
+    let Str.237 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.237;
 
 procedure Test.0 ():
     let Test.4 : Str = "bar";

crates/compiler/test_mono/generated/inspect_derived_record.txt

@@ -4,15 +4,15 @@ procedure #Derived.0 (#Derived.1):
 
 procedure #Derived.2 (#Derived.3, #Derived.1):
     let #Derived_gen.13 : I64 = StructAtIndex 1 #Derived.1;
-    let #Derived_gen.11 : [C I64, C Decimal] = CallByName Inspect.53 #Derived_gen.13;
+    let #Derived_gen.11 : [C I64, C Decimal] = CallByName Inspect.57 #Derived_gen.13;
     let #Derived_gen.12 : Str = "a";
     let #Derived_gen.6 : {[C I64, C Decimal], Str} = Struct {#Derived_gen.11, #Derived_gen.12};
     let #Derived_gen.10 : Decimal = StructAtIndex 0 #Derived.1;
-    let #Derived_gen.8 : [C I64, C Decimal] = CallByName Inspect.58 #Derived_gen.10;
+    let #Derived_gen.8 : [C I64, C Decimal] = CallByName Inspect.62 #Derived_gen.10;
     let #Derived_gen.9 : Str = "b";
     let #Derived_gen.7 : {[C I64, C Decimal], Str} = Struct {#Derived_gen.8, #Derived_gen.9};
     let #Derived_gen.5 : List {[C I64, C Decimal], Str} = Array [#Derived_gen.6, #Derived_gen.7];
-    let #Derived_gen.4 : List {[C I64, C Decimal], Str} = CallByName Inspect.41 #Derived_gen.5;
+    let #Derived_gen.4 : List {[C I64, C Decimal], Str} = CallByName Inspect.45 #Derived_gen.5;
     let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
     dec #Derived_gen.4;
     ret #Derived_gen.3;
@@ -25,192 +25,192 @@ procedure Bool.2 ():
     let Bool.23 : Int1 = true;
     ret Bool.23;
 
-procedure Inspect.225 (Inspect.226, Inspect.224):
-    let Inspect.349 : Str = "{";
-    let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.349;
-    dec Inspect.349;
-    let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
-    dec Inspect.324;
-    let Inspect.321 : {} = Struct {};
-    let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
-    let Inspect.317 : Str = "}";
-    let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
-    dec Inspect.317;
-    ret Inspect.315;
-
-procedure Inspect.227 (Inspect.228, Inspect.224):
-    let Inspect.348 : Int1 = CallByName Bool.1;
-    inc Inspect.228;
-    let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.348};
-    let Inspect.329 : {} = Struct {};
-    let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
-    ret Inspect.327;
-
-procedure Inspect.229 (Inspect.330, Inspect.331):
-    let Inspect.233 : [C I64, C Decimal] = StructAtIndex 0 Inspect.331;
-    let Inspect.232 : Str = StructAtIndex 1 Inspect.331;
-    let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
-    let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
-    joinpoint Inspect.346 Inspect.234:
-        let Inspect.343 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
-        dec Inspect.232;
-        let Inspect.344 : Str = ": ";
-        let Inspect.337 : Str = CallByName Inspect.59 Inspect.343 Inspect.344;
-        dec Inspect.344;
-        let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
-        let Inspect.334 : {} = Struct {};
-        let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
-        dec Inspect.333;
-        ret Inspect.332;
-    in
-    if Inspect.231 then
-        let Inspect.347 : Str = ", ";
-        let Inspect.345 : Str = CallByName Inspect.59 Inspect.230 Inspect.347;
-        dec Inspect.347;
-        jump Inspect.346 Inspect.345;
-    else
-        jump Inspect.346 Inspect.230;
-
-procedure Inspect.235 (Inspect.236, Inspect.233):
-    let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
-    ret Inspect.340;
-
-procedure Inspect.237 (Inspect.238):
-    let Inspect.336 : Int1 = CallByName Bool.2;
-    inc Inspect.238;
-    let Inspect.335 : {Str, Int1} = Struct {Inspect.238, Inspect.336};
-    ret Inspect.335;
-
-procedure Inspect.239 (Inspect.322):
-    let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
-    ret Inspect.323;
-
-procedure Inspect.274 (Inspect.275, #Attr.12):
-    let Inspect.362 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    let Inspect.361 : Str = CallByName Num.96 Inspect.362;
-    let Inspect.360 : Str = CallByName Inspect.59 Inspect.275 Inspect.361;
-    dec Inspect.361;
-    ret Inspect.360;
-
-procedure Inspect.289 (Inspect.290, #Attr.12):
-    let Inspect.356 : Decimal = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-    let Inspect.355 : Str = CallByName Num.96 Inspect.356;
-    let Inspect.354 : Str = CallByName Inspect.59 Inspect.290 Inspect.355;
-    dec Inspect.355;
-    ret Inspect.354;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
-    ret Inspect.310;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.342 : U8 = GetTagId Inspect.299;
-    switch Inspect.342:
-        case 0:
-            let Inspect.341 : Str = CallByName Inspect.274 Inspect.145 Inspect.299;
-            ret Inspect.341;
-    
-        default:
-            let Inspect.341 : Str = CallByName Inspect.289 Inspect.145 Inspect.299;
-            ret Inspect.341;
-    
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.41 (Inspect.224):
-    let Inspect.311 : List {[C I64, C Decimal], Str} = CallByName Inspect.30 Inspect.224;
-    ret Inspect.311;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : {Decimal, I64} = CallByName #Derived.0 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.53 (Inspect.273):
-    let Inspect.358 : [C I64, C Decimal] = TagId(0) Inspect.273;
-    let Inspect.357 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.358;
-    ret Inspect.357;
-
-procedure Inspect.58 (Inspect.288):
-    let Inspect.351 : [C I64, C Decimal] = TagId(1) Inspect.288;
-    let Inspect.350 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.351;
-    ret Inspect.350;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
+procedure Inspect.229 (Inspect.230, Inspect.228):
+    let Inspect.353 : Str = "{";
+    let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.353;
+    dec Inspect.353;
+    let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
+    dec Inspect.328;
+    let Inspect.325 : {} = Struct {};
+    let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
+    let Inspect.321 : Str = "}";
+    let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
+    dec Inspect.321;
     ret Inspect.319;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.231 (Inspect.232, Inspect.228):
+    let Inspect.352 : Int1 = CallByName Bool.1;
+    inc Inspect.232;
+    let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.352};
+    let Inspect.333 : {} = Struct {};
+    let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
+    ret Inspect.331;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Inspect.233 (Inspect.334, Inspect.335):
+    let Inspect.237 : [C I64, C Decimal] = StructAtIndex 0 Inspect.335;
+    let Inspect.236 : Str = StructAtIndex 1 Inspect.335;
+    let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
+    let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
+    joinpoint Inspect.350 Inspect.238:
+        let Inspect.347 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
+        dec Inspect.236;
+        let Inspect.348 : Str = ": ";
+        let Inspect.341 : Str = CallByName Inspect.63 Inspect.347 Inspect.348;
+        dec Inspect.348;
+        let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
+        let Inspect.338 : {} = Struct {};
+        let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
+        dec Inspect.337;
+        ret Inspect.336;
+    in
+    if Inspect.235 then
+        let Inspect.351 : Str = ", ";
+        let Inspect.349 : Str = CallByName Inspect.63 Inspect.234 Inspect.351;
+        dec Inspect.351;
+        jump Inspect.350 Inspect.349;
+    else
+        jump Inspect.350 Inspect.234;
+
+procedure Inspect.239 (Inspect.240, Inspect.237):
+    let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
+    ret Inspect.344;
+
+procedure Inspect.241 (Inspect.242):
+    let Inspect.340 : Int1 = CallByName Bool.2;
+    inc Inspect.242;
+    let Inspect.339 : {Str, Int1} = Struct {Inspect.242, Inspect.340};
+    ret Inspect.339;
+
+procedure Inspect.243 (Inspect.326):
+    let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
+    ret Inspect.327;
+
+procedure Inspect.278 (Inspect.279, #Attr.12):
+    let Inspect.366 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
+    let Inspect.365 : Str = CallByName Num.96 Inspect.366;
+    let Inspect.364 : Str = CallByName Inspect.63 Inspect.279 Inspect.365;
+    dec Inspect.365;
+    ret Inspect.364;
+
+procedure Inspect.293 (Inspect.294, #Attr.12):
+    let Inspect.360 : Decimal = UnionAtIndex (Id 1) (Index 0) #Attr.12;
+    let Inspect.359 : Str = CallByName Num.96 Inspect.360;
+    let Inspect.358 : Str = CallByName Inspect.63 Inspect.294 Inspect.359;
+    dec Inspect.359;
+    ret Inspect.358;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
+    ret Inspect.314;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.346 : U8 = GetTagId Inspect.303;
+    switch Inspect.346:
+        case 0:
+            let Inspect.345 : Str = CallByName Inspect.278 Inspect.149 Inspect.303;
+            ret Inspect.345;
+    
+        default:
+            let Inspect.345 : Str = CallByName Inspect.293 Inspect.149 Inspect.303;
+            ret Inspect.345;
+    
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.45 (Inspect.228):
+    let Inspect.315 : List {[C I64, C Decimal], Str} = CallByName Inspect.30 Inspect.228;
+    ret Inspect.315;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : {Decimal, I64} = CallByName #Derived.0 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.57 (Inspect.277):
+    let Inspect.362 : [C I64, C Decimal] = TagId(0) Inspect.277;
+    let Inspect.361 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.362;
+    ret Inspect.361;
+
+procedure Inspect.62 (Inspect.292):
+    let Inspect.355 : [C I64, C Decimal] = TagId(1) Inspect.292;
+    let Inspect.354 : [C I64, C Decimal] = CallByName Inspect.30 Inspect.355;
+    ret Inspect.354;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.323;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : {[C I64, C Decimal], Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : {[C I64, C Decimal], Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
-procedure List.92 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : {[C I64, C Decimal], Str} = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29, #Derived_gen.30):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : {[C I64, C Decimal], Str} = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
     inc #Derived_gen.26;
-    jump List.625 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
+    jump List.628 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29 #Derived_gen.30;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.282;
+    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    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.283;
+
+procedure Num.96 (#Attr.2):
+    let Num.281 : Str = lowlevel NumToStr #Attr.2;
     ret Num.281;
 
 procedure Num.96 (#Attr.2):
-    let Num.279 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.279;
-
-procedure Num.96 (#Attr.2):
-    let Num.280 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.280;
+    let Num.282 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.282;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.0 ():
     let Test.3 : Decimal = 3dec;

crates/compiler/test_mono/generated/inspect_derived_record_one_field_string.txt

@@ -4,10 +4,10 @@ procedure #Derived.0 (#Derived.1):
 
 procedure #Derived.2 (#Derived.3, #Derived.1):
     let #Derived_gen.7 : Str = "a";
-    let #Derived_gen.8 : Str = CallByName Inspect.43 #Derived.1;
+    let #Derived_gen.8 : Str = CallByName Inspect.47 #Derived.1;
     let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.7, #Derived_gen.8};
     let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6];
-    let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.5;
+    let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.45 #Derived_gen.5;
     let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
     dec #Derived_gen.4;
     ret #Derived_gen.3;
@@ -20,167 +20,167 @@ procedure Bool.2 ():
     let Bool.23 : Int1 = true;
     ret Bool.23;
 
-procedure Inspect.225 (Inspect.226, Inspect.224):
-    let Inspect.348 : Str = "{";
-    let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.348;
-    dec Inspect.348;
-    let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
-    dec Inspect.324;
-    let Inspect.321 : {} = Struct {};
-    let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
-    let Inspect.317 : Str = "}";
-    let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
-    dec Inspect.317;
-    ret Inspect.315;
-
-procedure Inspect.227 (Inspect.228, Inspect.224):
-    let Inspect.347 : Int1 = CallByName Bool.1;
-    inc Inspect.228;
-    let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.347};
-    let Inspect.329 : {} = Struct {};
-    let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
-    ret Inspect.327;
-
-procedure Inspect.229 (Inspect.330, Inspect.331):
-    let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
-    let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
-    let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
-    let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
-    joinpoint Inspect.345 Inspect.234:
-        let Inspect.342 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
-        dec Inspect.232;
-        let Inspect.343 : Str = ": ";
-        let Inspect.337 : Str = CallByName Inspect.59 Inspect.342 Inspect.343;
-        dec Inspect.343;
-        let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
-        dec Inspect.233;
-        let Inspect.334 : {} = Struct {};
-        let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
-        dec Inspect.333;
-        ret Inspect.332;
-    in
-    if Inspect.231 then
-        let Inspect.346 : Str = ", ";
-        let Inspect.344 : Str = CallByName Inspect.59 Inspect.230 Inspect.346;
-        dec Inspect.346;
-        jump Inspect.345 Inspect.344;
-    else
-        jump Inspect.345 Inspect.230;
-
-procedure Inspect.235 (Inspect.236, Inspect.233):
-    let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
-    ret Inspect.340;
-
-procedure Inspect.237 (Inspect.238):
-    let Inspect.336 : Int1 = CallByName Bool.2;
-    inc Inspect.238;
-    let Inspect.335 : {Str, Int1} = Struct {Inspect.238, Inspect.336};
-    ret Inspect.335;
-
-procedure Inspect.239 (Inspect.322):
-    let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
-    ret Inspect.323;
-
-procedure Inspect.246 (Inspect.247, Inspect.245):
-    let Inspect.357 : Str = "\"";
-    let Inspect.356 : Str = CallByName Inspect.59 Inspect.247 Inspect.357;
-    dec Inspect.357;
-    let Inspect.354 : Str = CallByName Inspect.59 Inspect.356 Inspect.245;
-    let Inspect.355 : Str = "\"";
-    let Inspect.353 : Str = CallByName Inspect.59 Inspect.354 Inspect.355;
-    dec Inspect.355;
-    ret Inspect.353;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
-    ret Inspect.310;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.341 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
-    ret Inspect.341;
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.41 (Inspect.224):
-    let Inspect.311 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
-    ret Inspect.311;
-
-procedure Inspect.43 (Inspect.245):
-    let Inspect.349 : Str = CallByName Inspect.30 Inspect.245;
-    ret Inspect.349;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : Str = CallByName #Derived.0 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
+procedure Inspect.229 (Inspect.230, Inspect.228):
+    let Inspect.352 : Str = "{";
+    let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.352;
+    dec Inspect.352;
+    let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
+    dec Inspect.328;
+    let Inspect.325 : {} = Struct {};
+    let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
+    let Inspect.321 : Str = "}";
+    let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
+    dec Inspect.321;
     ret Inspect.319;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.231 (Inspect.232, Inspect.228):
+    let Inspect.351 : Int1 = CallByName Bool.1;
+    inc Inspect.232;
+    let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.351};
+    let Inspect.333 : {} = Struct {};
+    let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
+    ret Inspect.331;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Inspect.233 (Inspect.334, Inspect.335):
+    let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
+    let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
+    let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
+    let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
+    joinpoint Inspect.349 Inspect.238:
+        let Inspect.346 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
+        dec Inspect.236;
+        let Inspect.347 : Str = ": ";
+        let Inspect.341 : Str = CallByName Inspect.63 Inspect.346 Inspect.347;
+        dec Inspect.347;
+        let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
+        dec Inspect.237;
+        let Inspect.338 : {} = Struct {};
+        let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
+        dec Inspect.337;
+        ret Inspect.336;
+    in
+    if Inspect.235 then
+        let Inspect.350 : Str = ", ";
+        let Inspect.348 : Str = CallByName Inspect.63 Inspect.234 Inspect.350;
+        dec Inspect.350;
+        jump Inspect.349 Inspect.348;
+    else
+        jump Inspect.349 Inspect.234;
+
+procedure Inspect.239 (Inspect.240, Inspect.237):
+    let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
+    ret Inspect.344;
+
+procedure Inspect.241 (Inspect.242):
+    let Inspect.340 : Int1 = CallByName Bool.2;
+    inc Inspect.242;
+    let Inspect.339 : {Str, Int1} = Struct {Inspect.242, Inspect.340};
+    ret Inspect.339;
+
+procedure Inspect.243 (Inspect.326):
+    let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
+    ret Inspect.327;
+
+procedure Inspect.250 (Inspect.251, Inspect.249):
+    let Inspect.361 : Str = "\"";
+    let Inspect.360 : Str = CallByName Inspect.63 Inspect.251 Inspect.361;
+    dec Inspect.361;
+    let Inspect.358 : Str = CallByName Inspect.63 Inspect.360 Inspect.249;
+    let Inspect.359 : Str = "\"";
+    let Inspect.357 : Str = CallByName Inspect.63 Inspect.358 Inspect.359;
+    dec Inspect.359;
+    ret Inspect.357;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
+    ret Inspect.314;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.345 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
+    ret Inspect.345;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.45 (Inspect.228):
+    let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
+    ret Inspect.315;
+
+procedure Inspect.47 (Inspect.249):
+    let Inspect.353 : Str = CallByName Inspect.30 Inspect.249;
+    ret Inspect.353;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : Str = CallByName #Derived.0 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.323;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
-procedure List.92 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.10;
-    jump List.625 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
+    inc #Derived_gen.14;
+    jump List.628 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.0 ():
     let Test.3 : Str = "foo";

crates/compiler/test_mono/generated/inspect_derived_record_two_field_strings.txt

@@ -6,15 +6,15 @@ procedure #Derived.2 (#Derived.3, #Derived.1):
     let #Derived_gen.11 : Str = "a";
     let #Derived_gen.13 : Str = StructAtIndex 0 #Derived.1;
     inc #Derived_gen.13;
-    let #Derived_gen.12 : Str = CallByName Inspect.43 #Derived_gen.13;
+    let #Derived_gen.12 : Str = CallByName Inspect.47 #Derived_gen.13;
     let #Derived_gen.6 : {Str, Str} = Struct {#Derived_gen.11, #Derived_gen.12};
     let #Derived_gen.8 : Str = "b";
     let #Derived_gen.10 : Str = StructAtIndex 1 #Derived.1;
     dec #Derived_gen.13;
-    let #Derived_gen.9 : Str = CallByName Inspect.43 #Derived_gen.10;
+    let #Derived_gen.9 : Str = CallByName Inspect.47 #Derived_gen.10;
     let #Derived_gen.7 : {Str, Str} = Struct {#Derived_gen.8, #Derived_gen.9};
     let #Derived_gen.5 : List {Str, Str} = Array [#Derived_gen.6, #Derived_gen.7];
-    let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.41 #Derived_gen.5;
+    let #Derived_gen.4 : List {Str, Str} = CallByName Inspect.45 #Derived_gen.5;
     let #Derived_gen.3 : Str = CallByName Inspect.31 #Derived_gen.4 #Derived.3;
     dec #Derived_gen.4;
     ret #Derived_gen.3;
@@ -27,167 +27,167 @@ procedure Bool.2 ():
     let Bool.23 : Int1 = true;
     ret Bool.23;
 
-procedure Inspect.225 (Inspect.226, Inspect.224):
-    let Inspect.348 : Str = "{";
-    let Inspect.324 : Str = CallByName Inspect.59 Inspect.226 Inspect.348;
-    dec Inspect.348;
-    let Inspect.320 : {Str, Int1} = CallByName Inspect.227 Inspect.324 Inspect.224;
-    dec Inspect.324;
-    let Inspect.321 : {} = Struct {};
-    let Inspect.316 : Str = CallByName Inspect.239 Inspect.320;
-    let Inspect.317 : Str = "}";
-    let Inspect.315 : Str = CallByName Inspect.59 Inspect.316 Inspect.317;
-    dec Inspect.317;
-    ret Inspect.315;
-
-procedure Inspect.227 (Inspect.228, Inspect.224):
-    let Inspect.347 : Int1 = CallByName Bool.1;
-    inc Inspect.228;
-    let Inspect.328 : {Str, Int1} = Struct {Inspect.228, Inspect.347};
-    let Inspect.329 : {} = Struct {};
-    let Inspect.327 : {Str, Int1} = CallByName List.18 Inspect.224 Inspect.328 Inspect.329;
-    ret Inspect.327;
-
-procedure Inspect.229 (Inspect.330, Inspect.331):
-    let Inspect.232 : Str = StructAtIndex 0 Inspect.331;
-    let Inspect.233 : Str = StructAtIndex 1 Inspect.331;
-    let Inspect.230 : Str = StructAtIndex 0 Inspect.330;
-    let Inspect.231 : Int1 = StructAtIndex 1 Inspect.330;
-    joinpoint Inspect.345 Inspect.234:
-        let Inspect.342 : Str = CallByName Inspect.59 Inspect.234 Inspect.232;
-        dec Inspect.232;
-        let Inspect.343 : Str = ": ";
-        let Inspect.337 : Str = CallByName Inspect.59 Inspect.342 Inspect.343;
-        dec Inspect.343;
-        let Inspect.333 : Str = CallByName Inspect.235 Inspect.337 Inspect.233;
-        dec Inspect.233;
-        let Inspect.334 : {} = Struct {};
-        let Inspect.332 : {Str, Int1} = CallByName Inspect.237 Inspect.333;
-        dec Inspect.333;
-        ret Inspect.332;
-    in
-    if Inspect.231 then
-        let Inspect.346 : Str = ", ";
-        let Inspect.344 : Str = CallByName Inspect.59 Inspect.230 Inspect.346;
-        dec Inspect.346;
-        jump Inspect.345 Inspect.344;
-    else
-        jump Inspect.345 Inspect.230;
-
-procedure Inspect.235 (Inspect.236, Inspect.233):
-    let Inspect.340 : Str = CallByName Inspect.31 Inspect.233 Inspect.236;
-    ret Inspect.340;
-
-procedure Inspect.237 (Inspect.238):
-    let Inspect.336 : Int1 = CallByName Bool.2;
-    inc Inspect.238;
-    let Inspect.335 : {Str, Int1} = Struct {Inspect.238, Inspect.336};
-    ret Inspect.335;
-
-procedure Inspect.239 (Inspect.322):
-    let Inspect.323 : Str = StructAtIndex 0 Inspect.322;
-    ret Inspect.323;
-
-procedure Inspect.246 (Inspect.247, Inspect.245):
-    let Inspect.357 : Str = "\"";
-    let Inspect.356 : Str = CallByName Inspect.59 Inspect.247 Inspect.357;
-    dec Inspect.357;
-    let Inspect.354 : Str = CallByName Inspect.59 Inspect.356 Inspect.245;
-    let Inspect.355 : Str = "\"";
-    let Inspect.353 : Str = CallByName Inspect.59 Inspect.354 Inspect.355;
-    dec Inspect.355;
-    ret Inspect.353;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.310 : Str = CallByName Inspect.225 Inspect.145 Inspect.299;
-    ret Inspect.310;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.341 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
-    ret Inspect.341;
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.41 (Inspect.224):
-    let Inspect.311 : List {Str, Str} = CallByName Inspect.30 Inspect.224;
-    ret Inspect.311;
-
-procedure Inspect.43 (Inspect.245):
-    let Inspect.358 : Str = CallByName Inspect.30 Inspect.245;
-    ret Inspect.358;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : {Str, Str} = CallByName #Derived.0 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName #Derived.2 Inspect.304 Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.319 : Str = CallByName Str.3 Inspect.296 Inspect.292;
+procedure Inspect.229 (Inspect.230, Inspect.228):
+    let Inspect.352 : Str = "{";
+    let Inspect.328 : Str = CallByName Inspect.63 Inspect.230 Inspect.352;
+    dec Inspect.352;
+    let Inspect.324 : {Str, Int1} = CallByName Inspect.231 Inspect.328 Inspect.228;
+    dec Inspect.328;
+    let Inspect.325 : {} = Struct {};
+    let Inspect.320 : Str = CallByName Inspect.243 Inspect.324;
+    let Inspect.321 : Str = "}";
+    let Inspect.319 : Str = CallByName Inspect.63 Inspect.320 Inspect.321;
+    dec Inspect.321;
     ret Inspect.319;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.231 (Inspect.232, Inspect.228):
+    let Inspect.351 : Int1 = CallByName Bool.1;
+    inc Inspect.232;
+    let Inspect.332 : {Str, Int1} = Struct {Inspect.232, Inspect.351};
+    let Inspect.333 : {} = Struct {};
+    let Inspect.331 : {Str, Int1} = CallByName List.18 Inspect.228 Inspect.332 Inspect.333;
+    ret Inspect.331;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : {Str, Int1} = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Inspect.233 (Inspect.334, Inspect.335):
+    let Inspect.236 : Str = StructAtIndex 0 Inspect.335;
+    let Inspect.237 : Str = StructAtIndex 1 Inspect.335;
+    let Inspect.234 : Str = StructAtIndex 0 Inspect.334;
+    let Inspect.235 : Int1 = StructAtIndex 1 Inspect.334;
+    joinpoint Inspect.349 Inspect.238:
+        let Inspect.346 : Str = CallByName Inspect.63 Inspect.238 Inspect.236;
+        dec Inspect.236;
+        let Inspect.347 : Str = ": ";
+        let Inspect.341 : Str = CallByName Inspect.63 Inspect.346 Inspect.347;
+        dec Inspect.347;
+        let Inspect.337 : Str = CallByName Inspect.239 Inspect.341 Inspect.237;
+        dec Inspect.237;
+        let Inspect.338 : {} = Struct {};
+        let Inspect.336 : {Str, Int1} = CallByName Inspect.241 Inspect.337;
+        dec Inspect.337;
+        ret Inspect.336;
+    in
+    if Inspect.235 then
+        let Inspect.350 : Str = ", ";
+        let Inspect.348 : Str = CallByName Inspect.63 Inspect.234 Inspect.350;
+        dec Inspect.350;
+        jump Inspect.349 Inspect.348;
+    else
+        jump Inspect.349 Inspect.234;
+
+procedure Inspect.239 (Inspect.240, Inspect.237):
+    let Inspect.344 : Str = CallByName Inspect.31 Inspect.237 Inspect.240;
+    ret Inspect.344;
+
+procedure Inspect.241 (Inspect.242):
+    let Inspect.340 : Int1 = CallByName Bool.2;
+    inc Inspect.242;
+    let Inspect.339 : {Str, Int1} = Struct {Inspect.242, Inspect.340};
+    ret Inspect.339;
+
+procedure Inspect.243 (Inspect.326):
+    let Inspect.327 : Str = StructAtIndex 0 Inspect.326;
+    ret Inspect.327;
+
+procedure Inspect.250 (Inspect.251, Inspect.249):
+    let Inspect.361 : Str = "\"";
+    let Inspect.360 : Str = CallByName Inspect.63 Inspect.251 Inspect.361;
+    dec Inspect.361;
+    let Inspect.358 : Str = CallByName Inspect.63 Inspect.360 Inspect.249;
+    let Inspect.359 : Str = "\"";
+    let Inspect.357 : Str = CallByName Inspect.63 Inspect.358 Inspect.359;
+    dec Inspect.359;
+    ret Inspect.357;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.314 : Str = CallByName Inspect.229 Inspect.149 Inspect.303;
+    ret Inspect.314;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.345 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
+    ret Inspect.345;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.45 (Inspect.228):
+    let Inspect.315 : List {Str, Str} = CallByName Inspect.30 Inspect.228;
+    ret Inspect.315;
+
+procedure Inspect.47 (Inspect.249):
+    let Inspect.362 : Str = CallByName Inspect.30 Inspect.249;
+    ret Inspect.362;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : {Str, Str} = CallByName #Derived.0 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName #Derived.2 Inspect.308 Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.323 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.323;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : {Str, Int1} = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : {Str, Str} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
-procedure List.92 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : {Str, Str} = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : {Str, Int1} = CallByName Inspect.229 List.167 List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.18, #Derived_gen.19, #Derived_gen.20, #Derived_gen.21, #Derived_gen.22):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : {Str, Str} = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : {Str, Int1} = CallByName Inspect.233 List.170 List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.14;
-    jump List.625 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
+    inc #Derived_gen.18;
+    jump List.628 #Derived_gen.18 #Derived_gen.19 #Derived_gen.20 #Derived_gen.21 #Derived_gen.22;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.0 ():
     let Test.3 : Str = "foo";

crates/compiler/test_mono/generated/inspect_derived_string.txt

@@ -1,47 +1,47 @@
-procedure Inspect.246 (Inspect.247, Inspect.245):
+procedure Inspect.250 (Inspect.251, Inspect.249):
+    let Inspect.323 : Str = "\"";
+    let Inspect.322 : Str = CallByName Inspect.63 Inspect.251 Inspect.323;
+    dec Inspect.323;
+    let Inspect.318 : Str = CallByName Inspect.63 Inspect.322 Inspect.249;
     let Inspect.319 : Str = "\"";
-    let Inspect.318 : Str = CallByName Inspect.59 Inspect.247 Inspect.319;
+    let Inspect.317 : Str = CallByName Inspect.63 Inspect.318 Inspect.319;
     dec Inspect.319;
-    let Inspect.314 : Str = CallByName Inspect.59 Inspect.318 Inspect.245;
-    let Inspect.315 : Str = "\"";
-    let Inspect.313 : Str = CallByName Inspect.59 Inspect.314 Inspect.315;
-    dec Inspect.315;
-    ret Inspect.313;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.43 (Inspect.245):
-    let Inspect.309 : Str = CallByName Inspect.30 Inspect.245;
-    ret Inspect.309;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : Str = CallByName Inspect.43 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName Inspect.246 Inspect.304 Inspect.308;
-    dec Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.317 : Str = CallByName Str.3 Inspect.296 Inspect.292;
     ret Inspect.317;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.47 (Inspect.249):
+    let Inspect.313 : Str = CallByName Inspect.30 Inspect.249;
+    ret Inspect.313;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : Str = CallByName Inspect.47 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName Inspect.250 Inspect.308 Inspect.312;
+    dec Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.321 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.321;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.0 ():
     let Test.2 : Str = "abc";

crates/compiler/test_mono/generated/inspect_derived_tag_one_field_string.txt

@@ -8,9 +8,9 @@ procedure #Derived.3 (#Derived.4, #Derived.1):
         ret #Derived_gen.3;
     in
     let #Derived_gen.7 : Str = "A";
-    let #Derived_gen.9 : Str = CallByName Inspect.43 #Derived.1;
+    let #Derived_gen.9 : Str = CallByName Inspect.47 #Derived.1;
     let #Derived_gen.8 : List Str = Array [#Derived_gen.9];
-    let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.39 #Derived_gen.7 #Derived_gen.8;
+    let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.43 #Derived_gen.7 #Derived_gen.8;
     dec #Derived_gen.8;
     dec #Derived_gen.7;
     jump #Derived_gen.5 #Derived_gen.6;
@@ -19,168 +19,168 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.23;
 
-procedure Inspect.200 (Inspect.201, #Attr.12):
-    let Inspect.342 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    let Inspect.341 : Str = CallByName Inspect.59 Inspect.201 Inspect.342;
-    dec Inspect.342;
-    ret Inspect.341;
+procedure Inspect.204 (Inspect.205, #Attr.12):
+    let Inspect.346 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
+    let Inspect.345 : Str = CallByName Inspect.63 Inspect.205 Inspect.346;
+    dec Inspect.346;
+    ret Inspect.345;
 
-procedure Inspect.202 (Inspect.203, #Attr.12):
-    let Inspect.336 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
-    let Inspect.335 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-    let Inspect.334 : Str = "(";
-    let Inspect.333 : Str = CallByName Inspect.59 Inspect.203 Inspect.334;
-    dec Inspect.334;
-    let Inspect.321 : Str = CallByName Inspect.59 Inspect.333 Inspect.335;
-    dec Inspect.335;
-    let Inspect.317 : Str = CallByName Inspect.204 Inspect.321 Inspect.336;
-    dec Inspect.336;
-    let Inspect.318 : Str = ")";
-    let Inspect.316 : Str = CallByName Inspect.59 Inspect.317 Inspect.318;
-    dec Inspect.318;
-    ret Inspect.316;
-
-procedure Inspect.204 (Inspect.205, Inspect.199):
-    let Inspect.325 : {} = Struct {};
-    let Inspect.324 : Str = CallByName List.18 Inspect.199 Inspect.205 Inspect.325;
-    ret Inspect.324;
-
-procedure Inspect.206 (Inspect.207, Inspect.208):
-    let Inspect.332 : Str = " ";
-    let Inspect.327 : Str = CallByName Inspect.59 Inspect.207 Inspect.332;
-    dec Inspect.332;
-    let Inspect.326 : Str = CallByName Inspect.209 Inspect.327 Inspect.208;
-    ret Inspect.326;
-
-procedure Inspect.209 (Inspect.210, Inspect.208):
-    let Inspect.330 : Str = CallByName Inspect.31 Inspect.208 Inspect.210;
-    ret Inspect.330;
-
-procedure Inspect.246 (Inspect.247, Inspect.245):
-    let Inspect.351 : Str = "\"";
-    let Inspect.350 : Str = CallByName Inspect.59 Inspect.247 Inspect.351;
-    dec Inspect.351;
-    let Inspect.348 : Str = CallByName Inspect.59 Inspect.350 Inspect.245;
-    let Inspect.349 : Str = "\"";
-    let Inspect.347 : Str = CallByName Inspect.59 Inspect.348 Inspect.349;
-    dec Inspect.349;
-    ret Inspect.347;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.311 : U8 = GetTagId Inspect.299;
-    switch Inspect.311:
-        case 0:
-            let Inspect.310 : Str = CallByName Inspect.200 Inspect.145 Inspect.299;
-            ret Inspect.310;
-    
-        default:
-            let Inspect.310 : Str = CallByName Inspect.202 Inspect.145 Inspect.299;
-            ret Inspect.310;
-    
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.331 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
-    ret Inspect.331;
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.39 (Inspect.198, Inspect.199):
-    let Inspect.337 : Int1 = CallByName List.1 Inspect.199;
-    if Inspect.337 then
-        inc Inspect.198;
-        let Inspect.339 : [C Str, C Str List Str] = TagId(0) Inspect.198;
-        let Inspect.338 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.339;
-        ret Inspect.338;
-    else
-        inc Inspect.199;
-        inc Inspect.198;
-        let Inspect.313 : [C Str, C Str List Str] = TagId(1) Inspect.198 Inspect.199;
-        let Inspect.312 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.313;
-        ret Inspect.312;
-
-procedure Inspect.43 (Inspect.245):
-    let Inspect.343 : Str = CallByName Inspect.30 Inspect.245;
-    ret Inspect.343;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : Str = CallByName #Derived.0 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName #Derived.3 Inspect.304 Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.320 : Str = CallByName Str.3 Inspect.296 Inspect.292;
+procedure Inspect.206 (Inspect.207, #Attr.12):
+    let Inspect.340 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
+    let Inspect.339 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
+    let Inspect.338 : Str = "(";
+    let Inspect.337 : Str = CallByName Inspect.63 Inspect.207 Inspect.338;
+    dec Inspect.338;
+    let Inspect.325 : Str = CallByName Inspect.63 Inspect.337 Inspect.339;
+    dec Inspect.339;
+    let Inspect.321 : Str = CallByName Inspect.208 Inspect.325 Inspect.340;
+    dec Inspect.340;
+    let Inspect.322 : Str = ")";
+    let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
+    dec Inspect.322;
     ret Inspect.320;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.208 (Inspect.209, Inspect.203):
+    let Inspect.329 : {} = Struct {};
+    let Inspect.328 : Str = CallByName List.18 Inspect.203 Inspect.209 Inspect.329;
+    ret Inspect.328;
 
-procedure List.1 (List.110):
-    let List.635 : U64 = CallByName List.6 List.110;
-    let List.636 : U64 = 0i64;
-    let List.634 : Int1 = CallByName Bool.11 List.635 List.636;
-    ret List.634;
+procedure Inspect.210 (Inspect.211, Inspect.212):
+    let Inspect.336 : Str = " ";
+    let Inspect.331 : Str = CallByName Inspect.63 Inspect.211 Inspect.336;
+    dec Inspect.336;
+    let Inspect.330 : Str = CallByName Inspect.213 Inspect.331 Inspect.212;
+    ret Inspect.330;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : Str = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Inspect.213 (Inspect.214, Inspect.212):
+    let Inspect.334 : Str = CallByName Inspect.31 Inspect.212 Inspect.214;
+    ret Inspect.334;
+
+procedure Inspect.250 (Inspect.251, Inspect.249):
+    let Inspect.355 : Str = "\"";
+    let Inspect.354 : Str = CallByName Inspect.63 Inspect.251 Inspect.355;
+    dec Inspect.355;
+    let Inspect.352 : Str = CallByName Inspect.63 Inspect.354 Inspect.249;
+    let Inspect.353 : Str = "\"";
+    let Inspect.351 : Str = CallByName Inspect.63 Inspect.352 Inspect.353;
+    dec Inspect.353;
+    ret Inspect.351;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.315 : U8 = GetTagId Inspect.303;
+    switch Inspect.315:
+        case 0:
+            let Inspect.314 : Str = CallByName Inspect.204 Inspect.149 Inspect.303;
+            ret Inspect.314;
+    
+        default:
+            let Inspect.314 : Str = CallByName Inspect.206 Inspect.149 Inspect.303;
+            ret Inspect.314;
+    
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.335 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
+    ret Inspect.335;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.43 (Inspect.202, Inspect.203):
+    let Inspect.341 : Int1 = CallByName List.1 Inspect.203;
+    if Inspect.341 then
+        inc Inspect.202;
+        let Inspect.343 : [C Str, C Str List Str] = TagId(0) Inspect.202;
+        let Inspect.342 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.343;
+        ret Inspect.342;
+    else
+        inc Inspect.203;
+        inc Inspect.202;
+        let Inspect.317 : [C Str, C Str List Str] = TagId(1) Inspect.202 Inspect.203;
+        let Inspect.316 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.317;
+        ret Inspect.316;
+
+procedure Inspect.47 (Inspect.249):
+    let Inspect.347 : Str = CallByName Inspect.30 Inspect.249;
+    ret Inspect.347;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : Str = CallByName #Derived.0 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName #Derived.3 Inspect.308 Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.324 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.324;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure List.1 (List.113):
+    let List.638 : U64 = CallByName List.6 List.113;
+    let List.639 : U64 = 0i64;
+    let List.637 : Int1 = CallByName Bool.11 List.638 List.639;
+    ret List.637;
+
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : Str = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
-procedure List.92 (#Derived_gen.10, #Derived_gen.11, #Derived_gen.12, #Derived_gen.13, #Derived_gen.14):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : Str = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : Str = CallByName Inspect.206 List.167 List.631;
-            dec List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17, #Derived_gen.18):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : Str = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : Str = CallByName Inspect.210 List.170 List.634;
+            dec List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
-    inc #Derived_gen.10;
-    jump List.625 #Derived_gen.10 #Derived_gen.11 #Derived_gen.12 #Derived_gen.13 #Derived_gen.14;
+    inc #Derived_gen.14;
+    jump List.628 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17 #Derived_gen.18;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.0 ():
     let Test.4 : Str = "foo";

crates/compiler/test_mono/generated/inspect_derived_tag_two_payloads_string.txt

@@ -10,10 +10,10 @@ procedure #Derived.4 (#Derived.5, #Derived.1):
     let #Derived.2 : Str = StructAtIndex 0 #Derived.1;
     let #Derived.3 : Str = StructAtIndex 1 #Derived.1;
     let #Derived_gen.7 : Str = "A";
-    let #Derived_gen.9 : Str = CallByName Inspect.43 #Derived.2;
-    let #Derived_gen.10 : Str = CallByName Inspect.43 #Derived.3;
+    let #Derived_gen.9 : Str = CallByName Inspect.47 #Derived.2;
+    let #Derived_gen.10 : Str = CallByName Inspect.47 #Derived.3;
     let #Derived_gen.8 : List Str = Array [#Derived_gen.9, #Derived_gen.10];
-    let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.39 #Derived_gen.7 #Derived_gen.8;
+    let #Derived_gen.6 : [C Str, C Str List Str] = CallByName Inspect.43 #Derived_gen.7 #Derived_gen.8;
     dec #Derived_gen.8;
     dec #Derived_gen.7;
     jump #Derived_gen.5 #Derived_gen.6;
@@ -22,168 +22,168 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.23;
 
-procedure Inspect.200 (Inspect.201, #Attr.12):
-    let Inspect.342 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    let Inspect.341 : Str = CallByName Inspect.59 Inspect.201 Inspect.342;
-    dec Inspect.342;
-    ret Inspect.341;
+procedure Inspect.204 (Inspect.205, #Attr.12):
+    let Inspect.346 : Str = UnionAtIndex (Id 0) (Index 0) #Attr.12;
+    let Inspect.345 : Str = CallByName Inspect.63 Inspect.205 Inspect.346;
+    dec Inspect.346;
+    ret Inspect.345;
 
-procedure Inspect.202 (Inspect.203, #Attr.12):
-    let Inspect.336 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
-    let Inspect.335 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-    let Inspect.334 : Str = "(";
-    let Inspect.333 : Str = CallByName Inspect.59 Inspect.203 Inspect.334;
-    dec Inspect.334;
-    let Inspect.321 : Str = CallByName Inspect.59 Inspect.333 Inspect.335;
-    dec Inspect.335;
-    let Inspect.317 : Str = CallByName Inspect.204 Inspect.321 Inspect.336;
-    dec Inspect.336;
-    let Inspect.318 : Str = ")";
-    let Inspect.316 : Str = CallByName Inspect.59 Inspect.317 Inspect.318;
-    dec Inspect.318;
-    ret Inspect.316;
-
-procedure Inspect.204 (Inspect.205, Inspect.199):
-    let Inspect.325 : {} = Struct {};
-    let Inspect.324 : Str = CallByName List.18 Inspect.199 Inspect.205 Inspect.325;
-    ret Inspect.324;
-
-procedure Inspect.206 (Inspect.207, Inspect.208):
-    let Inspect.332 : Str = " ";
-    let Inspect.327 : Str = CallByName Inspect.59 Inspect.207 Inspect.332;
-    dec Inspect.332;
-    let Inspect.326 : Str = CallByName Inspect.209 Inspect.327 Inspect.208;
-    ret Inspect.326;
-
-procedure Inspect.209 (Inspect.210, Inspect.208):
-    let Inspect.330 : Str = CallByName Inspect.31 Inspect.208 Inspect.210;
-    ret Inspect.330;
-
-procedure Inspect.246 (Inspect.247, Inspect.245):
-    let Inspect.351 : Str = "\"";
-    let Inspect.350 : Str = CallByName Inspect.59 Inspect.247 Inspect.351;
-    dec Inspect.351;
-    let Inspect.348 : Str = CallByName Inspect.59 Inspect.350 Inspect.245;
-    let Inspect.349 : Str = "\"";
-    let Inspect.347 : Str = CallByName Inspect.59 Inspect.348 Inspect.349;
-    dec Inspect.349;
-    ret Inspect.347;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.30 (Inspect.143):
-    ret Inspect.143;
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.311 : U8 = GetTagId Inspect.299;
-    switch Inspect.311:
-        case 0:
-            let Inspect.310 : Str = CallByName Inspect.200 Inspect.145 Inspect.299;
-            ret Inspect.310;
-    
-        default:
-            let Inspect.310 : Str = CallByName Inspect.202 Inspect.145 Inspect.299;
-            ret Inspect.310;
-    
-
-procedure Inspect.31 (Inspect.299, Inspect.145):
-    let Inspect.331 : Str = CallByName Inspect.246 Inspect.145 Inspect.299;
-    ret Inspect.331;
-
-procedure Inspect.33 (Inspect.148):
-    let Inspect.301 : Str = CallByName Inspect.5 Inspect.148;
-    let Inspect.300 : Str = CallByName Inspect.60 Inspect.301;
-    ret Inspect.300;
-
-procedure Inspect.35 (Inspect.297):
-    let Inspect.307 : Str = "";
-    ret Inspect.307;
-
-procedure Inspect.39 (Inspect.198, Inspect.199):
-    let Inspect.337 : Int1 = CallByName List.1 Inspect.199;
-    if Inspect.337 then
-        inc Inspect.198;
-        let Inspect.339 : [C Str, C Str List Str] = TagId(0) Inspect.198;
-        let Inspect.338 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.339;
-        ret Inspect.338;
-    else
-        inc Inspect.199;
-        inc Inspect.198;
-        let Inspect.313 : [C Str, C Str List Str] = TagId(1) Inspect.198 Inspect.199;
-        let Inspect.312 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.313;
-        ret Inspect.312;
-
-procedure Inspect.43 (Inspect.245):
-    let Inspect.352 : Str = CallByName Inspect.30 Inspect.245;
-    ret Inspect.352;
-
-procedure Inspect.5 (Inspect.146):
-    let Inspect.308 : {Str, Str} = CallByName #Derived.0 Inspect.146;
-    let Inspect.305 : {} = Struct {};
-    let Inspect.304 : Str = CallByName Inspect.35 Inspect.305;
-    let Inspect.303 : Str = CallByName #Derived.4 Inspect.304 Inspect.308;
-    ret Inspect.303;
-
-procedure Inspect.59 (Inspect.296, Inspect.292):
-    let Inspect.320 : Str = CallByName Str.3 Inspect.296 Inspect.292;
+procedure Inspect.206 (Inspect.207, #Attr.12):
+    let Inspect.340 : List Str = UnionAtIndex (Id 1) (Index 1) #Attr.12;
+    let Inspect.339 : Str = UnionAtIndex (Id 1) (Index 0) #Attr.12;
+    let Inspect.338 : Str = "(";
+    let Inspect.337 : Str = CallByName Inspect.63 Inspect.207 Inspect.338;
+    dec Inspect.338;
+    let Inspect.325 : Str = CallByName Inspect.63 Inspect.337 Inspect.339;
+    dec Inspect.339;
+    let Inspect.321 : Str = CallByName Inspect.208 Inspect.325 Inspect.340;
+    dec Inspect.340;
+    let Inspect.322 : Str = ")";
+    let Inspect.320 : Str = CallByName Inspect.63 Inspect.321 Inspect.322;
+    dec Inspect.322;
     ret Inspect.320;
 
-procedure Inspect.60 (Inspect.298):
-    ret Inspect.298;
+procedure Inspect.208 (Inspect.209, Inspect.203):
+    let Inspect.329 : {} = Struct {};
+    let Inspect.328 : Str = CallByName List.18 Inspect.203 Inspect.209 Inspect.329;
+    ret Inspect.328;
 
-procedure List.1 (List.110):
-    let List.635 : U64 = CallByName List.6 List.110;
-    let List.636 : U64 = 0i64;
-    let List.634 : Int1 = CallByName Bool.11 List.635 List.636;
-    ret List.634;
+procedure Inspect.210 (Inspect.211, Inspect.212):
+    let Inspect.336 : Str = " ";
+    let Inspect.331 : Str = CallByName Inspect.63 Inspect.211 Inspect.336;
+    dec Inspect.336;
+    let Inspect.330 : Str = CallByName Inspect.213 Inspect.331 Inspect.212;
+    ret Inspect.330;
 
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : Str = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure Inspect.213 (Inspect.214, Inspect.212):
+    let Inspect.334 : Str = CallByName Inspect.31 Inspect.212 Inspect.214;
+    ret Inspect.334;
+
+procedure Inspect.250 (Inspect.251, Inspect.249):
+    let Inspect.355 : Str = "\"";
+    let Inspect.354 : Str = CallByName Inspect.63 Inspect.251 Inspect.355;
+    dec Inspect.355;
+    let Inspect.352 : Str = CallByName Inspect.63 Inspect.354 Inspect.249;
+    let Inspect.353 : Str = "\"";
+    let Inspect.351 : Str = CallByName Inspect.63 Inspect.352 Inspect.353;
+    dec Inspect.353;
+    ret Inspect.351;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.30 (Inspect.147):
+    ret Inspect.147;
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.315 : U8 = GetTagId Inspect.303;
+    switch Inspect.315:
+        case 0:
+            let Inspect.314 : Str = CallByName Inspect.204 Inspect.149 Inspect.303;
+            ret Inspect.314;
+    
+        default:
+            let Inspect.314 : Str = CallByName Inspect.206 Inspect.149 Inspect.303;
+            ret Inspect.314;
+    
+
+procedure Inspect.31 (Inspect.303, Inspect.149):
+    let Inspect.335 : Str = CallByName Inspect.250 Inspect.149 Inspect.303;
+    ret Inspect.335;
+
+procedure Inspect.33 (Inspect.152):
+    let Inspect.305 : Str = CallByName Inspect.5 Inspect.152;
+    let Inspect.304 : Str = CallByName Inspect.64 Inspect.305;
+    ret Inspect.304;
+
+procedure Inspect.39 (Inspect.301):
+    let Inspect.311 : Str = "";
+    ret Inspect.311;
+
+procedure Inspect.43 (Inspect.202, Inspect.203):
+    let Inspect.341 : Int1 = CallByName List.1 Inspect.203;
+    if Inspect.341 then
+        inc Inspect.202;
+        let Inspect.343 : [C Str, C Str List Str] = TagId(0) Inspect.202;
+        let Inspect.342 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.343;
+        ret Inspect.342;
+    else
+        inc Inspect.203;
+        inc Inspect.202;
+        let Inspect.317 : [C Str, C Str List Str] = TagId(1) Inspect.202 Inspect.203;
+        let Inspect.316 : [C Str, C Str List Str] = CallByName Inspect.30 Inspect.317;
+        ret Inspect.316;
+
+procedure Inspect.47 (Inspect.249):
+    let Inspect.356 : Str = CallByName Inspect.30 Inspect.249;
+    ret Inspect.356;
+
+procedure Inspect.5 (Inspect.150):
+    let Inspect.312 : {Str, Str} = CallByName #Derived.0 Inspect.150;
+    let Inspect.309 : {} = Struct {};
+    let Inspect.308 : Str = CallByName Inspect.39 Inspect.309;
+    let Inspect.307 : Str = CallByName #Derived.4 Inspect.308 Inspect.312;
+    ret Inspect.307;
+
+procedure Inspect.63 (Inspect.300, Inspect.296):
+    let Inspect.324 : Str = CallByName Str.3 Inspect.300 Inspect.296;
+    ret Inspect.324;
+
+procedure Inspect.64 (Inspect.302):
+    ret Inspect.302;
+
+procedure List.1 (List.113):
+    let List.638 : U64 = CallByName List.6 List.113;
+    let List.639 : U64 = 0i64;
+    let List.637 : Int1 = CallByName Bool.11 List.638 List.639;
+    ret List.637;
+
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : Str = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
-procedure List.92 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : Str = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : Str = CallByName Inspect.206 List.167 List.631;
-            dec List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : Str = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : Str = CallByName Inspect.210 List.170 List.634;
+            dec List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
     inc #Derived_gen.13;
-    jump List.625 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
+    jump List.628 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.0 ():
     let Test.5 : Str = "foo";

crates/compiler/test_mono/generated/ir_int_add.txt

@@ -1,10 +1,10 @@
 procedure List.6 (#Attr.2):
-    let List.622 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.622;
+    let List.625 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.625;
 
 procedure Num.19 (#Attr.2, #Attr.3):
-    let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.283;
 
 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.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
 
 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.279 : I64 = lowlevel NumRound #Attr.2;
-    ret Num.279;
+    let Num.281 : I64 = lowlevel NumRound #Attr.2;
+    ret Num.281;
 
 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.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
 
 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.281 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
-    ret Num.281;
+    let Num.283 : I64 = lowlevel NumDivTruncUnchecked #Attr.2 #Attr.3;
+    ret Num.283;
 
 procedure Num.30 (#Attr.2):
-    let Num.286 : I64 = 0i64;
-    let Num.285 : Int1 = lowlevel Eq #Attr.2 Num.286;
-    ret Num.285;
+    let Num.288 : I64 = 0i64;
+    let Num.287 : Int1 = lowlevel Eq #Attr.2 Num.288;
+    ret Num.287;
 
-procedure Num.40 (Num.247, Num.248):
-    let Num.282 : Int1 = CallByName Num.30 Num.248;
-    if Num.282 then
-        let Num.284 : {} = Struct {};
-        let Num.283 : [C {}, C I64] = TagId(0) Num.284;
-        ret Num.283;
+procedure Num.40 (Num.249, Num.250):
+    let Num.284 : Int1 = CallByName Num.30 Num.250;
+    if Num.284 then
+        let Num.286 : {} = Struct {};
+        let Num.285 : [C {}, C I64] = TagId(0) Num.286;
+        ret Num.285;
     else
-        let Num.280 : I64 = CallByName Num.157 Num.247 Num.248;
-        let Num.279 : [C {}, C I64] = TagId(1) Num.280;
-        ret Num.279;
+        let Num.282 : I64 = CallByName Num.157 Num.249 Num.250;
+        let Num.281 : [C {}, C I64] = TagId(1) Num.282;
+        ret Num.281;
 
 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.279 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Test.0 ():
     let Test.10 : I64 = 41i64;

crates/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt

@@ -6,66 +6,66 @@ procedure Bool.2 ():
     let Bool.23 : Int1 = true;
     ret Bool.23;
 
-procedure List.2 (List.111, List.112):
-    let List.636 : U64 = CallByName List.6 List.111;
-    let List.632 : Int1 = CallByName Num.22 List.112 List.636;
-    if List.632 then
-        let List.634 : I64 = CallByName List.66 List.111 List.112;
-        let List.633 : [C {}, C I64] = TagId(1) List.634;
-        ret List.633;
+procedure List.2 (List.114, List.115):
+    let List.639 : U64 = CallByName List.6 List.114;
+    let List.635 : Int1 = CallByName Num.22 List.115 List.639;
+    if List.635 then
+        let List.637 : I64 = CallByName List.66 List.114 List.115;
+        let List.636 : [C {}, C I64] = TagId(1) List.637;
+        ret List.636;
     else
-        let List.631 : {} = Struct {};
-        let List.630 : [C {}, C I64] = TagId(0) List.631;
-        ret List.630;
+        let List.634 : {} = Struct {};
+        let List.633 : [C {}, C I64] = TagId(0) List.634;
+        ret List.633;
 
 procedure List.6 (#Attr.2):
-    let List.637 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.637;
+    let List.640 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.640;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.635 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.635;
+    let List.638 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.638;
 
-procedure List.9 (List.383):
-    let List.629 : U64 = 0i64;
-    let List.622 : [C {}, C I64] = CallByName List.2 List.383 List.629;
-    let List.626 : U8 = 1i64;
-    let List.627 : U8 = GetTagId List.622;
-    let List.628 : Int1 = lowlevel Eq List.626 List.627;
-    if List.628 then
-        let List.384 : I64 = UnionAtIndex (Id 1) (Index 0) List.622;
-        let List.623 : [C Int1, C I64] = TagId(1) List.384;
-        ret List.623;
+procedure List.9 (List.386):
+    let List.632 : U64 = 0i64;
+    let List.625 : [C {}, C I64] = CallByName List.2 List.386 List.632;
+    let List.629 : U8 = 1i64;
+    let List.630 : U8 = GetTagId List.625;
+    let List.631 : Int1 = lowlevel Eq List.629 List.630;
+    if List.631 then
+        let List.387 : I64 = UnionAtIndex (Id 1) (Index 0) List.625;
+        let List.626 : [C Int1, C I64] = TagId(1) List.387;
+        ret List.626;
     else
-        let List.625 : Int1 = true;
-        let List.624 : [C Int1, C I64] = TagId(0) List.625;
-        ret List.624;
+        let List.628 : Int1 = true;
+        let List.627 : [C Int1, C I64] = TagId(0) List.628;
+        ret List.627;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.279 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.281;
 
-procedure Str.27 (Str.78):
-    let Str.232 : [C Int1, C I64] = CallByName Str.60 Str.78;
-    ret Str.232;
+procedure Str.27 (Str.82):
+    let Str.236 : [C Int1, C I64] = CallByName Str.64 Str.82;
+    ret Str.236;
 
 procedure Str.42 (#Attr.2):
-    let Str.240 : {I64, U8} = lowlevel StrToNum #Attr.2;
-    ret Str.240;
+    let Str.244 : {I64, U8} = lowlevel StrToNum #Attr.2;
+    ret Str.244;
 
-procedure Str.60 (Str.185):
-    let Str.186 : {I64, U8} = CallByName Str.42 Str.185;
-    let Str.238 : U8 = StructAtIndex 1 Str.186;
-    let Str.239 : U8 = 0i64;
-    let Str.235 : Int1 = CallByName Bool.11 Str.238 Str.239;
-    if Str.235 then
-        let Str.237 : I64 = StructAtIndex 0 Str.186;
-        let Str.236 : [C Int1, C I64] = TagId(1) Str.237;
-        ret Str.236;
+procedure Str.64 (Str.189):
+    let Str.190 : {I64, U8} = CallByName Str.42 Str.189;
+    let Str.242 : U8 = StructAtIndex 1 Str.190;
+    let Str.243 : U8 = 0i64;
+    let Str.239 : Int1 = CallByName Bool.11 Str.242 Str.243;
+    if Str.239 then
+        let Str.241 : I64 = StructAtIndex 0 Str.190;
+        let Str.240 : [C Int1, C I64] = TagId(1) Str.241;
+        ret Str.240;
     else
-        let Str.234 : Int1 = false;
-        let Str.233 : [C Int1, C I64] = TagId(0) Str.234;
-        ret Str.233;
+        let Str.238 : Int1 = false;
+        let Str.237 : [C Int1, C I64] = TagId(0) Str.238;
+        ret Str.237;
 
 procedure Test.0 ():
     let Test.3 : Int1 = CallByName Bool.2;

crates/compiler/test_mono/generated/issue_4770.txt

@@ -6,137 +6,137 @@ procedure Bool.2 ():
     let Bool.24 : Int1 = true;
     ret Bool.24;
 
-procedure List.107 (List.536, List.537, List.538):
-    let List.636 : U64 = 0i64;
-    let List.637 : U64 = CallByName List.6 List.536;
-    let List.635 : [C {}, C {}] = CallByName List.80 List.536 List.537 List.538 List.636 List.637;
-    ret List.635;
-
-procedure List.23 (List.278, List.279, List.280):
-    let List.672 : U64 = CallByName List.6 List.278;
-    let List.673 : U64 = CallByName List.6 List.279;
-    let List.281 : U64 = CallByName Num.148 List.672 List.673;
-    let List.658 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.68 List.281;
-    let List.659 : U64 = 0i64;
-    let List.657 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.97 List.278 List.279 List.658 List.280 List.659 List.281;
-    ret List.657;
-
-procedure List.239 (List.624, List.240, List.238):
-    let List.654 : Int1 = CallByName Test.1 List.240;
-    if List.654 then
-        let List.656 : {} = Struct {};
-        let List.655 : [C {}, C {}] = TagId(1) List.656;
-        ret List.655;
-    else
-        let List.653 : {} = Struct {};
-        let List.652 : [C {}, C {}] = TagId(0) List.653;
-        ret List.652;
-
-procedure List.56 (List.237, List.238):
-    let List.633 : {} = Struct {};
-    let List.625 : [C {}, C {}] = CallByName List.107 List.237 List.633 List.238;
-    let List.630 : U8 = 1i64;
-    let List.631 : U8 = GetTagId List.625;
-    let List.632 : Int1 = lowlevel Eq List.630 List.631;
-    if List.632 then
-        let List.626 : Int1 = CallByName Bool.2;
-        ret List.626;
-    else
-        let List.627 : Int1 = CallByName Bool.1;
-        ret List.627;
-
-procedure List.6 (#Attr.2):
-    let List.623 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.623;
-
-procedure List.6 (#Attr.2):
-    let List.651 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.651;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.650 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.650;
-
-procedure List.66 (#Attr.2, #Attr.3):
-    let List.670 : [<r>C I64, C List *self] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.670;
-
-procedure List.68 (#Attr.2):
-    let List.671 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListWithCapacity #Attr.2;
-    ret List.671;
-
-procedure List.71 (#Attr.2, #Attr.3):
-    let List.667 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
-    ret List.667;
-
-procedure List.80 (#Derived_gen.7, #Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11):
-    joinpoint List.638 List.539 List.540 List.541 List.542 List.543:
-        let List.640 : Int1 = CallByName Num.22 List.542 List.543;
-        if List.640 then
-            let List.649 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.539 List.542;
-            inc List.649;
-            let List.641 : [C {}, C {}] = CallByName List.239 List.540 List.649 List.541;
-            let List.646 : U8 = 1i64;
-            let List.647 : U8 = GetTagId List.641;
-            let List.648 : Int1 = lowlevel Eq List.646 List.647;
-            if List.648 then
-                let List.544 : {} = UnionAtIndex (Id 1) (Index 0) List.641;
-                let List.644 : U64 = 1i64;
-                let List.643 : U64 = CallByName Num.51 List.542 List.644;
-                jump List.638 List.539 List.544 List.541 List.643 List.543;
-            else
-                dec List.539;
-                let List.545 : {} = UnionAtIndex (Id 0) (Index 0) List.641;
-                let List.645 : [C {}, C {}] = TagId(0) List.545;
-                ret List.645;
+procedure List.100 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6):
+    joinpoint List.663 List.285 List.286 List.287 List.288 List.289 List.290:
+        let List.665 : Int1 = CallByName Num.22 List.289 List.290;
+        if List.665 then
+            let List.671 : [<r>C I64, C List *self] = CallByName List.66 List.285 List.289;
+            inc List.671;
+            let List.672 : [<r>C I64, C List *self] = CallByName List.66 List.286 List.289;
+            inc List.672;
+            let List.291 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName Test.15 List.671 List.672;
+            let List.667 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.71 List.287 List.291;
+            let List.669 : U64 = 1i64;
+            let List.668 : U64 = CallByName Num.51 List.289 List.669;
+            jump List.663 List.285 List.286 List.667 List.288 List.668 List.290;
         else
-            dec List.539;
-            let List.639 : [C {}, C {}] = TagId(1) List.540;
-            ret List.639;
-    in
-    inc #Derived_gen.7;
-    jump List.638 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11;
-
-procedure List.97 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6):
-    joinpoint List.660 List.282 List.283 List.284 List.285 List.286 List.287:
-        let List.662 : Int1 = CallByName Num.22 List.286 List.287;
-        if List.662 then
-            let List.668 : [<r>C I64, C List *self] = CallByName List.66 List.282 List.286;
-            inc List.668;
-            let List.669 : [<r>C I64, C List *self] = CallByName List.66 List.283 List.286;
-            inc List.669;
-            let List.288 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName Test.15 List.668 List.669;
-            let List.664 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.71 List.284 List.288;
-            let List.666 : U64 = 1i64;
-            let List.665 : U64 = CallByName Num.51 List.286 List.666;
-            jump List.660 List.282 List.283 List.664 List.285 List.665 List.287;
-        else
-            dec List.283;
-            dec List.282;
-            ret List.284;
+            dec List.286;
+            dec List.285;
+            ret List.287;
     in
     inc #Derived_gen.1;
     inc #Derived_gen.2;
-    jump List.660 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6;
+    jump List.663 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6;
 
-procedure Num.148 (Num.223, Num.224):
-    let Num.286 : Int1 = CallByName Num.22 Num.223 Num.224;
-    if Num.286 then
-        ret Num.223;
+procedure List.110 (List.539, List.540, List.541):
+    let List.639 : U64 = 0i64;
+    let List.640 : U64 = CallByName List.6 List.539;
+    let List.638 : [C {}, C {}] = CallByName List.80 List.539 List.540 List.541 List.639 List.640;
+    ret List.638;
+
+procedure List.23 (List.281, List.282, List.283):
+    let List.675 : U64 = CallByName List.6 List.281;
+    let List.676 : U64 = CallByName List.6 List.282;
+    let List.284 : U64 = CallByName Num.148 List.675 List.676;
+    let List.661 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.68 List.284;
+    let List.662 : U64 = 0i64;
+    let List.660 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.100 List.281 List.282 List.661 List.283 List.662 List.284;
+    ret List.660;
+
+procedure List.242 (List.627, List.243, List.241):
+    let List.657 : Int1 = CallByName Test.1 List.243;
+    if List.657 then
+        let List.659 : {} = Struct {};
+        let List.658 : [C {}, C {}] = TagId(1) List.659;
+        ret List.658;
     else
-        ret Num.224;
+        let List.656 : {} = Struct {};
+        let List.655 : [C {}, C {}] = TagId(0) List.656;
+        ret List.655;
+
+procedure List.56 (List.240, List.241):
+    let List.636 : {} = Struct {};
+    let List.628 : [C {}, C {}] = CallByName List.110 List.240 List.636 List.241;
+    let List.633 : U8 = 1i64;
+    let List.634 : U8 = GetTagId List.628;
+    let List.635 : Int1 = lowlevel Eq List.633 List.634;
+    if List.635 then
+        let List.629 : Int1 = CallByName Bool.2;
+        ret List.629;
+    else
+        let List.630 : Int1 = CallByName Bool.1;
+        ret List.630;
+
+procedure List.6 (#Attr.2):
+    let List.626 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.626;
+
+procedure List.6 (#Attr.2):
+    let List.654 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.654;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.653 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.653;
+
+procedure List.66 (#Attr.2, #Attr.3):
+    let List.673 : [<r>C I64, C List *self] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.673;
+
+procedure List.68 (#Attr.2):
+    let List.674 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListWithCapacity #Attr.2;
+    ret List.674;
+
+procedure List.71 (#Attr.2, #Attr.3):
+    let List.670 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
+    ret List.670;
+
+procedure List.80 (#Derived_gen.7, #Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11):
+    joinpoint List.641 List.542 List.543 List.544 List.545 List.546:
+        let List.643 : Int1 = CallByName Num.22 List.545 List.546;
+        if List.643 then
+            let List.652 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.542 List.545;
+            inc List.652;
+            let List.644 : [C {}, C {}] = CallByName List.242 List.543 List.652 List.544;
+            let List.649 : U8 = 1i64;
+            let List.650 : U8 = GetTagId List.644;
+            let List.651 : Int1 = lowlevel Eq List.649 List.650;
+            if List.651 then
+                let List.547 : {} = UnionAtIndex (Id 1) (Index 0) List.644;
+                let List.647 : U64 = 1i64;
+                let List.646 : U64 = CallByName Num.51 List.545 List.647;
+                jump List.641 List.542 List.547 List.544 List.646 List.546;
+            else
+                dec List.542;
+                let List.548 : {} = UnionAtIndex (Id 0) (Index 0) List.644;
+                let List.648 : [C {}, C {}] = TagId(0) List.548;
+                ret List.648;
+        else
+            dec List.542;
+            let List.642 : [C {}, C {}] = TagId(1) List.543;
+            ret List.642;
+    in
+    inc #Derived_gen.7;
+    jump List.641 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11;
+
+procedure Num.148 (Num.225, Num.226):
+    let Num.288 : Int1 = CallByName Num.22 Num.225 Num.226;
+    if Num.288 then
+        ret Num.225;
+    else
+        ret Num.226;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.279 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.284 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.284;
+    let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.286;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.282 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.282;
+    let Num.284 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.284;
 
 procedure Test.1 (#Derived_gen.0):
     joinpoint Test.26 Test.6:

crates/compiler/test_mono/generated/issue_4772_weakened_monomorphic_destructure.txt

@@ -6,43 +6,43 @@ procedure Bool.11 (#Attr.2, #Attr.3):
     let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.24;
 
-procedure Decode.24 (Decode.101):
-    ret Decode.101;
+procedure Decode.24 (Decode.105):
+    ret Decode.105;
 
-procedure Decode.25 (Decode.102, Decode.121, Decode.104):
-    let Decode.124 : {List U8, [C {}, C Str]} = CallByName Test.76 Decode.102 Decode.104;
-    ret Decode.124;
+procedure Decode.25 (Decode.106, Decode.125, Decode.108):
+    let Decode.128 : {List U8, [C {}, C Str]} = CallByName Test.76 Decode.106 Decode.108;
+    ret Decode.128;
 
-procedure Decode.26 (Decode.105, Decode.106):
-    let Decode.123 : {} = CallByName Test.15;
-    let Decode.122 : {List U8, [C {}, C Str]} = CallByName Decode.25 Decode.105 Decode.123 Decode.106;
-    ret Decode.122;
+procedure Decode.26 (Decode.109, Decode.110):
+    let Decode.127 : {} = CallByName Test.15;
+    let Decode.126 : {List U8, [C {}, C Str]} = CallByName Decode.25 Decode.109 Decode.127 Decode.110;
+    ret Decode.126;
 
 procedure Str.12 (#Attr.2):
-    let Str.241 : List U8 = lowlevel StrToUtf8 #Attr.2;
-    ret Str.241;
+    let Str.245 : List U8 = lowlevel StrToUtf8 #Attr.2;
+    ret Str.245;
 
-procedure Str.27 (Str.78):
-    let Str.232 : [C {}, C I64] = CallByName Str.60 Str.78;
-    ret Str.232;
+procedure Str.27 (Str.82):
+    let Str.236 : [C {}, C I64] = CallByName Str.64 Str.82;
+    ret Str.236;
 
 procedure Str.42 (#Attr.2):
-    let Str.240 : {I64, U8} = lowlevel StrToNum #Attr.2;
-    ret Str.240;
+    let Str.244 : {I64, U8} = lowlevel StrToNum #Attr.2;
+    ret Str.244;
 
-procedure Str.60 (Str.185):
-    let Str.186 : {I64, U8} = CallByName Str.42 Str.185;
-    let Str.238 : U8 = StructAtIndex 1 Str.186;
-    let Str.239 : U8 = 0i64;
-    let Str.235 : Int1 = CallByName Bool.11 Str.238 Str.239;
-    if Str.235 then
-        let Str.237 : I64 = StructAtIndex 0 Str.186;
-        let Str.236 : [C {}, C I64] = TagId(1) Str.237;
-        ret Str.236;
+procedure Str.64 (Str.189):
+    let Str.190 : {I64, U8} = CallByName Str.42 Str.189;
+    let Str.242 : U8 = StructAtIndex 1 Str.190;
+    let Str.243 : U8 = 0i64;
+    let Str.239 : Int1 = CallByName Bool.11 Str.242 Str.243;
+    if Str.239 then
+        let Str.241 : I64 = StructAtIndex 0 Str.190;
+        let Str.240 : [C {}, C I64] = TagId(1) Str.241;
+        ret Str.240;
     else
-        let Str.234 : {} = Struct {};
-        let Str.233 : [C {}, C I64] = TagId(0) Str.234;
-        ret Str.233;
+        let Str.238 : {} = Struct {};
+        let Str.237 : [C {}, C I64] = TagId(0) Str.238;
+        ret Str.237;
 
 procedure Test.103 ():
     let Test.101 : [C Str, C {List U8, I64}] = CallByName Test.19;

crates/compiler/test_mono/generated/issue_6196.txt

@@ -1,6 +1,6 @@
 procedure Num.20 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
+    ret Num.281;
 
 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.279 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.279;
+    let Num.281 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.281;
 
 procedure Num.96 (#Attr.2):
-    let Num.280 : Str = lowlevel NumToStr #Attr.2;
-    ret Num.280;
+    let Num.282 : Str = lowlevel NumToStr #Attr.2;
+    ret Num.282;
 
 procedure Test.1 (Test.4):
     let Test.13 : [C U8, C U64] = TagId(1) Test.4;

crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt

@@ -1,6 +1,6 @@
 procedure Str.3 (#Attr.2, #Attr.3):
-    let Str.232 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
-    ret Str.232;
+    let Str.236 : Str = lowlevel StrConcat #Attr.2 #Attr.3;
+    ret Str.236;
 
 procedure Test.1 (Test.5):
     let Test.16 : [C {}, C U64, C Str] = TagId(0) Test.5;

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.279 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
+    ret Num.281;
 
 procedure Num.21 (#Attr.2, #Attr.3):
-    let Num.280 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : U64 = lowlevel NumMul #Attr.2 #Attr.3;
+    ret Num.282;
 
 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

@@ -1,41 +1,41 @@
-procedure List.18 (List.163, List.164, List.165):
-    let List.623 : U64 = 0i64;
-    let List.624 : U64 = CallByName List.6 List.163;
-    let List.622 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.92 List.163 List.164 List.165 List.623 List.624;
-    ret List.622;
+procedure List.18 (List.166, List.167, List.168):
+    let List.626 : U64 = 0i64;
+    let List.627 : U64 = CallByName List.6 List.166;
+    let List.625 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName List.95 List.166 List.167 List.168 List.626 List.627;
+    ret List.625;
 
 procedure List.6 (#Attr.2):
-    let List.633 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.633;
+    let List.636 : U64 = lowlevel ListLenU64 #Attr.2;
+    ret List.636;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.632 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.632;
+    let List.635 : [<rnu>C *self, <null>] = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    ret List.635;
 
-procedure List.92 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
-    joinpoint List.625 List.166 List.167 List.168 List.169 List.170:
-        let List.627 : Int1 = CallByName Num.22 List.169 List.170;
-        if List.627 then
-            let List.631 : [<rnu>C *self, <null>] = CallByName List.66 List.166 List.169;
-            inc List.631;
-            let List.171 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.167 List.631;
-            let List.630 : U64 = 1i64;
-            let List.629 : U64 = CallByName Num.51 List.169 List.630;
-            jump List.625 List.166 List.171 List.168 List.629 List.170;
+procedure List.95 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+    joinpoint List.628 List.169 List.170 List.171 List.172 List.173:
+        let List.630 : Int1 = CallByName Num.22 List.172 List.173;
+        if List.630 then
+            let List.634 : [<rnu>C *self, <null>] = CallByName List.66 List.169 List.172;
+            inc List.634;
+            let List.174 : [<rnu><null>, C {[<rnu>C *self, <null>], *self}] = CallByName Test.7 List.170 List.634;
+            let List.633 : U64 = 1i64;
+            let List.632 : U64 = CallByName Num.51 List.172 List.633;
+            jump List.628 List.169 List.174 List.171 List.632 List.173;
         else
-            dec List.166;
-            ret List.167;
+            dec List.169;
+            ret List.170;
     in
     inc #Derived_gen.0;
-    jump List.625 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.628 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
 
 procedure Num.22 (#Attr.2, #Attr.3):
-    let Num.280 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
-    ret Num.280;
+    let Num.282 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
+    ret Num.282;
 
 procedure Num.51 (#Attr.2, #Attr.3):
-    let Num.279 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
-    ret Num.279;
+    let Num.281 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
+    ret Num.281;
 
 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};