Move desugaring to new roc_can_solo crate

Cargo.lock

@@ -2393,6 +2393,31 @@ dependencies = [
  "bumpalo",
  "indoc",
  "pretty_assertions",
+ "roc_can_solo",
+ "roc_collections",
+ "roc_error_macros",
+ "roc_exhaustive",
+ "roc_module",
+ "roc_parse",
+ "roc_problem",
+ "roc_region",
+ "roc_serialize",
+ "roc_types",
+ "soa",
+ "static_assertions",
+ "test_compile",
+ "ven_pretty",
+]
+
+[[package]]
+name = "roc_can_solo"
+version = "0.0.1"
+dependencies = [
+ "bitvec",
+ "bumpalo",
+ "indoc",
+ "insta",
+ "pretty_assertions",
  "roc_collections",
  "roc_error_macros",
  "roc_exhaustive",
@@ -2805,6 +2830,7 @@ dependencies = [
  "pretty_assertions",
  "roc_builtins",
  "roc_can",
+ "roc_can_solo",
  "roc_collections",
  "roc_constrain",
  "roc_derive",
@@ -2828,6 +2854,8 @@ dependencies = [
 name = "roc_load_internal"
 version = "0.0.1"
 dependencies = [
+ "base64-url",
+ "blake3",
  "bumpalo",
  "crossbeam",
  "indoc",
@@ -2836,6 +2864,7 @@ dependencies = [
  "pretty_assertions",
  "roc_builtins",
  "roc_can",
+ "roc_can_solo",
  "roc_checkmate",
  "roc_collections",
  "roc_constrain",
@@ -3871,6 +3900,7 @@ dependencies = [
  "pretty_assertions",
  "roc_builtins",
  "roc_can",
+ "roc_can_solo",
  "roc_collections",
  "roc_constrain",
  "roc_derive",
@@ -4015,6 +4045,7 @@ dependencies = [
  "indoc",
  "pretty_assertions",
  "roc_can",
+ "roc_can_solo",
  "roc_collections",
  "roc_error_macros",
  "roc_fmt",

Cargo.toml

@@ -1,6 +1,7 @@
 [workspace]
 members = [
-    "crates/build/specialize_types",
+    "crates/build/*",
+    "crates/check/*",
     "crates/compiler/*",
     "crates/vendor/*",
     "crates/fs",
@@ -174,6 +175,7 @@ roc_bitcode_bc = { path = "crates/compiler/builtins/bitcode/bc" }
 roc_build = { path = "crates/compiler/build" }
 roc_builtins = { path = "crates/compiler/builtins" }
 roc_can = { path = "crates/compiler/can" }
+roc_can_solo = { path = "crates/check/can_solo" }
 roc_checkmate = { path = "crates/compiler/checkmate" }
 roc_checkmate_schema = { path = "crates/compiler/checkmate_schema" }
 roc_cli = { path = "crates/cli" }

crates/check/can_solo/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "roc_can_solo"
+description = "Canonicalize a Roc module in preparation for typechecking without any knowledge of other modules."
+
+authors.workspace = true
+edition.workspace = true
+license.workspace = true
+version.workspace = true
+
+[dependencies]
+roc_collections.workspace = true
+roc_error_macros.workspace = true
+roc_exhaustive.workspace = true
+roc_module.workspace = true
+roc_parse.workspace = true
+roc_problem.workspace = true
+roc_region.workspace = true
+roc_serialize.workspace = true
+roc_types.workspace = true
+ven_pretty.workspace = true
+bitvec.workspace = true
+bumpalo.workspace = true
+static_assertions.workspace = true
+soa.workspace = true
+
+[dev-dependencies]
+indoc.workspace = true
+insta.workspace = true
+pretty_assertions.workspace = true
+test_compile.workspace = true

crates/check/can_solo/src/env.rs

@@ -0,0 +1,48 @@
+use std::path::Path;
+
+use bumpalo::Bump;
+use roc_module::symbol::ModuleId;
+use roc_problem::can::Problem;
+use roc_region::all::LineInfo;
+
+/// The canonicalization environment for a particular module.
+#[derive(Debug)]
+pub struct SoloEnv<'a> {
+    pub arena: &'a Bump,
+
+    pub module_path: &'a Path,
+
+    pub solo_home: ModuleId,
+
+    /// Problems we've encountered along the way, which will be reported to the user at the end.
+    pub problems: Vec<Problem>,
+
+    pub src: &'a str,
+
+    /// Lazily calculated line info. This data is only needed if the code contains calls to `dbg`,
+    /// otherwise we can leave it as `None` and never pay the cost of scanning the source an extra
+    /// time.
+    pub lazy_line_info: &'a mut Option<LineInfo>,
+}
+
+impl<'a> SoloEnv<'a> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn new(arena: &'a Bump, src: &'a str, module_path: &'a Path) -> SoloEnv<'a> {
+        SoloEnv {
+            arena,
+            module_path,
+            solo_home: ModuleId::first_after_builtins(),
+            src,
+            problems: Vec::new(),
+            lazy_line_info: arena.alloc(None),
+        }
+    }
+
+    pub fn line_info(&mut self) -> &LineInfo {
+        if self.lazy_line_info.is_none() {
+            *self.lazy_line_info = Some(LineInfo::new(self.src));
+        }
+
+        self.lazy_line_info.as_ref().unwrap()
+    }
+}

crates/check/can_solo/src/lib.rs

@@ -0,0 +1,5 @@
+#![warn(clippy::dbg_macro)]
+pub mod desugar;
+pub mod env;
+pub mod module;
+pub mod scope;

crates/check/can_solo/src/module.rs

@@ -0,0 +1,81 @@
+use std::path::PathBuf;
+
+use bumpalo::Bump;
+use roc_module::symbol::ModuleId;
+use roc_parse::{
+    ast::{Collection, Defs, Pattern},
+    header::HeaderType,
+};
+use roc_problem::can::Problem;
+use roc_region::all::{LineInfo, Loc, Region};
+
+use crate::{
+    desugar::{desugar_defs_node_values, desugar_record_destructures},
+    env::SoloEnv,
+    scope::SoloScope,
+};
+
+#[derive(Debug)]
+pub struct SoloCanOutput<'a> {
+    pub scope: SoloScope,
+    pub loc_defs: Defs<'a>,
+    pub solo_home: ModuleId,
+
+    /// Problems we've encountered along the way, which will be reported to the user at the end.
+    pub problems: Vec<Problem>,
+
+    pub src: &'a str,
+
+    /// Lazily calculated line info. This data is only needed if the code contains calls to `dbg`,
+    /// otherwise we can leave it as `None` and never pay the cost of scanning the source an extra
+    /// time.
+    pub lazy_line_info: &'a mut Option<LineInfo>,
+
+    pub module_params: Option<(Region, Collection<'a, Loc<Pattern<'a>>>)>,
+}
+
+// TODO trim these down
+#[allow(clippy::too_many_arguments)]
+pub fn solo_canonicalize_module_defs<'a>(
+    arena: &'a Bump,
+    header_type: HeaderType<'a>,
+    loc_defs: &'a mut Defs<'a>,
+    module_path: PathBuf,
+    src: &'a str,
+) -> SoloCanOutput<'a> {
+    let mut scope = SoloScope::new();
+    let mut env = SoloEnv::new(arena, src, arena.alloc(module_path));
+
+    // Desugar operators (convert them to Apply calls, taking into account
+    // operator precedence and associativity rules), before doing other canonicalization.
+    //
+    // If we did this *during* canonicalization, then each time we
+    // visited a BinOp node we'd recursively try to apply this to each of its nested
+    // operators, and then again on *their* nested operators, ultimately applying the
+    // rules multiple times unnecessarily.
+
+    desugar_defs_node_values(&mut env, &mut scope, loc_defs);
+
+    let module_params = header_type.get_params().as_ref().map(
+        |roc_parse::header::ModuleParams {
+             pattern,
+             before_arrow: _,
+             after_arrow: _,
+         }| {
+            let desugared_patterns =
+                desugar_record_destructures(&mut env, &mut scope, pattern.value);
+
+            (pattern.region, desugared_patterns)
+        },
+    );
+
+    SoloCanOutput {
+        scope,
+        solo_home: env.solo_home,
+        loc_defs: loc_defs.clone(),
+        problems: env.problems,
+        src: env.src,
+        lazy_line_info: env.lazy_line_info,
+        module_params,
+    }
+}

crates/check/can_solo/src/scope.rs

@@ -0,0 +1,229 @@
+use roc_collections::VecMap;
+use roc_module::ident::ModuleName;
+use roc_module::symbol::{IdentId, IdentIds, ModuleId, ModuleIds, Symbol};
+use roc_problem::can::ScopeModuleSource;
+use roc_region::all::Region;
+use roc_types::subs::Variable;
+use roc_types::types::{Alias, EarlyReturnKind};
+
+use bitvec::vec::BitVec;
+
+#[derive(Clone, Debug)]
+pub struct SoloScope {
+    /// The type aliases currently in scope
+    pub aliases: VecMap<Symbol, Alias>,
+
+    #[allow(dead_code)]
+    /// The current module being processed. This will be used to turn
+    /// unqualified idents into Symbols.
+    solo_home: ModuleId,
+
+    /// Modules that are imported
+    pub modules: ScopeModules,
+
+    /// Identifiers that are in scope, and defined in the current module
+    pub locals: ScopedIdentIds,
+
+    pub early_returns: Vec<(Variable, Region, EarlyReturnKind)>,
+}
+
+impl Default for SoloScope {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SoloScope {
+    pub fn new() -> Self {
+        let solo_home = ModuleId::first_after_builtins();
+
+        Self {
+            solo_home,
+            locals: ScopedIdentIds::from_ident_ids(solo_home),
+            aliases: VecMap::default(),
+            modules: ScopeModules::new(solo_home),
+            early_returns: Vec::default(),
+        }
+    }
+
+    /// Generates a unique new symbol and return the symbol's unqualified identifier name.
+    pub fn gen_unique_symbol_name(&mut self) -> &str {
+        let ident_id = self.locals.gen_unique();
+        self.locals.ident_ids.get_name(ident_id).unwrap()
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ScopedIdentIds {
+    pub ident_ids: IdentIds,
+    in_scope: BitVec,
+    regions: Vec<Region>,
+    #[allow(dead_code)]
+    solo_home: ModuleId,
+}
+
+impl ScopedIdentIds {
+    fn from_ident_ids(solo_home: ModuleId) -> Self {
+        Self {
+            in_scope: BitVec::repeat(false, 0),
+            ident_ids: IdentIds::default(),
+            regions: vec![Region::zero(); 0],
+            solo_home,
+        }
+    }
+
+    fn gen_unique(&mut self) -> IdentId {
+        let id = self.ident_ids.gen_unique();
+
+        debug_assert_eq!(id.index(), self.in_scope.len());
+        debug_assert_eq!(id.index(), self.regions.len());
+
+        self.in_scope.push(false);
+        self.regions.push(Region::zero());
+
+        id
+    }
+}
+
+#[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<(Variable, Symbol)>>,
+}
+
+impl ScopeModules {
+    pub fn new(home_id: ModuleId) -> 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("".into());
+            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: Option<(Variable, 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);
+        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, Copy)]
+pub struct SymbolLookup {
+    pub symbol: Symbol,
+    pub module_params: Option<(Variable, Symbol)>,
+}
+
+impl SymbolLookup {
+    pub fn new(symbol: Symbol, params: Option<(Variable, 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<(Variable, 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,
+        }
+    }
+}

crates/compiler/can/Cargo.toml

@@ -8,6 +8,7 @@ license.workspace = true
 version.workspace = true
 
 [dependencies]
+roc_can_solo.workspace = true
 roc_collections.workspace = true
 roc_error_macros.workspace = true
 roc_exhaustive.workspace = true

crates/compiler/can/src/env.rs

@@ -11,6 +11,7 @@ use roc_region::all::{LineInfo, Loc, Region};
 use roc_types::subs::Variable;
 
 /// The canonicalization environment for a particular module.
+#[derive(Debug)]
 pub struct Env<'a> {
     /// The module's path. Opaques and unqualified references to identifiers
     /// are assumed to be relative to this path.
@@ -51,6 +52,36 @@ pub struct Env<'a> {
 }
 
 impl<'a> Env<'a> {
+    #[allow(clippy::too_many_arguments)]
+    pub fn from_solo_can(
+        arena: &'a Bump,
+        module_path: &'a Path,
+        home: ModuleId,
+        dep_idents: &'a IdentIdsByModule,
+        qualified_module_ids: &'a PackageModuleIds<'a>,
+        problems: Vec<Problem>,
+        opt_shorthand: Option<&'a str>,
+        src: &'a str,
+        line_info: &'a mut Option<LineInfo>,
+    ) -> Self {
+        Env {
+            arena,
+            src,
+            home,
+            module_path,
+            dep_idents,
+            qualified_module_ids,
+            problems,
+            closures: MutMap::default(),
+            qualified_value_lookups: Default::default(),
+            tailcallable_symbol: None,
+            top_level_symbols: Default::default(),
+            home_params_record: None,
+            opt_shorthand,
+            line_info,
+        }
+    }
+
     #[allow(clippy::too_many_arguments)]
     pub fn new(
         arena: &'a Bump,

crates/compiler/can/src/module.rs

@@ -1,9 +1,6 @@
-use std::path::Path;
-
 use crate::abilities::{AbilitiesStore, ImplKey, PendingAbilitiesStore, ResolvedImpl};
 use crate::annotation::{canonicalize_annotation, AnnotationFor};
 use crate::def::{canonicalize_defs, report_unused_imports, Def, DefKind};
-use crate::desugar::desugar_record_destructures;
 use crate::env::Env;
 use crate::expr::{ClosureData, Declarations, ExpectLookup, Expr, Output, PendingDerives};
 use crate::pattern::{
@@ -16,8 +13,8 @@ use roc_collections::{MutMap, SendMap, VecMap, VecSet};
 use roc_error_macros::internal_error;
 use roc_module::ident::Ident;
 use roc_module::ident::Lowercase;
-use roc_module::symbol::{IdentId, IdentIds, IdentIdsByModule, ModuleId, PackageModuleIds, Symbol};
+use roc_module::symbol::{IdentId, ModuleId, Symbol};
-use roc_parse::ast::{Defs, TypeAnnotation};
+use roc_parse::ast::{Collection, Defs, Pattern as ParsePattern, TypeAnnotation};
 use roc_parse::header::HeaderType;
 use roc_parse::pattern::PatternType;
 use roc_problem::can::{Problem, RuntimeError};
@@ -209,55 +206,19 @@ fn has_no_implementation(expr: &Expr) -> bool {
 #[allow(clippy::too_many_arguments)]
 pub fn canonicalize_module_defs<'a>(
     arena: &'a Bump,
-    loc_defs: &'a mut Defs<'a>,
     header_type: &'a roc_parse::header::HeaderType,
     home: ModuleId,
-    module_path: &'a str,
-    src: &'a str,
-    qualified_module_ids: &'a PackageModuleIds<'a>,
-    exposed_ident_ids: IdentIds,
-    dep_idents: &'a IdentIdsByModule,
-    aliases: MutMap<Symbol, Alias>,
-    imported_abilities_state: PendingAbilitiesStore,
     initial_scope: MutMap<Ident, (Symbol, Region)>,
     exposed_symbols: VecSet<Symbol>,
     symbols_from_requires: &[(Loc<Symbol>, Loc<TypeAnnotation<'a>>)],
     var_store: &mut VarStore,
-    opt_shorthand: Option<&'a str>,
+    mut scope: Scope,
+    mut env: Env<'a>,
+    loc_defs: Defs<'a>,
+    module_params: Option<(Region, Collection<'a, Loc<ParsePattern<'a>>>)>,
 ) -> ModuleOutput {
     let mut can_exposed_imports = MutMap::default();
 
-    let mut scope = Scope::new(
-        home,
-        qualified_module_ids
-            .get_name(home)
-            .expect("home module not found")
-            .as_inner()
-            .to_owned(),
-        exposed_ident_ids,
-        imported_abilities_state,
-    );
-    let mut env = Env::new(
-        arena,
-        src,
-        home,
-        arena.alloc(Path::new(module_path)),
-        dep_idents,
-        qualified_module_ids,
-        opt_shorthand,
-    );
-
-    for (name, alias) in aliases.into_iter() {
-        scope.add_alias(
-            name,
-            alias.region,
-            alias.type_variables,
-            alias.infer_ext_in_output_variables,
-            alias.typ,
-            alias.kind,
-        );
-    }
-
     // Desugar operators (convert them to Apply calls, taking into account
     // operator precedence and associativity rules), before doing other canonicalization.
     //
@@ -266,8 +227,6 @@ pub fn canonicalize_module_defs<'a>(
     // operators, and then again on *their* nested operators, ultimately applying the
     // rules multiple times unnecessarily.
 
-    crate::desugar::desugar_defs_node_values(&mut env, &mut scope, loc_defs);
-
     let mut rigid_variables = RigidVariables::default();
 
     // Initial scope values are treated like defs that appear before any others.
@@ -319,15 +278,7 @@ pub fn canonicalize_module_defs<'a>(
 
     let mut output = Output::default();
 
-    let module_params = header_type.get_params().as_ref().map(
+    let module_params = module_params.map(|(params_region, desugared_patterns)| {
-        |roc_parse::header::ModuleParams {
-             pattern,
-             before_arrow: _,
-             after_arrow: _,
-         }| {
-            let desugared_patterns =
-                desugar_record_destructures(&mut env, &mut scope, pattern.value);
-
         let (destructs, _) = canonicalize_record_destructs(
             &mut env,
             var_store,
@@ -335,7 +286,7 @@ pub fn canonicalize_module_defs<'a>(
             &mut output,
             PatternType::ModuleParams,
             &desugared_patterns,
-                pattern.region,
+            params_region,
             PermitShadows(false),
         );
 
@@ -347,7 +298,7 @@ pub fn canonicalize_module_defs<'a>(
         env.home_params_record = Some((whole_symbol, whole_var));
 
         ModuleParams {
-                region: pattern.region,
+            region: params_region,
             whole_var,
             whole_symbol,
             record_var: var_store.fresh(),
@@ -355,15 +306,14 @@ pub fn canonicalize_module_defs<'a>(
             destructs,
             arity_by_name: Default::default(),
         }
-        },
+    });
-    );
 
     let (defs, output, symbols_introduced, imports_introduced) = canonicalize_defs(
         &mut env,
         output,
         var_store,
         &mut scope,
-        loc_defs,
+        arena.alloc(loc_defs),
         PatternType::TopLevelDef,
     );
 

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

@@ -1,10 +1,11 @@
 extern crate bumpalo;
 
 use self::bumpalo::Bump;
-use roc_can::desugar;
 use roc_can::env::Env;
 use roc_can::expr::{canonicalize_expr, Expr};
 use roc_can::scope::Scope;
+use roc_can_solo::env::SoloEnv;
+use roc_can_solo::scope::SoloScope;
 use roc_collections::all::MutMap;
 use roc_module::symbol::{IdentIds, Interns, ModuleId, ModuleIds, PackageModuleIds, Symbol};
 use roc_problem::can::Problem;
@@ -65,7 +66,9 @@ pub fn can_expr_with(arena: &Bump, home: ModuleId, expr_str: &str) -> CanExprOut
     // visited a BinOp node we'd recursively try to apply this to each of its nested
     // operators, and then again on *their* nested operators, ultimately applying the
     // rules multiple times unnecessarily.
-    let loc_expr = desugar::desugar_expr(&mut env, &mut scope, &loc_expr);
+    let mut solo_env = SoloEnv::new(arena, expr_str, Path::new("Test.roc"));
+    let mut solo_scope = SoloScope::new();
+    let loc_expr = roc_can_solo::desugar::desugar_expr(&mut solo_env, &mut solo_scope, &loc_expr);
 
     scope.add_alias(
         Symbol::NUM_INT,

crates/compiler/load/Cargo.toml

@@ -9,6 +9,7 @@ version.workspace = true
 
 [dependencies]
 roc_can.workspace = true
+roc_can_solo.workspace = true
 roc_collections.workspace = true
 roc_load_internal.workspace = true
 roc_module.workspace = true

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

@@ -3,11 +3,12 @@ extern crate bumpalo;
 use self::bumpalo::Bump;
 use roc_can::abilities::AbilitiesStore;
 use roc_can::constraint::{Constraint, Constraints};
-use roc_can::desugar;
 use roc_can::env::Env;
 use roc_can::expected::Expected;
 use roc_can::expr::{canonicalize_expr, Expr, Output, PendingDerives};
 use roc_can::scope::Scope;
+use roc_can_solo::env::SoloEnv;
+use roc_can_solo::scope::SoloScope;
 use roc_collections::all::{ImMap, MutMap, SendSet};
 use roc_constrain::expr::constrain_expr;
 use roc_derive::SharedDerivedModule;
@@ -162,24 +163,6 @@ pub fn can_expr_with<'a>(
     // ensure the Test module is accessible in our tests
     module_ids.get_or_insert(&PQModuleName::Unqualified("Test".into()));
 
-    let mut scope = Scope::new(
-        home,
-        "TestPath".into(),
-        IdentIds::default(),
-        Default::default(),
-    );
-
-    let dep_idents = IdentIds::exposed_builtins(0);
-    let mut env = Env::new(
-        arena,
-        expr_str,
-        home,
-        Path::new("Test.roc"),
-        &dep_idents,
-        &module_ids,
-        None,
-    );
-
     // Desugar operators (convert them to Apply calls, taking into account
     // operator precedence and associativity rules), before doing other canonicalization.
     //
@@ -187,7 +170,9 @@ pub fn can_expr_with<'a>(
     // visited a BinOp node we'd recursively try to apply this to each of its nested
     // operators, and then again on *their* nested operators, ultimately applying the
     // rules multiple times unnecessarily.
-    let loc_expr = desugar::desugar_expr(&mut env, &mut scope, &loc_expr);
+    let mut solo_env = SoloEnv::new(arena, expr_str, Path::new("Test.roc"));
+    let mut solo_scope = SoloScope::new();
+    let loc_expr = roc_can_solo::desugar::desugar_expr(&mut solo_env, &mut solo_scope, &loc_expr);
 
     let mut scope = Scope::new(
         home,

crates/compiler/load_internal/Cargo.toml

@@ -10,6 +10,7 @@ version.workspace = true
 [dependencies]
 roc_builtins.workspace = true
 roc_can.workspace = true
+roc_can_solo.workspace = true
 roc_work.workspace = true
 roc_checkmate.workspace = true
 roc_collections.workspace = true
@@ -39,6 +40,8 @@ bumpalo.workspace = true
 crossbeam.workspace = true
 parking_lot.workspace = true
 tempfile.workspace = true
+base64-url.workspace = true
+blake3.workspace = true
 
 [dev-dependencies]
 roc_test_utils_dir.workspace = true

crates/compiler/load_internal/src/file.rs

@@ -15,11 +15,14 @@ use parking_lot::Mutex;
 use roc_builtins::roc::module_source;
 use roc_can::abilities::{AbilitiesStore, PendingAbilitiesStore, ResolvedImpl};
 use roc_can::constraint::{Constraint as ConstraintSoa, Constraints, TypeOrVar};
+use roc_can::env::Env;
 use roc_can::expr::{Declarations, ExpectLookup, PendingDerives};
 use roc_can::module::{
     canonicalize_module_defs, ExposedByModule, ExposedForModule, ExposedModuleTypes, Module,
     ModuleParams, ResolvedImplementations, TypeState,
 };
+use roc_can::scope::Scope;
+use roc_can_solo::module::{solo_canonicalize_module_defs, SoloCanOutput};
 use roc_collections::soa::slice_extend_new;
 use roc_collections::{default_hasher, BumpMap, MutMap, MutSet, VecMap, VecSet};
 use roc_constrain::module::constrain_module;
@@ -204,9 +207,20 @@ fn start_phase<'a>(
                     root_type: state.root_type.clone(),
                 }
             }
+            Phase::SoloCanonicalize => {
+                // canonicalize the file
+                let parsed = state.module_cache.parsed.get(&module_id).unwrap().clone();
+
+                BuildTask::SoloCanonicalize { parsed }
+            }
             Phase::CanonicalizeAndConstrain => {
                 // canonicalize the file
                 let parsed = state.module_cache.parsed.remove(&module_id).unwrap();
+                let solo_can_output = state
+                    .module_cache
+                    .solo_canonicalized
+                    .remove(&module_id)
+                    .unwrap();
 
                 let deps_by_name = &parsed.deps_by_name;
                 let num_deps = deps_by_name.len();
@@ -318,6 +332,7 @@ fn start_phase<'a>(
                     exposed_module_ids: state.exposed_modules,
                     exec_mode: state.exec_mode,
                     imported_module_params,
+                    solo_can_output,
                 }
             }
 
@@ -577,6 +592,7 @@ enum Msg<'a> {
     Many(Vec<Msg<'a>>),
     Header(ModuleHeader<'a>),
     Parsed(ParsedModule<'a>),
+    SoloCanonicalized(ModuleId, CanSolo<'a>),
     CanonicalizedAndConstrained(CanAndCon),
     SolvedTypes {
         module_id: ModuleId,
@@ -651,6 +667,9 @@ enum Msg<'a> {
     IncorrectModuleName(FileError<'a, IncorrectModuleName<'a>>),
 }
 
+#[derive(Debug)]
+struct CanSolo<'a>(SoloCanOutput<'a>);
+
 #[derive(Debug)]
 struct CanAndCon {
     constrained_module: ConstrainedModule,
@@ -890,6 +909,9 @@ enum BuildTask<'a> {
         ident_ids_by_module: SharedIdentIdsByModule,
         root_type: RootType,
     },
+    SoloCanonicalize {
+        parsed: ParsedModule<'a>,
+    },
     CanonicalizeAndConstrain {
         parsed: ParsedModule<'a>,
         qualified_module_ids: PackageModuleIds<'a>,
@@ -901,6 +923,7 @@ enum BuildTask<'a> {
         skip_constraint_gen: bool,
         exec_mode: ExecutionMode,
         imported_module_params: VecMap<ModuleId, ModuleParams>,
+        solo_can_output: SoloCanOutput<'a>,
     },
     Solve {
         module: Module,
@@ -2411,6 +2434,23 @@ fn update<'a>(
             Ok(state)
         }
 
+        SoloCanonicalized(module_id, CanSolo(solo_can_output)) => {
+            log!("solo canonicalized module {:?}", module_id);
+
+            state
+                .module_cache
+                .solo_canonicalized
+                .insert(module_id, solo_can_output);
+
+            let work = state
+                .dependencies
+                .notify(module_id, Phase::SoloCanonicalize);
+
+            start_tasks(arena, &mut state, work, injector, worker_wakers)?;
+
+            Ok(state)
+        }
+
         CanonicalizedAndConstrained(CanAndCon {
             constrained_module,
             canonicalization_problems,
@@ -2462,6 +2502,7 @@ fn update<'a>(
 
             Ok(state)
         }
+
         SolvedTypes {
             module_id,
             ident_ids,
@@ -5082,6 +5123,31 @@ fn build_platform_header<'a>(
     build_header(info, parse_state, module_ids, module_timing)
 }
 
+#[allow(clippy::unnecessary_wraps)]
+fn canonicalize_solo<'a>(arena: &'a Bump, parsed: ParsedModule<'a>) -> CanSolo<'a> {
+    let canonicalize_solo_start = Instant::now();
+
+    let ParsedModule {
+        module_path,
+        header_type,
+        src,
+        parsed_defs,
+        mut module_timing,
+        ..
+    } = parsed;
+
+    let parsed_defs = arena.alloc(parsed_defs);
+
+    let solo_can_output =
+        solo_canonicalize_module_defs(arena, header_type, parsed_defs, module_path, src);
+
+    let canonicalize_solo_end = Instant::now();
+
+    module_timing.canonicalize_solo = canonicalize_solo_end.duration_since(canonicalize_solo_start);
+
+    CanSolo(solo_can_output)
+}
+
 #[allow(clippy::unnecessary_wraps)]
 fn canonicalize_and_constrain<'a>(
     arena: &'a Bump,
@@ -5095,21 +5161,21 @@ fn canonicalize_and_constrain<'a>(
     exposed_module_ids: &[ModuleId],
     exec_mode: ExecutionMode,
     imported_module_params: VecMap<ModuleId, ModuleParams>,
+    solo_can_output: SoloCanOutput<'a>,
 ) -> CanAndCon {
     let canonicalize_start = Instant::now();
 
     let ParsedModule {
         module_id,
         module_path,
-        src,
         header_type,
-        exposed_ident_ids,
         parsed_defs,
         initial_scope,
         available_modules,
         mut module_timing,
         symbols_from_requires,
         opt_shorthand,
+        exposed_ident_ids,
         ..
     } = parsed;
 
@@ -5117,27 +5183,55 @@ fn canonicalize_and_constrain<'a>(
     let _before = roc_types::types::get_type_clone_count();
 
     let parsed_defs_for_docs = parsed_defs.clone();
-    let parsed_defs = arena.alloc(parsed_defs);
 
     let mut var_store = VarStore::default();
 
+    let env = Env::from_solo_can(
+        arena,
+        &module_path,
+        module_id,
+        &dep_idents,
+        qualified_module_ids,
+        solo_can_output.problems,
+        opt_shorthand,
+        solo_can_output.src,
+        solo_can_output.lazy_line_info,
+    );
+
+    let mut scope = Scope::new(
+        module_id,
+        qualified_module_ids
+            .get_name(module_id)
+            .expect("home module not found")
+            .as_inner()
+            .to_owned(),
+        exposed_ident_ids,
+        imported_abilities_state,
+    );
+
+    for (name, alias) in aliases.into_iter() {
+        scope.add_alias(
+            name,
+            alias.region,
+            alias.type_variables,
+            alias.infer_ext_in_output_variables,
+            alias.typ,
+            alias.kind,
+        );
+    }
+
     let mut module_output = canonicalize_module_defs(
         arena,
-        parsed_defs,
         &header_type,
         module_id,
-        &*arena.alloc(module_path.to_string_lossy()),
-        src,
-        qualified_module_ids,
-        exposed_ident_ids,
-        &dep_idents,
-        aliases,
-        imported_abilities_state,
         initial_scope,
         exposed_symbols,
         &symbols_from_requires,
         &mut var_store,
-        opt_shorthand,
+        scope,
+        env,
+        solo_can_output.loc_defs,
+        solo_can_output.module_params,
     );
 
     let mut types = Types::new();
@@ -6237,6 +6331,12 @@ fn run_task<'a>(
             ident_ids_by_module,
             root_type,
         ),
+        SoloCanonicalize { parsed } => {
+            let module_id = parsed.module_id;
+            let solo_can = canonicalize_solo(arena, parsed);
+
+            Ok(Msg::SoloCanonicalized(module_id, solo_can))
+        }
         CanonicalizeAndConstrain {
             parsed,
             qualified_module_ids,
@@ -6248,6 +6348,7 @@ fn run_task<'a>(
             exposed_module_ids,
             exec_mode,
             imported_module_params,
+            solo_can_output,
         } => {
             let can_and_con = canonicalize_and_constrain(
                 arena,
@@ -6261,6 +6362,7 @@ fn run_task<'a>(
                 exposed_module_ids,
                 exec_mode,
                 imported_module_params,
+                solo_can_output,
             );
 
             Ok(Msg::CanonicalizedAndConstrained(can_and_con))

crates/compiler/load_internal/src/module.rs

@@ -189,7 +189,7 @@ pub struct MonomorphizedModule<'a> {
     pub glue_layouts: GlueLayouts<'a>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ParsedModule<'a> {
     pub module_id: ModuleId,
     pub module_path: PathBuf,
@@ -237,11 +237,12 @@ pub struct ExposedToHost {
     pub getters: Vec<Symbol>,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct ModuleTiming {
     pub read_roc_file: Duration,
     pub parse_header: Duration,
     pub parse_body: Duration,
+    pub canonicalize_solo: Duration,
     pub canonicalize: Duration,
     pub constrain: Duration,
     pub solve: Duration,
@@ -261,6 +262,7 @@ impl ModuleTiming {
             read_roc_file: Duration::default(),
             parse_header: Duration::default(),
             parse_body: Duration::default(),
+            canonicalize_solo: Duration::default(),
             canonicalize: Duration::default(),
             constrain: Duration::default(),
             solve: Duration::default(),
@@ -281,6 +283,7 @@ impl ModuleTiming {
             read_roc_file,
             parse_header,
             parse_body,
+            canonicalize_solo,
             canonicalize,
             constrain,
             solve,
@@ -297,6 +300,7 @@ impl ModuleTiming {
                 .checked_sub(*find_specializations)?
                 .checked_sub(*solve)?
                 .checked_sub(*constrain)?
+                .checked_sub(*canonicalize_solo)?
                 .checked_sub(*canonicalize)?
                 .checked_sub(*parse_body)?
                 .checked_sub(*parse_header)?

crates/compiler/load_internal/src/module_cache.rs

@@ -5,6 +5,7 @@ use crate::module::{
 };
 use roc_can::abilities::PendingAbilitiesStore;
 use roc_can::module::ModuleParams;
+use roc_can_solo::module::SoloCanOutput;
 use roc_collections::{MutMap, MutSet, VecMap};
 use roc_module::ident::ModuleName;
 use roc_module::symbol::{ModuleId, PQModuleName, Symbol};
@@ -26,6 +27,7 @@ pub(crate) struct ModuleCache<'a> {
     pub(crate) parsed: MutMap<ModuleId, ParsedModule<'a>>,
     pub(crate) aliases: MutMap<ModuleId, MutMap<Symbol, (bool, Alias)>>,
     pub(crate) pending_abilities: MutMap<ModuleId, PendingAbilitiesStore>,
+    pub(crate) solo_canonicalized: MutMap<ModuleId, SoloCanOutput<'a>>,
     pub(crate) constrained: MutMap<ModuleId, ConstrainedModule>,
     pub(crate) module_params: MutMap<ModuleId, ModuleParams>,
     pub(crate) typechecked: MutMap<ModuleId, TypeCheckedModule<'a>>,
@@ -45,6 +47,8 @@ pub(crate) struct ModuleCache<'a> {
     pub(crate) type_problems: MutMap<ModuleId, Vec<TypeError>>,
 
     pub(crate) sources: MutMap<ModuleId, (PathBuf, &'a str)>,
+    #[allow(dead_code)]
+    pub(crate) content_hashes: MutMap<ModuleId, String>,
 }
 
 impl<'a> ModuleCache<'a> {
@@ -65,6 +69,19 @@ impl<'a> ModuleCache<'a> {
     pub fn has_errors(&self) -> bool {
         self.has_can_errors() || self.has_type_errors()
     }
+
+    #[allow(dead_code)]
+    pub fn add_module_content_hash(&mut self, module_id: ModuleId, contents: &str) -> String {
+        let hash = Self::hash_contents(contents);
+        self.content_hashes.insert(module_id, hash.clone());
+
+        hash
+    }
+
+    #[allow(dead_code)]
+    pub fn hash_contents(contents: &str) -> String {
+        base64_url::encode(blake3::hash(contents.as_bytes()).as_bytes())
+    }
 }
 
 impl Default for ModuleCache<'_> {
@@ -101,6 +118,7 @@ impl Default for ModuleCache<'_> {
             parsed: Default::default(),
             aliases: Default::default(),
             pending_abilities: Default::default(),
+            solo_canonicalized: Default::default(),
             constrained: Default::default(),
             module_params: Default::default(),
             typechecked: Default::default(),
@@ -116,6 +134,7 @@ impl Default for ModuleCache<'_> {
             can_problems: Default::default(),
             type_problems: Default::default(),
             sources: Default::default(),
+            content_hashes: Default::default(),
         }
     }
 }

crates/compiler/module/src/symbol.rs

@@ -986,6 +986,10 @@ macro_rules! define_builtins {
                 self.to_zero_indexed() < $total
             }
 
+            pub const fn first_after_builtins() -> Self {
+                ModuleId::from_zero_indexed($total)
+            }
+
             $(
                 pub const $module_const: ModuleId = ModuleId::from_zero_indexed($module_id);
             )+

crates/compiler/parse/src/header.rs

@@ -927,7 +927,7 @@ impl<'a> HeaderType<'a> {
     }
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum HeaderType<'a> {
     App {
         provides: &'a [Loc<ExposedName<'a>>],

crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt

@@ -51,7 +51,7 @@ procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
     let List.681 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
     ret List.681;
 
-procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.80 (Bool.22, Bool.23, Bool.24, Bool.25, Bool.26):
     joinpoint List.695 List.566 List.567 List.568 List.569 List.570:
         let List.697 : Int1 = CallByName Num.22 List.569 List.570;
         if List.697 then
@@ -75,8 +75,8 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
             let List.696 : [C U64, C U64] = TagId(1) List.567;
             ret List.696;
     in
-    inc #Derived_gen.0;
+    inc Bool.22;
-    jump List.695 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.695 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_mono/generated/binary_tree_fbip.txt

@@ -8,7 +8,7 @@ procedure Test.4 (Test.27):
     let Test.38 : I64 = CallByName Test.5 Test.27 Test.39 Test.40;
     ret Test.38;
 
-procedure Test.5 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
+procedure Test.5 (Bool.21, Bool.22, Bool.23):
     joinpoint Test.41 Test.29 Test.30 Test.31:
         let Test.51 : U8 = 0i64;
         let Test.52 : U8 = GetTagId Test.29;
@@ -16,22 +16,22 @@ procedure Test.5 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
         if Test.53 then
             let Test.32 : [<rnu><null>, C *self *self] = UnionAtIndex (Id 0) (Index 0) Test.29;
             let Test.33 : [<rnu><null>, C *self *self] = UnionAtIndex (Id 0) (Index 1) Test.29;
-            joinpoint #Derived_gen.3 #Derived_gen.6:
+            joinpoint Bool.24 Bool.27:
-                let #Derived_gen.7 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = lowlevel PtrCast #Derived_gen.6;
+                let Bool.28 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = lowlevel PtrCast Bool.27;
-                let Test.43 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = Reuse #Derived_gen.7 UpdateModeId { id: 1 } TagId(1) Test.33 Test.30;
+                let Test.43 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = Reuse Bool.28 UpdateModeId { id: 1 } TagId(1) Test.33 Test.30;
                 let Test.45 : I64 = 1i64;
                 let Test.44 : I64 = CallByName Num.19 Test.31 Test.45;
                 jump Test.41 Test.32 Test.43 Test.44;
             in
-            let #Derived_gen.4 : Int1 = lowlevel RefCountIsUnique Test.29;
+            let Bool.25 : Int1 = lowlevel RefCountIsUnique Test.29;
-            if #Derived_gen.4 then
+            if Bool.25 then
-                jump #Derived_gen.3 Test.29;
+                jump Bool.24 Test.29;
             else
                 inc Test.32;
                 inc Test.33;
                 decref Test.29;
-                let #Derived_gen.8 : [<rnu><null>, C *self *self] = NullPointer;
+                let Bool.29 : [<rnu><null>, C *self *self] = NullPointer;
-                jump #Derived_gen.3 #Derived_gen.8;
+                jump Bool.24 Bool.29;
         else
             let Test.48 : U8 = 1i64;
             let Test.49 : U8 = GetTagId Test.30;
@@ -39,8 +39,8 @@ procedure Test.5 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
             if Test.50 then
                 let Test.35 : [<rnu><null>, C *self *self] = UnionAtIndex (Id 1) (Index 0) Test.30;
                 let Test.36 : [<rnu>C [<rnu><null>, C *self *self] *self, <null>] = UnionAtIndex (Id 1) (Index 1) Test.30;
-                let #Derived_gen.5 : Int1 = lowlevel RefCountIsUnique Test.30;
+                let Bool.26 : Int1 = lowlevel RefCountIsUnique Test.30;
-                if #Derived_gen.5 then
+                if Bool.26 then
                     free Test.30;
                     jump Test.41 Test.35 Test.36 Test.31;
                 else
@@ -51,7 +51,7 @@ procedure Test.5 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
             else
                 ret Test.31;
     in
-    jump Test.41 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2;
+    jump Test.41 Bool.21 Bool.22 Bool.23;
 
 procedure Test.0 ():
     let Test.64 : [<rnu><null>, C *self *self] = TagId(1) ;

crates/compiler/test_mono/generated/call_function_in_empty_list.txt

@@ -1,4 +1,4 @@
-procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.101 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
     joinpoint List.681 List.175 List.176 List.177 List.178 List.179:
         let List.683 : Int1 = CallByName Num.22 List.178 List.179;
         if List.683 then
@@ -11,8 +11,8 @@ procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.0;
+    inc Bool.21;
-    jump List.681 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.681 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.679 : U64 = 0i64;

crates/compiler/test_mono/generated/call_function_in_empty_list_unbound.txt

@@ -1,4 +1,4 @@
-procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.101 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
     joinpoint List.681 List.175 List.176 List.177 List.178 List.179:
         let List.683 : Int1 = CallByName Num.22 List.178 List.179;
         if List.683 then
@@ -11,8 +11,8 @@ procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.0;
+    inc Bool.21;
-    jump List.681 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.681 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.679 : U64 = 0i64;

crates/compiler/test_mono/generated/capture_void_layout_task.txt

@@ -1,4 +1,4 @@
-procedure List.101 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_gen.16, #Derived_gen.17):
+procedure List.101 (Bool.34, Bool.35, Bool.36, Bool.37, Bool.38):
     joinpoint List.678 List.175 List.176 List.177 List.178 List.179:
         let List.680 : Int1 = CallByName Num.22 List.178 List.179;
         if List.680 then
@@ -11,8 +11,8 @@ procedure List.101 (#Derived_gen.13, #Derived_gen.14, #Derived_gen.15, #Derived_
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.13;
+    inc Bool.34;
-    jump List.678 #Derived_gen.13 #Derived_gen.14 #Derived_gen.15 #Derived_gen.16 #Derived_gen.17;
+    jump List.678 Bool.34 Bool.35 Bool.36 Bool.37 Bool.38;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.676 : U64 = 0i64;
@@ -38,8 +38,8 @@ procedure Num.51 (#Attr.2, #Attr.3):
 
 procedure Test.10 (Test.69, #Attr.12):
     let Test.72 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    let #Derived_gen.18 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+    let Bool.39 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-    if #Derived_gen.18 then
+    if Bool.39 then
         free #Attr.12;
         ret Test.72;
     else
@@ -53,7 +53,7 @@ procedure Test.10 (Test.69, #Attr.12):
 procedure Test.14 (Test.45, #Attr.12):
     let Test.55 : {{}, []} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
     let Test.54 : [<r>C {}, C *self {{}, []}] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-    joinpoint #Derived_gen.19:
+    joinpoint Bool.40:
         let Test.50 : {} = Struct {};
         let Test.51 : U8 = GetTagId Test.54;
         joinpoint Test.52 Test.15:
@@ -80,14 +80,14 @@ procedure Test.14 (Test.45, #Attr.12):
                 jump Test.52 Test.53;
         
     in
-    let #Derived_gen.20 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+    let Bool.41 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-    if #Derived_gen.20 then
+    if Bool.41 then
         free #Attr.12;
-        jump #Derived_gen.19;
+        jump Bool.40;
     else
         inc Test.54;
         decref #Attr.12;
-        jump #Derived_gen.19;
+        jump Bool.40;
 
 procedure Test.20 (Test.21, Test.18):
     let Test.23 : [C {}, C []] = CallByName Test.32 Test.21 Test.18;

crates/compiler/test_mono/generated/choose_correct_recursion_var_under_record.txt

@@ -8,7 +8,7 @@ procedure Test.2 (Test.6):
     let Test.24 : Int1 = lowlevel Eq Test.22 Test.23;
     if Test.24 then
         let Test.7 : [<r>C List *self, C *self] = UnionAtIndex (Id 1) (Index 0) Test.6;
-        joinpoint #Derived_gen.1:
+        joinpoint Bool.23:
             let Test.8 : Str = CallByName Test.2 Test.7;
             let Test.18 : Int1 = CallByName Bool.1;
             if Test.18 then
@@ -18,29 +18,29 @@ procedure Test.2 (Test.6):
                 let Test.17 : Str = "foo";
                 ret Test.17;
         in
-        let #Derived_gen.2 : Int1 = lowlevel RefCountIsUnique Test.6;
+        let Bool.24 : Int1 = lowlevel RefCountIsUnique Test.6;
-        if #Derived_gen.2 then
+        if Bool.24 then
             free Test.6;
-            jump #Derived_gen.1;
+            jump Bool.23;
         else
             inc Test.7;
             decref Test.6;
-            jump #Derived_gen.1;
+            jump Bool.23;
     else
         let Test.9 : List [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = UnionAtIndex (Id 0) (Index 0) Test.6;
-        joinpoint #Derived_gen.3:
+        joinpoint Bool.25:
             dec Test.9;
             let Test.21 : Str = "ValueNotExposed { module_name: ModuleName(IdentStr { string: \"Result\" }), ident: Ident(IdentStr { string: \"withDefault\" }), region: @662-680, exposed_values: ['is_err', 'on_err', 'map_ok', 'map_err', 'with_default', 'try', 'is_ok', 'map_both', 'map2', 'on_err!'] }";
             Crash Test.21
         in
-        let #Derived_gen.4 : Int1 = lowlevel RefCountIsUnique Test.6;
+        let Bool.26 : Int1 = lowlevel RefCountIsUnique Test.6;
-        if #Derived_gen.4 then
+        if Bool.26 then
             free Test.6;
-            jump #Derived_gen.3;
+            jump Bool.25;
         else
             inc Test.9;
             decref Test.6;
-            jump #Derived_gen.3;
+            jump Bool.25;
 
 procedure Test.0 ():
     let Test.25 : List [<r>C List [<r>C List *self, C *self], C [<r>C List *self, C *self]] = Array [];

crates/compiler/test_mono/generated/compose_recursive_lambda_set_productive_nullable_wrapped.txt

@@ -2,7 +2,7 @@ procedure Bool.2 ():
     let Bool.21 : Int1 = true;
     ret Bool.21;
 
-procedure List.101 (#Derived_gen.7, #Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11):
+procedure List.101 (Bool.29, Bool.30, Bool.31, Bool.32, Bool.33):
     joinpoint List.678 List.175 List.176 List.177 List.178 List.179:
         let List.680 : Int1 = CallByName Num.22 List.178 List.179;
         if List.680 then
@@ -15,8 +15,8 @@ procedure List.101 (#Derived_gen.7, #Derived_gen.8, #Derived_gen.9, #Derived_gen
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.7;
+    inc Bool.29;
-    jump List.678 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11;
+    jump List.678 Bool.29 Bool.30 Bool.31 Bool.32 Bool.33;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.676 : U64 = 0i64;
@@ -47,11 +47,11 @@ procedure Str.3 (#Attr.2, #Attr.3):
 procedure Test.1 (Test.5):
     ret Test.5;
 
-procedure Test.11 (#Derived_gen.5, #Derived_gen.6):
+procedure Test.11 (Bool.27, Bool.28):
     joinpoint Test.27 Test.12 #Attr.12:
         let Test.34 : Int1 = UnionAtIndex (Id 2) (Index 1) #Attr.12;
         let Test.33 : [<rnw><null>, C *self Int1, C *self Int1] = UnionAtIndex (Id 2) (Index 0) #Attr.12;
-        joinpoint #Derived_gen.14:
+        joinpoint Bool.36:
             joinpoint Test.31 Test.29:
                 let Test.30 : U8 = GetTagId Test.33;
                 switch Test.30:
@@ -78,16 +78,16 @@ procedure Test.11 (#Derived_gen.5, #Derived_gen.6):
                     jump Test.31 Test.32;
             
         in
-        let #Derived_gen.15 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+        let Bool.37 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-        if #Derived_gen.15 then
+        if Bool.37 then
             free #Attr.12;
-            jump #Derived_gen.14;
+            jump Bool.36;
         else
             inc Test.33;
             decref #Attr.12;
-            jump #Derived_gen.14;
+            jump Bool.36;
     in
-    jump Test.27 #Derived_gen.5 #Derived_gen.6;
+    jump Test.27 Bool.27 Bool.28;
 
 procedure Test.2 (Test.13):
     ret Test.13;
@@ -118,7 +118,7 @@ procedure Test.6 (Test.7, Test.8, Test.5):
 procedure Test.9 (Test.10, #Attr.12):
     let Test.43 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
     let Test.42 : [<rnw><null>, C *self Int1, C *self Int1] = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-    joinpoint #Derived_gen.12:
+    joinpoint Bool.34:
         let Test.39 : U8 = GetTagId Test.42;
         joinpoint Test.40 Test.38:
             switch Test.43:
@@ -146,14 +146,14 @@ procedure Test.9 (Test.10, #Attr.12):
                 jump Test.40 Test.41;
         
     in
-    let #Derived_gen.13 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+    let Bool.35 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-    if #Derived_gen.13 then
+    if Bool.35 then
         free #Attr.12;
-        jump #Derived_gen.12;
+        jump Bool.34;
     else
         inc Test.42;
         decref #Attr.12;
-        jump #Derived_gen.12;
+        jump Bool.34;
 
 procedure Test.0 ():
     let Test.45 : Int1 = false;

crates/compiler/test_mono/generated/dbg_expr.txt

@@ -47,10 +47,10 @@ procedure Str.3 (#Attr.2, #Attr.3):
     ret Str.246;
 
 procedure Test.0 ():
-    let Test.5 : I64 = 1i64;
+    let Test.4 : I64 = 1i64;
-    let Test.2 : I64 = 2i64;
+    let Test.1 : I64 = 2i64;
-    let Test.3 : Str = CallByName Inspect.33 Test.2;
+    let Test.2 : Str = CallByName Inspect.33 Test.1;
-    dbg Test.3;
+    dbg Test.2;
-    dec Test.3;
+    dec Test.2;
-    let Test.4 : I64 = CallByName Num.19 Test.5 Test.2;
+    let Test.3 : I64 = CallByName Num.19 Test.4 Test.1;
-    ret Test.4;
+    ret Test.3;

crates/compiler/test_mono/generated/dbg_inside_string.txt

@@ -167,7 +167,7 @@ procedure Str.45 (Str.91, Str.92, Str.93):
         dec Str.344;
         ret Str.91;
 
-procedure Str.56 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
+procedure Str.56 (Bool.24, Bool.25, Bool.26, Bool.27):
     joinpoint Str.252 Str.96 Str.97 Str.98 Str.99:
         inc Str.97;
         let Str.253 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
@@ -191,9 +191,9 @@ procedure Str.56 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3
             dec Str.97;
             ret Str.257;
     in
-    inc #Derived_gen.3;
+    inc Bool.26;
-    inc #Derived_gen.2;
+    inc Bool.27;
-    jump Str.252 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
+    jump Str.252 Bool.24 Bool.25 Bool.26 Bool.27;
 
 procedure Str.57 (Str.121, Str.122):
     let Str.123 : U64 = CallByName Str.36 Str.121;
@@ -203,7 +203,7 @@ procedure Str.57 (Str.121, Str.122):
     let Str.278 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.279 Str.125;
     ret Str.278;
 
-procedure Str.58 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
+procedure Str.58 (Bool.28, Bool.29, Bool.30, Bool.31):
     joinpoint Str.280 Str.126 Str.127 Str.128 Str.129:
         let Str.282 : Int1 = CallByName Num.23 Str.128 Str.129;
         if Str.282 then
@@ -223,9 +223,9 @@ procedure Str.58 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7
             let Str.281 : [C , C U64] = TagId(0) ;
             ret Str.281;
     in
-    inc #Derived_gen.5;
+    inc Bool.29;
-    inc #Derived_gen.4;
+    inc Bool.28;
-    jump Str.280 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+    jump Str.280 Bool.28 Bool.29 Bool.30 Bool.31;
 
 procedure Str.61 (Str.152, Str.153):
     let Str.311 : Int1 = CallByName Num.22 Str.152 Str.153;
@@ -280,15 +280,15 @@ procedure Str.63 (Str.160):
             ret Str.291;
 
 procedure Test.0 ():
-    let Test.5 : Str = "Hello ";
+    let Test.4 : Str = "Hello ";
-    let Test.2 : Str = "world";
+    let Test.1 : Str = "world";
-    inc Test.2;
+    inc Test.1;
-    let Test.3 : Str = CallByName Inspect.33 Test.2;
+    let Test.2 : Str = CallByName Inspect.33 Test.1;
-    dbg Test.3;
+    dbg Test.2;
-    dec Test.3;
+    dec Test.2;
-    let Test.8 : Str = "!";
+    let Test.7 : Str = "!";
-    let Test.6 : Str = CallByName Str.3 Test.2 Test.8;
+    let Test.5 : Str = CallByName Str.3 Test.1 Test.7;
-    dec Test.8;
+    dec Test.7;
-    let Test.4 : Str = CallByName Str.3 Test.5 Test.6;
+    let Test.3 : Str = CallByName Str.3 Test.4 Test.5;
-    dec Test.6;
+    dec Test.5;
-    ret Test.4;
+    ret Test.3;

crates/compiler/test_mono/generated/dbg_nested_expr.txt

@@ -43,14 +43,14 @@ procedure Str.3 (#Attr.2, #Attr.3):
     ret Str.246;
 
 procedure Test.0 ():
-    let Test.6 : I64 = 1i64;
+    let Test.3 : I64 = 1i64;
-    let Test.7 : Str = CallByName Inspect.33 Test.6;
+    let Test.4 : Str = CallByName Inspect.33 Test.3;
-    dbg Test.7;
+    dbg Test.4;
-    dec Test.7;
+    dec Test.4;
-    let Test.8 : Str = CallByName Inspect.33 Test.6;
+    let Test.5 : Str = CallByName Inspect.33 Test.3;
-    dbg Test.8;
+    dbg Test.5;
-    dec Test.8;
+    dec Test.5;
-    let Test.9 : Str = CallByName Inspect.33 Test.6;
+    let Test.6 : Str = CallByName Inspect.33 Test.3;
-    dbg Test.9;
+    dbg Test.6;
-    dec Test.9;
+    dec Test.6;
-    ret Test.6;
+    ret Test.3;

crates/compiler/test_mono/generated/dbg_str_followed_by_number.txt

@@ -167,7 +167,7 @@ procedure Str.45 (Str.91, Str.92, Str.93):
         dec Str.342;
         ret Str.91;
 
-procedure Str.56 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
+procedure Str.56 (Bool.24, Bool.25, Bool.26, Bool.27):
     joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
         inc Str.97;
         let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
@@ -191,9 +191,9 @@ procedure Str.56 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3
             dec Str.97;
             ret Str.255;
     in
-    inc #Derived_gen.3;
+    inc Bool.26;
-    inc #Derived_gen.2;
+    inc Bool.27;
-    jump Str.250 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
+    jump Str.250 Bool.24 Bool.25 Bool.26 Bool.27;
 
 procedure Str.57 (Str.121, Str.122):
     let Str.123 : U64 = CallByName Str.36 Str.121;
@@ -203,7 +203,7 @@ procedure Str.57 (Str.121, Str.122):
     let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
     ret Str.276;
 
-procedure Str.58 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
+procedure Str.58 (Bool.28, Bool.29, Bool.30, Bool.31):
     joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
         let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
         if Str.280 then
@@ -223,9 +223,9 @@ procedure Str.58 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7
             let Str.279 : [C , C U64] = TagId(0) ;
             ret Str.279;
     in
-    inc #Derived_gen.5;
+    inc Bool.29;
-    inc #Derived_gen.4;
+    inc Bool.28;
-    jump Str.278 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+    jump Str.278 Bool.28 Bool.29 Bool.30 Bool.31;
 
 procedure Str.61 (Str.152, Str.153):
     let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;

crates/compiler/test_mono/generated/dict.txt

@@ -9,8 +9,8 @@ procedure Dict.1 (Dict.732):
 
 procedure Dict.4 (Dict.738):
     let Dict.163 : List {[], []} = StructAtIndex 1 Dict.738;
-    let #Derived_gen.0 : List {U32, U32} = StructAtIndex 0 Dict.738;
+    let Bool.21 : List {U32, U32} = StructAtIndex 0 Dict.738;
-    dec #Derived_gen.0;
+    dec Bool.21;
     let Dict.739 : U64 = CallByName List.6 Dict.163;
     dec Dict.163;
     ret Dict.739;

crates/compiler/test_mono/generated/factorial.txt

@@ -6,7 +6,7 @@ procedure Num.21 (#Attr.2, #Attr.3):
     let Num.283 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
     ret Num.283;
 
-procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
+procedure Test.1 (Bool.21, Bool.22):
     joinpoint Test.7 Test.2 Test.3:
         let Test.13 : I64 = 0i64;
         let Test.14 : Int1 = lowlevel Eq Test.13 Test.2;
@@ -18,7 +18,7 @@ procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
             let Test.11 : I64 = CallByName Num.21 Test.2 Test.3;
             jump Test.7 Test.10 Test.11;
     in
-    jump Test.7 #Derived_gen.0 #Derived_gen.1;
+    jump Test.7 Bool.21 Bool.22;
 
 procedure Test.0 ():
     let Test.5 : I64 = 10i64;

crates/compiler/test_mono/generated/inline_return_joinpoints_in_bool_lambda_set.txt

@@ -9,7 +9,7 @@ procedure Num.19 (#Attr.2, #Attr.3):
 procedure Test.3 (Test.4):
     ret Test.4;
 
-procedure Test.0 (#Derived_gen.0):
+procedure Test.0 (Bool.22):
     joinpoint Test.5 Test.1:
         joinpoint Test.10 Test.2:
             let Test.8 : I64 = 1i64;
@@ -31,4 +31,4 @@ procedure Test.0 (#Derived_gen.0):
             let Test.9 : Int1 = true;
             jump Test.10 Test.9;
     in
-    jump Test.5 #Derived_gen.0;
+    jump Test.5 Bool.22;

crates/compiler/test_mono/generated/inline_return_joinpoints_in_enum_lambda_set.txt

@@ -34,7 +34,7 @@ procedure Test.8 (Test.9):
     let Test.23 : I64 = CallByName Num.19 Test.9 Test.24;
     ret Test.23;
 
-procedure Test.0 (#Derived_gen.0):
+procedure Test.0 (Bool.21):
     joinpoint Test.11 Test.1:
         let Test.25 : I64 = 1i64;
         let Test.13 : I64 = CallByName Num.19 Test.1 Test.25;
@@ -57,4 +57,4 @@ procedure Test.0 (#Derived_gen.0):
                 ret Test.12;
         
     in
-    jump Test.11 #Derived_gen.0;
+    jump Test.11 Bool.21;

crates/compiler/test_mono/generated/inline_return_joinpoints_in_union_lambda_set.txt

@@ -17,7 +17,7 @@ procedure Test.4 (Test.5, #Attr.12):
     let Test.16 : I64 = CallByName Num.19 Test.5 Test.17;
     ret Test.16;
 
-procedure Test.0 (#Derived_gen.0):
+procedure Test.0 (Bool.21):
     joinpoint Test.7 Test.1:
         let Test.21 : I64 = 1i64;
         let Test.9 : I64 = CallByName Num.19 Test.1 Test.21;
@@ -33,4 +33,4 @@ procedure Test.0 (#Derived_gen.0):
                 ret Test.8;
         
     in
-    jump Test.7 #Derived_gen.0;
+    jump Test.7 Bool.21;

crates/compiler/test_mono/generated/inspect_derived_dict.txt

@@ -49,32 +49,32 @@ procedure Dict.1 (Dict.732):
 
 procedure Dict.10 (Dict.733, Dict.186, Dict.187):
     let Dict.185 : List {Str, I64} = StructAtIndex 1 Dict.733;
-    let #Derived_gen.70 : List {U32, U32} = StructAtIndex 0 Dict.733;
+    let #Derived_gen.71 : List {U32, U32} = StructAtIndex 0 Dict.733;
-    dec #Derived_gen.70;
+    dec #Derived_gen.71;
-    let Dict.1110 : {Str, Int1} = CallByName List.18 Dict.185 Dict.186 Dict.187;
+    let Dict.909 : {Str, Int1} = CallByName List.18 Dict.185 Dict.186 Dict.187;
     dec Dict.185;
-    ret Dict.1110;
+    ret Dict.909;
 
 procedure Dict.100 (Dict.546, Dict.547, Dict.548):
-    let Dict.1063 : U8 = CallByName Dict.22 Dict.546 Dict.547;
+    let Dict.1076 : U8 = CallByName Dict.22 Dict.546 Dict.547;
-    let Dict.549 : U64 = CallByName Num.133 Dict.1063;
+    let Dict.549 : U64 = CallByName Num.133 Dict.1076;
-    let Dict.1062 : U8 = 1i64;
+    let Dict.1075 : U8 = 1i64;
-    let Dict.1061 : U64 = CallByName Num.74 Dict.548 Dict.1062;
+    let Dict.1074 : U64 = CallByName Num.74 Dict.548 Dict.1075;
-    let Dict.1060 : U64 = CallByName Num.51 Dict.1061 Dict.547;
+    let Dict.1073 : U64 = CallByName Num.51 Dict.1074 Dict.547;
-    let Dict.1059 : U8 = CallByName Dict.22 Dict.546 Dict.1060;
+    let Dict.1072 : U8 = CallByName Dict.22 Dict.546 Dict.1073;
-    let Dict.550 : U64 = CallByName Num.133 Dict.1059;
+    let Dict.550 : U64 = CallByName Num.133 Dict.1072;
-    let Dict.1058 : U64 = 1i64;
+    let Dict.1071 : U64 = 1i64;
-    let Dict.1057 : U64 = CallByName Num.75 Dict.548 Dict.1058;
+    let Dict.1070 : U64 = CallByName Num.75 Dict.548 Dict.1071;
-    let Dict.1056 : U64 = CallByName Num.51 Dict.1057 Dict.547;
+    let Dict.1069 : U64 = CallByName Num.51 Dict.1070 Dict.547;
-    let Dict.1055 : U8 = CallByName Dict.22 Dict.546 Dict.1056;
+    let Dict.1068 : U8 = CallByName Dict.22 Dict.546 Dict.1069;
-    let Dict.551 : U64 = CallByName Num.133 Dict.1055;
+    let Dict.551 : U64 = CallByName Num.133 Dict.1068;
-    let Dict.1054 : U8 = 16i64;
+    let Dict.1067 : U8 = 16i64;
-    let Dict.1051 : U64 = CallByName Num.72 Dict.549 Dict.1054;
+    let Dict.1064 : U64 = CallByName Num.72 Dict.549 Dict.1067;
-    let Dict.1053 : U8 = 8i64;
+    let Dict.1066 : U8 = 8i64;
-    let Dict.1052 : U64 = CallByName Num.72 Dict.550 Dict.1053;
+    let Dict.1065 : U64 = CallByName Num.72 Dict.550 Dict.1066;
-    let Dict.552 : U64 = CallByName Num.71 Dict.1051 Dict.1052;
+    let Dict.552 : U64 = CallByName Num.71 Dict.1064 Dict.1065;
-    let Dict.1050 : U64 = CallByName Num.71 Dict.552 Dict.551;
+    let Dict.1063 : U64 = CallByName Num.71 Dict.552 Dict.551;
-    ret Dict.1050;
+    ret Dict.1063;
 
 procedure Dict.12 (Dict.158):
     let Dict.892 : {} = Struct {};
@@ -84,12 +84,12 @@ procedure Dict.12 (Dict.158):
     ret Dict.739;
 
 procedure Dict.127 (Dict.128, Dict.126):
-    let Dict.1107 : {} = Struct {};
+    let Dict.906 : {} = Struct {};
-    let Dict.1108 : {} = Struct {};
+    let Dict.907 : {} = Struct {};
-    let Dict.1109 : {} = Struct {};
+    let Dict.908 : {} = Struct {};
-    let Dict.1106 : {{List {U32, U32}, List {Str, I64}, U64, Float32, U8}, {}, {}, {}} = CallByName Inspect.42 Dict.126 Dict.1107 Dict.1108 Dict.1109;
+    let Dict.905 : {{List {U32, U32}, List {Str, I64}, U64, Float32, U8}, {}, {}, {}} = CallByName Inspect.42 Dict.126 Dict.906 Dict.907 Dict.908;
-    let Dict.1105 : Str = CallByName Inspect.31 Dict.1106 Dict.128;
+    let Dict.904 : Str = CallByName Inspect.31 Dict.905 Dict.128;
-    ret Dict.1105;
+    ret Dict.904;
 
 procedure Dict.159 (Dict.160, Dict.742):
     let Dict.161 : Str = StructAtIndex 0 Dict.742;
@@ -97,11 +97,11 @@ procedure Dict.159 (Dict.160, Dict.742):
     let Dict.743 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Dict.8 Dict.160 Dict.161 Dict.162;
     ret Dict.743;
 
-procedure Dict.188 (Dict.189, Dict.1112, Dict.187):
+procedure Dict.188 (Dict.189, Dict.911, Dict.187):
-    let Dict.190 : Str = StructAtIndex 0 Dict.1112;
+    let Dict.190 : Str = StructAtIndex 0 Dict.911;
-    let Dict.191 : I64 = StructAtIndex 1 Dict.1112;
+    let Dict.191 : I64 = StructAtIndex 1 Dict.911;
-    let Dict.1114 : {Str, Int1} = CallByName Inspect.189 Dict.189 Dict.190 Dict.191 Dict.187;
+    let Dict.913 : {Str, Int1} = CallByName Inspect.189 Dict.189 Dict.190 Dict.191 Dict.187;
-    ret Dict.1114;
+    ret Dict.913;
 
 procedure Dict.20 (Dict.729):
     let Dict.155 : U64 = StructAtIndex 2 Dict.729;
@@ -120,8 +120,8 @@ procedure Dict.22 (#Attr.2, #Attr.3):
     ret Dict.790;
 
 procedure Dict.22 (#Attr.2, #Attr.3):
-    let Dict.953 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let Dict.966 : U8 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret Dict.953;
+    ret Dict.966;
 
 procedure Dict.23 (#Attr.2):
     let Dict.826 : U64 = lowlevel DictPseudoSeed #Attr.2;
@@ -146,8 +146,8 @@ procedure Dict.407 (Dict.408, Dict.849, Dict.410, Dict.406):
     ret Dict.851;
 
 procedure Dict.43 (Dict.126):
-    let Dict.1102 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Inspect.30 Dict.126;
+    let Dict.901 : {List {U32, U32}, List {Str, I64}, U64, Float32, U8} = CallByName Inspect.30 Dict.126;
-    ret Dict.1102;
+    ret Dict.901;
 
 procedure Dict.45 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7, #Derived_gen.8):
     joinpoint Dict.745 Dict.228 Dict.229 Dict.230 Dict.231 Dict.232 Dict.233 Dict.234 Dict.235 Dict.236:
@@ -243,8 +243,8 @@ procedure Dict.66 (Dict.728):
     let Dict.386 : U64 = StructAtIndex 2 Dict.728;
     let Dict.387 : Float32 = StructAtIndex 3 Dict.728;
     let Dict.388 : U8 = StructAtIndex 4 Dict.728;
-    let #Derived_gen.71 : List {U32, U32} = StructAtIndex 0 Dict.728;
+    let #Derived_gen.70 : List {U32, U32} = StructAtIndex 0 Dict.728;
-    dec #Derived_gen.71;
+    dec #Derived_gen.70;
     let Dict.886 : U64 = CallByName Dict.54;
     let Dict.845 : Int1 = CallByName Bool.5 Dict.386 Dict.886;
     if Dict.845 then
@@ -427,21 +427,21 @@ procedure Dict.81 (Dict.717, Dict.718):
     let Dict.443 : U64 = StructAtIndex 3 Dict.718;
     let Dict.439 : U64 = StructAtIndex 0 Dict.717;
     let Dict.440 : U64 = StructAtIndex 1 Dict.717;
-    let Dict.922 : U64 = CallByName Dict.93;
+    let Dict.935 : U64 = CallByName Dict.93;
-    let Dict.920 : U64 = CallByName Num.70 Dict.441 Dict.922;
+    let Dict.933 : U64 = CallByName Num.70 Dict.441 Dict.935;
-    let Dict.921 : U64 = CallByName Num.70 Dict.442 Dict.443;
+    let Dict.934 : U64 = CallByName Num.70 Dict.442 Dict.443;
-    let Dict.445 : {U64, U64} = CallByName Dict.97 Dict.920 Dict.921;
+    let Dict.445 : {U64, U64} = CallByName Dict.97 Dict.933 Dict.934;
-    let Dict.917 : U64 = StructAtIndex 0 Dict.445;
+    let Dict.930 : U64 = StructAtIndex 0 Dict.445;
-    let Dict.918 : U64 = CallByName Dict.92;
+    let Dict.931 : U64 = CallByName Dict.92;
-    let Dict.916 : U64 = CallByName Num.70 Dict.917 Dict.918;
+    let Dict.929 : U64 = CallByName Num.70 Dict.930 Dict.931;
-    let Dict.446 : U64 = CallByName Num.70 Dict.916 Dict.444;
+    let Dict.446 : U64 = CallByName Num.70 Dict.929 Dict.444;
-    let Dict.913 : U64 = StructAtIndex 1 Dict.445;
+    let Dict.926 : U64 = StructAtIndex 1 Dict.445;
-    let Dict.914 : U64 = CallByName Dict.93;
+    let Dict.927 : U64 = CallByName Dict.93;
-    let Dict.447 : U64 = CallByName Num.70 Dict.913 Dict.914;
+    let Dict.447 : U64 = CallByName Num.70 Dict.926 Dict.927;
     let Dict.448 : U64 = CallByName Dict.96 Dict.446 Dict.447;
-    let Dict.905 : U64 = CallByName Dict.96 Dict.440 Dict.448;
+    let Dict.918 : U64 = CallByName Dict.96 Dict.440 Dict.448;
-    let Dict.904 : {U64, U64} = Struct {Dict.439, Dict.905};
+    let Dict.917 : {U64, U64} = Struct {Dict.439, Dict.918};
-    ret Dict.904;
+    ret Dict.917;
 
 procedure Dict.82 (Dict.449):
     let Dict.821 : U64 = CallByName Dict.92;
@@ -459,284 +459,284 @@ procedure Dict.89 (Dict.711, Dict.489):
     let Dict.487 : U64 = StructAtIndex 0 Dict.711;
     let Dict.488 : U64 = StructAtIndex 1 Dict.711;
     let Dict.490 : U64 = CallByName List.6 Dict.489;
-    joinpoint Dict.927 Dict.491:
+    joinpoint Dict.940 Dict.491:
-        let Dict.902 : {U64, U64} = Struct {Dict.487, Dict.488};
+        let Dict.915 : {U64, U64} = Struct {Dict.487, Dict.488};
-        let Dict.923 : U64 = StructAtIndex 0 Dict.491;
+        let Dict.936 : U64 = StructAtIndex 0 Dict.491;
-        let Dict.924 : U64 = StructAtIndex 1 Dict.491;
+        let Dict.937 : U64 = StructAtIndex 1 Dict.491;
-        let Dict.925 : U64 = StructAtIndex 2 Dict.491;
+        let Dict.938 : U64 = StructAtIndex 2 Dict.491;
-        let Dict.903 : {U64, U64, U64, U64} = Struct {Dict.923, Dict.924, Dict.490, Dict.925};
+        let Dict.916 : {U64, U64, U64, U64} = Struct {Dict.936, Dict.937, Dict.490, Dict.938};
-        let Dict.901 : {U64, U64} = CallByName Dict.81 Dict.902 Dict.903;
+        let Dict.914 : {U64, U64} = CallByName Dict.81 Dict.915 Dict.916;
-        ret Dict.901;
+        ret Dict.914;
     in
-    let Dict.1101 : U64 = 16i64;
+    let Dict.1114 : U64 = 16i64;
-    let Dict.1041 : Int1 = CallByName Num.23 Dict.490 Dict.1101;
+    let Dict.1054 : Int1 = CallByName Num.23 Dict.490 Dict.1114;
-    if Dict.1041 then
+    if Dict.1054 then
-        joinpoint Dict.1043 Dict.926:
+        joinpoint Dict.1056 Dict.939:
-            jump Dict.927 Dict.926;
+            jump Dict.940 Dict.939;
         in
+        let Dict.1113 : U64 = 4i64;
+        let Dict.1078 : Int1 = CallByName Num.25 Dict.490 Dict.1113;
+        if Dict.1078 then
+            let Dict.1112 : U8 = 3i64;
+            let Dict.1110 : U64 = CallByName Num.74 Dict.490 Dict.1112;
+            let Dict.1111 : U8 = 2i64;
+            let Dict.492 : U64 = CallByName Num.72 Dict.1110 Dict.1111;
+            let Dict.1109 : U64 = 0i64;
+            let Dict.1107 : U64 = CallByName Dict.99 Dict.489 Dict.1109;
+            let Dict.1108 : U8 = 32i64;
+            let Dict.1105 : U64 = CallByName Num.72 Dict.1107 Dict.1108;
+            let Dict.1106 : U64 = CallByName Dict.99 Dict.489 Dict.492;
+            let Dict.493 : U64 = CallByName Num.71 Dict.1105 Dict.1106;
+            let Dict.1104 : U64 = 4i64;
+            let Dict.1103 : U64 = CallByName Num.75 Dict.490 Dict.1104;
+            let Dict.1101 : U64 = CallByName Dict.99 Dict.489 Dict.1103;
+            let Dict.1102 : U8 = 32i64;
+            let Dict.1079 : U64 = CallByName Num.72 Dict.1101 Dict.1102;
             let Dict.1100 : U64 = 4i64;
-        let Dict.1065 : Int1 = CallByName Num.25 Dict.490 Dict.1100;
+            let Dict.1099 : U64 = CallByName Num.75 Dict.490 Dict.1100;
-        if Dict.1065 then
+            let Dict.1081 : U64 = CallByName Num.75 Dict.1099 Dict.492;
-            let Dict.1099 : U8 = 3i64;
+            let Dict.1080 : U64 = CallByName Dict.99 Dict.489 Dict.1081;
-            let Dict.1097 : U64 = CallByName Num.74 Dict.490 Dict.1099;
+            let Dict.494 : U64 = CallByName Num.71 Dict.1079 Dict.1080;
-            let Dict.1098 : U8 = 2i64;
+            let Dict.1055 : {U64, U64, U64} = Struct {Dict.493, Dict.494, Dict.487};
-            let Dict.492 : U64 = CallByName Num.72 Dict.1097 Dict.1098;
+            jump Dict.1056 Dict.1055;
-            let Dict.1096 : U64 = 0i64;
-            let Dict.1094 : U64 = CallByName Dict.99 Dict.489 Dict.1096;
-            let Dict.1095 : U8 = 32i64;
-            let Dict.1092 : U64 = CallByName Num.72 Dict.1094 Dict.1095;
-            let Dict.1093 : U64 = CallByName Dict.99 Dict.489 Dict.492;
-            let Dict.493 : U64 = CallByName Num.71 Dict.1092 Dict.1093;
-            let Dict.1091 : U64 = 4i64;
-            let Dict.1090 : U64 = CallByName Num.75 Dict.490 Dict.1091;
-            let Dict.1088 : U64 = CallByName Dict.99 Dict.489 Dict.1090;
-            let Dict.1089 : U8 = 32i64;
-            let Dict.1066 : U64 = CallByName Num.72 Dict.1088 Dict.1089;
-            let Dict.1087 : U64 = 4i64;
-            let Dict.1086 : U64 = CallByName Num.75 Dict.490 Dict.1087;
-            let Dict.1068 : U64 = CallByName Num.75 Dict.1086 Dict.492;
-            let Dict.1067 : U64 = CallByName Dict.99 Dict.489 Dict.1068;
-            let Dict.494 : U64 = CallByName Num.71 Dict.1066 Dict.1067;
-            let Dict.1042 : {U64, U64, U64} = Struct {Dict.493, Dict.494, Dict.487};
-            jump Dict.1043 Dict.1042;
         else
-            let Dict.1064 : U64 = 0i64;
+            let Dict.1077 : U64 = 0i64;
-            let Dict.1046 : Int1 = CallByName Num.24 Dict.490 Dict.1064;
+            let Dict.1059 : Int1 = CallByName Num.24 Dict.490 Dict.1077;
-            if Dict.1046 then
+            if Dict.1059 then
-                let Dict.1049 : U64 = 0i64;
+                let Dict.1062 : U64 = 0i64;
-                let Dict.1047 : U64 = CallByName Dict.100 Dict.489 Dict.1049 Dict.490;
+                let Dict.1060 : U64 = CallByName Dict.100 Dict.489 Dict.1062 Dict.490;
-                let Dict.1048 : U64 = 0i64;
+                let Dict.1061 : U64 = 0i64;
-                let Dict.1042 : {U64, U64, U64} = Struct {Dict.1047, Dict.1048, Dict.487};
+                let Dict.1055 : {U64, U64, U64} = Struct {Dict.1060, Dict.1061, Dict.487};
-                jump Dict.1043 Dict.1042;
+                jump Dict.1056 Dict.1055;
             else
-                let Dict.1044 : U64 = 0i64;
+                let Dict.1057 : U64 = 0i64;
-                let Dict.1045 : U64 = 0i64;
+                let Dict.1058 : U64 = 0i64;
-                let Dict.1042 : {U64, U64, U64} = Struct {Dict.1044, Dict.1045, Dict.487};
+                let Dict.1055 : {U64, U64, U64} = Struct {Dict.1057, Dict.1058, Dict.487};
-                jump Dict.1043 Dict.1042;
+                jump Dict.1056 Dict.1055;
     else
-        let Dict.1040 : U64 = 48i64;
+        let Dict.1053 : U64 = 48i64;
-        let Dict.1038 : Int1 = CallByName Num.23 Dict.490 Dict.1040;
+        let Dict.1051 : Int1 = CallByName Num.23 Dict.490 Dict.1053;
-        if Dict.1038 then
+        if Dict.1051 then
-            let Dict.1039 : U64 = 0i64;
+            let Dict.1052 : U64 = 0i64;
-            let Dict.926 : {U64, U64, U64} = CallByName Dict.91 Dict.487 Dict.489 Dict.1039 Dict.490;
+            let Dict.939 : {U64, U64, U64} = CallByName Dict.91 Dict.487 Dict.489 Dict.1052 Dict.490;
-            jump Dict.927 Dict.926;
+            jump Dict.940 Dict.939;
         else
-            let Dict.928 : U64 = 0i64;
+            let Dict.941 : U64 = 0i64;
-            let Dict.926 : {U64, U64, U64} = CallByName Dict.90 Dict.487 Dict.487 Dict.487 Dict.489 Dict.928 Dict.490;
+            let Dict.939 : {U64, U64, U64} = CallByName Dict.90 Dict.487 Dict.487 Dict.487 Dict.489 Dict.941 Dict.490;
-            jump Dict.927 Dict.926;
+            jump Dict.940 Dict.939;
 
 procedure Dict.90 (#Derived_gen.24, #Derived_gen.25, #Derived_gen.26, #Derived_gen.27, #Derived_gen.28, #Derived_gen.29):
-    joinpoint Dict.929 Dict.495 Dict.496 Dict.497 Dict.498 Dict.499 Dict.500:
+    joinpoint Dict.942 Dict.495 Dict.496 Dict.497 Dict.498 Dict.499 Dict.500:
-        let Dict.1036 : U64 = CallByName Dict.98 Dict.498 Dict.499;
+        let Dict.1049 : U64 = CallByName Dict.98 Dict.498 Dict.499;
-        let Dict.1037 : U64 = CallByName Dict.93;
+        let Dict.1050 : U64 = CallByName Dict.93;
-        let Dict.1031 : U64 = CallByName Num.70 Dict.1036 Dict.1037;
+        let Dict.1044 : U64 = CallByName Num.70 Dict.1049 Dict.1050;
-        let Dict.1035 : U64 = 8i64;
+        let Dict.1048 : U64 = 8i64;
-        let Dict.1034 : U64 = CallByName Num.51 Dict.499 Dict.1035;
+        let Dict.1047 : U64 = CallByName Num.51 Dict.499 Dict.1048;
-        let Dict.1033 : U64 = CallByName Dict.98 Dict.498 Dict.1034;
+        let Dict.1046 : U64 = CallByName Dict.98 Dict.498 Dict.1047;
-        let Dict.1032 : U64 = CallByName Num.70 Dict.1033 Dict.495;
+        let Dict.1045 : U64 = CallByName Num.70 Dict.1046 Dict.495;
-        let Dict.501 : U64 = CallByName Dict.96 Dict.1031 Dict.1032;
+        let Dict.501 : U64 = CallByName Dict.96 Dict.1044 Dict.1045;
-        let Dict.1030 : U64 = 16i64;
+        let Dict.1043 : U64 = 16i64;
-        let Dict.1029 : U64 = CallByName Num.51 Dict.499 Dict.1030;
+        let Dict.1042 : U64 = CallByName Num.51 Dict.499 Dict.1043;
-        let Dict.1026 : U64 = CallByName Dict.98 Dict.498 Dict.1029;
+        let Dict.1039 : U64 = CallByName Dict.98 Dict.498 Dict.1042;
-        let Dict.1027 : U64 = CallByName Dict.94;
+        let Dict.1040 : U64 = CallByName Dict.94;
-        let Dict.1021 : U64 = CallByName Num.70 Dict.1026 Dict.1027;
+        let Dict.1034 : U64 = CallByName Num.70 Dict.1039 Dict.1040;
-        let Dict.1025 : U64 = 24i64;
+        let Dict.1038 : U64 = 24i64;
-        let Dict.1024 : U64 = CallByName Num.51 Dict.499 Dict.1025;
+        let Dict.1037 : U64 = CallByName Num.51 Dict.499 Dict.1038;
-        let Dict.1023 : U64 = CallByName Dict.98 Dict.498 Dict.1024;
+        let Dict.1036 : U64 = CallByName Dict.98 Dict.498 Dict.1037;
-        let Dict.1022 : U64 = CallByName Num.70 Dict.1023 Dict.496;
+        let Dict.1035 : U64 = CallByName Num.70 Dict.1036 Dict.496;
-        let Dict.502 : U64 = CallByName Dict.96 Dict.1021 Dict.1022;
+        let Dict.502 : U64 = CallByName Dict.96 Dict.1034 Dict.1035;
-        let Dict.1020 : U64 = 32i64;
+        let Dict.1033 : U64 = 32i64;
-        let Dict.1019 : U64 = CallByName Num.51 Dict.499 Dict.1020;
+        let Dict.1032 : U64 = CallByName Num.51 Dict.499 Dict.1033;
-        let Dict.1016 : U64 = CallByName Dict.98 Dict.498 Dict.1019;
+        let Dict.1029 : U64 = CallByName Dict.98 Dict.498 Dict.1032;
-        let Dict.1017 : U64 = CallByName Dict.95;
+        let Dict.1030 : U64 = CallByName Dict.95;
-        let Dict.1011 : U64 = CallByName Num.70 Dict.1016 Dict.1017;
+        let Dict.1024 : U64 = CallByName Num.70 Dict.1029 Dict.1030;
-        let Dict.1015 : U64 = 40i64;
+        let Dict.1028 : U64 = 40i64;
-        let Dict.1014 : U64 = CallByName Num.51 Dict.499 Dict.1015;
+        let Dict.1027 : U64 = CallByName Num.51 Dict.499 Dict.1028;
-        let Dict.1013 : U64 = CallByName Dict.98 Dict.498 Dict.1014;
+        let Dict.1026 : U64 = CallByName Dict.98 Dict.498 Dict.1027;
-        let Dict.1012 : U64 = CallByName Num.70 Dict.1013 Dict.497;
+        let Dict.1025 : U64 = CallByName Num.70 Dict.1026 Dict.497;
-        let Dict.503 : U64 = CallByName Dict.96 Dict.1011 Dict.1012;
+        let Dict.503 : U64 = CallByName Dict.96 Dict.1024 Dict.1025;
-        let Dict.1010 : U64 = 48i64;
+        let Dict.1023 : U64 = 48i64;
-        let Dict.504 : U64 = CallByName Num.75 Dict.500 Dict.1010;
+        let Dict.504 : U64 = CallByName Num.75 Dict.500 Dict.1023;
-        let Dict.1009 : U64 = 48i64;
+        let Dict.1022 : U64 = 48i64;
-        let Dict.505 : U64 = CallByName Num.51 Dict.499 Dict.1009;
+        let Dict.505 : U64 = CallByName Num.51 Dict.499 Dict.1022;
-        let Dict.1008 : U64 = 48i64;
+        let Dict.1021 : U64 = 48i64;
-        let Dict.1006 : Int1 = CallByName Num.24 Dict.504 Dict.1008;
+        let Dict.1019 : Int1 = CallByName Num.24 Dict.504 Dict.1021;
-        if Dict.1006 then
+        if Dict.1019 then
-            jump Dict.929 Dict.501 Dict.502 Dict.503 Dict.498 Dict.505 Dict.504;
+            jump Dict.942 Dict.501 Dict.502 Dict.503 Dict.498 Dict.505 Dict.504;
         else
-            let Dict.1005 : U64 = 16i64;
+            let Dict.1018 : U64 = 16i64;
-            let Dict.980 : Int1 = CallByName Num.24 Dict.504 Dict.1005;
+            let Dict.993 : Int1 = CallByName Num.24 Dict.504 Dict.1018;
-            if Dict.980 then
+            if Dict.993 then
-                let Dict.1004 : U64 = CallByName Num.70 Dict.502 Dict.501;
+                let Dict.1017 : U64 = CallByName Num.70 Dict.502 Dict.501;
-                let Dict.506 : U64 = CallByName Num.70 Dict.503 Dict.1004;
+                let Dict.506 : U64 = CallByName Num.70 Dict.503 Dict.1017;
-                let Dict.981 : {U64, U64, U64} = CallByName Dict.91 Dict.506 Dict.498 Dict.505 Dict.504;
+                let Dict.994 : {U64, U64, U64} = CallByName Dict.91 Dict.506 Dict.498 Dict.505 Dict.504;
                 dec Dict.498;
-                ret Dict.981;
+                ret Dict.994;
             else
-                let Dict.979 : U64 = CallByName Num.70 Dict.502 Dict.501;
+                let Dict.992 : U64 = CallByName Num.70 Dict.502 Dict.501;
-                let Dict.507 : U64 = CallByName Num.70 Dict.503 Dict.979;
+                let Dict.507 : U64 = CallByName Num.70 Dict.503 Dict.992;
-                let Dict.978 : U64 = 16i64;
+                let Dict.991 : U64 = 16i64;
-                let Dict.977 : U64 = CallByName Num.75 Dict.504 Dict.978;
+                let Dict.990 : U64 = CallByName Num.75 Dict.504 Dict.991;
-                let Dict.976 : U64 = CallByName Num.51 Dict.977 Dict.505;
+                let Dict.989 : U64 = CallByName Num.51 Dict.990 Dict.505;
-                let Dict.931 : U64 = CallByName Dict.98 Dict.498 Dict.976;
+                let Dict.944 : U64 = CallByName Dict.98 Dict.498 Dict.989;
-                let Dict.975 : U64 = 8i64;
+                let Dict.988 : U64 = 8i64;
-                let Dict.974 : U64 = CallByName Num.75 Dict.504 Dict.975;
+                let Dict.987 : U64 = CallByName Num.75 Dict.504 Dict.988;
-                let Dict.933 : U64 = CallByName Num.51 Dict.974 Dict.505;
+                let Dict.946 : U64 = CallByName Num.51 Dict.987 Dict.505;
-                let Dict.932 : U64 = CallByName Dict.98 Dict.498 Dict.933;
+                let Dict.945 : U64 = CallByName Dict.98 Dict.498 Dict.946;
                 dec Dict.498;
-                let Dict.930 : {U64, U64, U64} = Struct {Dict.931, Dict.932, Dict.507};
+                let Dict.943 : {U64, U64, U64} = Struct {Dict.944, Dict.945, Dict.507};
-                ret Dict.930;
+                ret Dict.943;
     in
     inc #Derived_gen.27;
-    jump Dict.929 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29;
+    jump Dict.942 #Derived_gen.24 #Derived_gen.25 #Derived_gen.26 #Derived_gen.27 #Derived_gen.28 #Derived_gen.29;
 
 procedure Dict.91 (#Derived_gen.30, #Derived_gen.31, #Derived_gen.32, #Derived_gen.33):
-    joinpoint Dict.982 Dict.508 Dict.509 Dict.510 Dict.511:
+    joinpoint Dict.995 Dict.508 Dict.509 Dict.510 Dict.511:
-        let Dict.1002 : U64 = CallByName Dict.98 Dict.509 Dict.510;
+        let Dict.1015 : U64 = CallByName Dict.98 Dict.509 Dict.510;
-        let Dict.1003 : U64 = CallByName Dict.93;
+        let Dict.1016 : U64 = CallByName Dict.93;
-        let Dict.997 : U64 = CallByName Num.70 Dict.1002 Dict.1003;
+        let Dict.1010 : U64 = CallByName Num.70 Dict.1015 Dict.1016;
-        let Dict.1001 : U64 = 8i64;
+        let Dict.1014 : U64 = 8i64;
-        let Dict.1000 : U64 = CallByName Num.51 Dict.510 Dict.1001;
+        let Dict.1013 : U64 = CallByName Num.51 Dict.510 Dict.1014;
-        let Dict.999 : U64 = CallByName Dict.98 Dict.509 Dict.1000;
+        let Dict.1012 : U64 = CallByName Dict.98 Dict.509 Dict.1013;
-        let Dict.998 : U64 = CallByName Num.70 Dict.999 Dict.508;
+        let Dict.1011 : U64 = CallByName Num.70 Dict.1012 Dict.508;
-        let Dict.512 : U64 = CallByName Dict.96 Dict.997 Dict.998;
+        let Dict.512 : U64 = CallByName Dict.96 Dict.1010 Dict.1011;
-        let Dict.996 : U64 = 16i64;
+        let Dict.1009 : U64 = 16i64;
-        let Dict.513 : U64 = CallByName Num.75 Dict.511 Dict.996;
+        let Dict.513 : U64 = CallByName Num.75 Dict.511 Dict.1009;
-        let Dict.995 : U64 = 16i64;
+        let Dict.1008 : U64 = 16i64;
-        let Dict.514 : U64 = CallByName Num.51 Dict.510 Dict.995;
+        let Dict.514 : U64 = CallByName Num.51 Dict.510 Dict.1008;
-        let Dict.994 : U64 = 16i64;
+        let Dict.1007 : U64 = 16i64;
-        let Dict.984 : Int1 = CallByName Num.23 Dict.513 Dict.994;
+        let Dict.997 : Int1 = CallByName Num.23 Dict.513 Dict.1007;
-        if Dict.984 then
+        if Dict.997 then
-            let Dict.993 : U64 = 16i64;
+            let Dict.1006 : U64 = 16i64;
-            let Dict.992 : U64 = CallByName Num.75 Dict.513 Dict.993;
+            let Dict.1005 : U64 = CallByName Num.75 Dict.513 Dict.1006;
-            let Dict.991 : U64 = CallByName Num.51 Dict.992 Dict.514;
+            let Dict.1004 : U64 = CallByName Num.51 Dict.1005 Dict.514;
-            let Dict.986 : U64 = CallByName Dict.98 Dict.509 Dict.991;
+            let Dict.999 : U64 = CallByName Dict.98 Dict.509 Dict.1004;
-            let Dict.990 : U64 = 8i64;
+            let Dict.1003 : U64 = 8i64;
-            let Dict.989 : U64 = CallByName Num.75 Dict.513 Dict.990;
+            let Dict.1002 : U64 = CallByName Num.75 Dict.513 Dict.1003;
-            let Dict.988 : U64 = CallByName Num.51 Dict.989 Dict.514;
+            let Dict.1001 : U64 = CallByName Num.51 Dict.1002 Dict.514;
-            let Dict.987 : U64 = CallByName Dict.98 Dict.509 Dict.988;
+            let Dict.1000 : U64 = CallByName Dict.98 Dict.509 Dict.1001;
             dec Dict.509;
-            let Dict.985 : {U64, U64, U64} = Struct {Dict.986, Dict.987, Dict.512};
+            let Dict.998 : {U64, U64, U64} = Struct {Dict.999, Dict.1000, Dict.512};
-            ret Dict.985;
+            ret Dict.998;
         else
-            jump Dict.982 Dict.512 Dict.509 Dict.514 Dict.513;
+            jump Dict.995 Dict.512 Dict.509 Dict.514 Dict.513;
     in
     inc #Derived_gen.31;
-    jump Dict.982 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33;
+    jump Dict.995 #Derived_gen.30 #Derived_gen.31 #Derived_gen.32 #Derived_gen.33;
 
 procedure Dict.92 ():
-    let Dict.919 : U64 = 11562461410679940143i64;
+    let Dict.932 : U64 = 11562461410679940143i64;
-    ret Dict.919;
+    ret Dict.932;
 
 procedure Dict.93 ():
-    let Dict.915 : U64 = 16646288086500911323i64;
+    let Dict.928 : U64 = 16646288086500911323i64;
-    ret Dict.915;
+    ret Dict.928;
 
 procedure Dict.94 ():
-    let Dict.1028 : U64 = 10285213230658275043i64;
+    let Dict.1041 : U64 = 10285213230658275043i64;
-    ret Dict.1028;
+    ret Dict.1041;
 
 procedure Dict.95 ():
-    let Dict.1018 : U64 = 6384245875588680899i64;
+    let Dict.1031 : U64 = 6384245875588680899i64;
-    ret Dict.1018;
+    ret Dict.1031;
 
 procedure Dict.96 (Dict.515, Dict.516):
-    let Dict.907 : {U64, U64} = CallByName Dict.97 Dict.515 Dict.516;
+    let Dict.920 : {U64, U64} = CallByName Dict.97 Dict.515 Dict.516;
-    let Dict.517 : U64 = StructAtIndex 0 Dict.907;
+    let Dict.517 : U64 = StructAtIndex 0 Dict.920;
-    let Dict.518 : U64 = StructAtIndex 1 Dict.907;
+    let Dict.518 : U64 = StructAtIndex 1 Dict.920;
-    let Dict.906 : U64 = CallByName Num.70 Dict.517 Dict.518;
+    let Dict.919 : U64 = CallByName Num.70 Dict.517 Dict.518;
-    ret Dict.906;
+    ret Dict.919;
 
 procedure Dict.97 (Dict.519, Dict.520):
-    let Dict.911 : U128 = CallByName Num.135 Dict.519;
+    let Dict.924 : U128 = CallByName Num.135 Dict.519;
-    let Dict.912 : U128 = CallByName Num.135 Dict.520;
+    let Dict.925 : U128 = CallByName Num.135 Dict.520;
-    let Dict.521 : U128 = CallByName Num.78 Dict.911 Dict.912;
+    let Dict.521 : U128 = CallByName Num.78 Dict.924 Dict.925;
     let Dict.522 : U64 = CallByName Num.133 Dict.521;
-    let Dict.910 : U8 = 64i64;
+    let Dict.923 : U8 = 64i64;
-    let Dict.909 : U128 = CallByName Num.74 Dict.521 Dict.910;
+    let Dict.922 : U128 = CallByName Num.74 Dict.521 Dict.923;
-    let Dict.523 : U64 = CallByName Num.133 Dict.909;
+    let Dict.523 : U64 = CallByName Num.133 Dict.922;
-    let Dict.908 : {U64, U64} = Struct {Dict.522, Dict.523};
+    let Dict.921 : {U64, U64} = Struct {Dict.522, Dict.523};
-    ret Dict.908;
+    ret Dict.921;
 
 procedure Dict.98 (Dict.524, Dict.525):
-    let Dict.973 : U8 = CallByName Dict.22 Dict.524 Dict.525;
+    let Dict.986 : U8 = CallByName Dict.22 Dict.524 Dict.525;
-    let Dict.526 : U64 = CallByName Num.133 Dict.973;
+    let Dict.526 : U64 = CallByName Num.133 Dict.986;
-    let Dict.972 : U64 = 1i64;
+    let Dict.985 : U64 = 1i64;
-    let Dict.971 : U64 = CallByName Num.51 Dict.525 Dict.972;
+    let Dict.984 : U64 = CallByName Num.51 Dict.525 Dict.985;
-    let Dict.970 : U8 = CallByName Dict.22 Dict.524 Dict.971;
+    let Dict.983 : U8 = CallByName Dict.22 Dict.524 Dict.984;
-    let Dict.527 : U64 = CallByName Num.133 Dict.970;
+    let Dict.527 : U64 = CallByName Num.133 Dict.983;
-    let Dict.969 : U64 = 2i64;
+    let Dict.982 : U64 = 2i64;
-    let Dict.968 : U64 = CallByName Num.51 Dict.525 Dict.969;
+    let Dict.981 : U64 = CallByName Num.51 Dict.525 Dict.982;
-    let Dict.967 : U8 = CallByName Dict.22 Dict.524 Dict.968;
+    let Dict.980 : U8 = CallByName Dict.22 Dict.524 Dict.981;
-    let Dict.528 : U64 = CallByName Num.133 Dict.967;
+    let Dict.528 : U64 = CallByName Num.133 Dict.980;
-    let Dict.966 : U64 = 3i64;
+    let Dict.979 : U64 = 3i64;
-    let Dict.965 : U64 = CallByName Num.51 Dict.525 Dict.966;
+    let Dict.978 : U64 = CallByName Num.51 Dict.525 Dict.979;
+    let Dict.977 : U8 = CallByName Dict.22 Dict.524 Dict.978;
+    let Dict.529 : U64 = CallByName Num.133 Dict.977;
+    let Dict.976 : U64 = 4i64;
+    let Dict.975 : U64 = CallByName Num.51 Dict.525 Dict.976;
+    let Dict.974 : U8 = CallByName Dict.22 Dict.524 Dict.975;
+    let Dict.530 : U64 = CallByName Num.133 Dict.974;
+    let Dict.973 : U64 = 5i64;
+    let Dict.972 : U64 = CallByName Num.51 Dict.525 Dict.973;
+    let Dict.971 : U8 = CallByName Dict.22 Dict.524 Dict.972;
+    let Dict.531 : U64 = CallByName Num.133 Dict.971;
+    let Dict.970 : U64 = 6i64;
+    let Dict.969 : U64 = CallByName Num.51 Dict.525 Dict.970;
+    let Dict.968 : U8 = CallByName Dict.22 Dict.524 Dict.969;
+    let Dict.532 : U64 = CallByName Num.133 Dict.968;
+    let Dict.967 : U64 = 7i64;
+    let Dict.965 : U64 = CallByName Num.51 Dict.525 Dict.967;
     let Dict.964 : U8 = CallByName Dict.22 Dict.524 Dict.965;
-    let Dict.529 : U64 = CallByName Num.133 Dict.964;
+    let Dict.533 : U64 = CallByName Num.133 Dict.964;
-    let Dict.963 : U64 = 4i64;
+    let Dict.963 : U8 = 8i64;
-    let Dict.962 : U64 = CallByName Num.51 Dict.525 Dict.963;
+    let Dict.962 : U64 = CallByName Num.72 Dict.527 Dict.963;
-    let Dict.961 : U8 = CallByName Dict.22 Dict.524 Dict.962;
+    let Dict.534 : U64 = CallByName Num.71 Dict.526 Dict.962;
-    let Dict.530 : U64 = CallByName Num.133 Dict.961;
+    let Dict.961 : U8 = 16i64;
-    let Dict.960 : U64 = 5i64;
+    let Dict.958 : U64 = CallByName Num.72 Dict.528 Dict.961;
-    let Dict.959 : U64 = CallByName Num.51 Dict.525 Dict.960;
+    let Dict.960 : U8 = 24i64;
-    let Dict.958 : U8 = CallByName Dict.22 Dict.524 Dict.959;
+    let Dict.959 : U64 = CallByName Num.72 Dict.529 Dict.960;
-    let Dict.531 : U64 = CallByName Num.133 Dict.958;
+    let Dict.535 : U64 = CallByName Num.71 Dict.958 Dict.959;
-    let Dict.957 : U64 = 6i64;
+    let Dict.957 : U8 = 32i64;
-    let Dict.956 : U64 = CallByName Num.51 Dict.525 Dict.957;
+    let Dict.954 : U64 = CallByName Num.72 Dict.530 Dict.957;
-    let Dict.955 : U8 = CallByName Dict.22 Dict.524 Dict.956;
+    let Dict.956 : U8 = 40i64;
-    let Dict.532 : U64 = CallByName Num.133 Dict.955;
+    let Dict.955 : U64 = CallByName Num.72 Dict.531 Dict.956;
-    let Dict.954 : U64 = 7i64;
+    let Dict.536 : U64 = CallByName Num.71 Dict.954 Dict.955;
-    let Dict.952 : U64 = CallByName Num.51 Dict.525 Dict.954;
+    let Dict.953 : U8 = 48i64;
-    let Dict.951 : U8 = CallByName Dict.22 Dict.524 Dict.952;
+    let Dict.950 : U64 = CallByName Num.72 Dict.532 Dict.953;
-    let Dict.533 : U64 = CallByName Num.133 Dict.951;
+    let Dict.952 : U8 = 56i64;
-    let Dict.950 : U8 = 8i64;
+    let Dict.951 : U64 = CallByName Num.72 Dict.533 Dict.952;
-    let Dict.949 : U64 = CallByName Num.72 Dict.527 Dict.950;
+    let Dict.537 : U64 = CallByName Num.71 Dict.950 Dict.951;
-    let Dict.534 : U64 = CallByName Num.71 Dict.526 Dict.949;
+    let Dict.948 : U64 = CallByName Num.71 Dict.534 Dict.535;
-    let Dict.948 : U8 = 16i64;
+    let Dict.949 : U64 = CallByName Num.71 Dict.536 Dict.537;
-    let Dict.945 : U64 = CallByName Num.72 Dict.528 Dict.948;
+    let Dict.947 : U64 = CallByName Num.71 Dict.948 Dict.949;
-    let Dict.947 : U8 = 24i64;
+    ret Dict.947;
-    let Dict.946 : U64 = CallByName Num.72 Dict.529 Dict.947;
-    let Dict.535 : U64 = CallByName Num.71 Dict.945 Dict.946;
-    let Dict.944 : U8 = 32i64;
-    let Dict.941 : U64 = CallByName Num.72 Dict.530 Dict.944;
-    let Dict.943 : U8 = 40i64;
-    let Dict.942 : U64 = CallByName Num.72 Dict.531 Dict.943;
-    let Dict.536 : U64 = CallByName Num.71 Dict.941 Dict.942;
-    let Dict.940 : U8 = 48i64;
-    let Dict.937 : U64 = CallByName Num.72 Dict.532 Dict.940;
-    let Dict.939 : U8 = 56i64;
-    let Dict.938 : U64 = CallByName Num.72 Dict.533 Dict.939;
-    let Dict.537 : U64 = CallByName Num.71 Dict.937 Dict.938;
-    let Dict.935 : U64 = CallByName Num.71 Dict.534 Dict.535;
-    let Dict.936 : U64 = CallByName Num.71 Dict.536 Dict.537;
-    let Dict.934 : U64 = CallByName Num.71 Dict.935 Dict.936;
-    ret Dict.934;
 
 procedure Dict.99 (Dict.538, Dict.539):
-    let Dict.1085 : U8 = CallByName Dict.22 Dict.538 Dict.539;
+    let Dict.1098 : U8 = CallByName Dict.22 Dict.538 Dict.539;
-    let Dict.540 : U64 = CallByName Num.133 Dict.1085;
+    let Dict.540 : U64 = CallByName Num.133 Dict.1098;
-    let Dict.1084 : U64 = 1i64;
+    let Dict.1097 : U64 = 1i64;
-    let Dict.1083 : U64 = CallByName Num.51 Dict.539 Dict.1084;
+    let Dict.1096 : U64 = CallByName Num.51 Dict.539 Dict.1097;
-    let Dict.1082 : U8 = CallByName Dict.22 Dict.538 Dict.1083;
+    let Dict.1095 : U8 = CallByName Dict.22 Dict.538 Dict.1096;
-    let Dict.541 : U64 = CallByName Num.133 Dict.1082;
+    let Dict.541 : U64 = CallByName Num.133 Dict.1095;
-    let Dict.1081 : U64 = 2i64;
+    let Dict.1094 : U64 = 2i64;
-    let Dict.1080 : U64 = CallByName Num.51 Dict.539 Dict.1081;
+    let Dict.1093 : U64 = CallByName Num.51 Dict.539 Dict.1094;
-    let Dict.1079 : U8 = CallByName Dict.22 Dict.538 Dict.1080;
+    let Dict.1092 : U8 = CallByName Dict.22 Dict.538 Dict.1093;
-    let Dict.542 : U64 = CallByName Num.133 Dict.1079;
+    let Dict.542 : U64 = CallByName Num.133 Dict.1092;
-    let Dict.1078 : U64 = 3i64;
+    let Dict.1091 : U64 = 3i64;
-    let Dict.1077 : U64 = CallByName Num.51 Dict.539 Dict.1078;
+    let Dict.1090 : U64 = CallByName Num.51 Dict.539 Dict.1091;
-    let Dict.1076 : U8 = CallByName Dict.22 Dict.538 Dict.1077;
+    let Dict.1089 : U8 = CallByName Dict.22 Dict.538 Dict.1090;
-    let Dict.543 : U64 = CallByName Num.133 Dict.1076;
+    let Dict.543 : U64 = CallByName Num.133 Dict.1089;
-    let Dict.1075 : U8 = 8i64;
+    let Dict.1088 : U8 = 8i64;
-    let Dict.1074 : U64 = CallByName Num.72 Dict.541 Dict.1075;
+    let Dict.1087 : U64 = CallByName Num.72 Dict.541 Dict.1088;
-    let Dict.544 : U64 = CallByName Num.71 Dict.540 Dict.1074;
+    let Dict.544 : U64 = CallByName Num.71 Dict.540 Dict.1087;
-    let Dict.1073 : U8 = 16i64;
+    let Dict.1086 : U8 = 16i64;
-    let Dict.1070 : U64 = CallByName Num.72 Dict.542 Dict.1073;
+    let Dict.1083 : U64 = CallByName Num.72 Dict.542 Dict.1086;
-    let Dict.1072 : U8 = 24i64;
+    let Dict.1085 : U8 = 24i64;
-    let Dict.1071 : U64 = CallByName Num.72 Dict.543 Dict.1072;
+    let Dict.1084 : U64 = CallByName Num.72 Dict.543 Dict.1085;
-    let Dict.545 : U64 = CallByName Num.71 Dict.1070 Dict.1071;
+    let Dict.545 : U64 = CallByName Num.71 Dict.1083 Dict.1084;
-    let Dict.1069 : U64 = CallByName Num.71 Dict.544 Dict.545;
+    let Dict.1082 : U64 = CallByName Num.71 Dict.544 Dict.545;
-    ret Dict.1069;
+    ret Dict.1082;
 
 procedure Hash.19 (Hash.42, Hash.43):
     let Hash.75 : List U8 = CallByName Str.12 Hash.43;
@@ -916,21 +916,21 @@ procedure List.101 (#Derived_gen.37, #Derived_gen.38, #Derived_gen.39, #Derived_
     jump List.678 #Derived_gen.37 #Derived_gen.38 #Derived_gen.39 #Derived_gen.40 #Derived_gen.41;
 
 procedure List.101 (#Derived_gen.42, #Derived_gen.43, #Derived_gen.44, #Derived_gen.45, #Derived_gen.46):
-    joinpoint List.742 List.175 List.176 List.177 List.178 List.179:
+    joinpoint List.741 List.175 List.176 List.177 List.178 List.179:
-        let List.744 : Int1 = CallByName Num.22 List.178 List.179;
+        let List.743 : Int1 = CallByName Num.22 List.178 List.179;
-        if List.744 then
+        if List.743 then
-            let List.748 : {Str, I64} = CallByName List.66 List.175 List.178;
+            let List.747 : {Str, I64} = CallByName List.66 List.175 List.178;
-            inc List.748;
+            inc List.747;
-            let List.180 : {Str, Int1} = CallByName Dict.188 List.176 List.748 List.177;
+            let List.180 : {Str, Int1} = CallByName Dict.188 List.176 List.747 List.177;
-            let List.747 : U64 = 1i64;
+            let List.746 : U64 = 1i64;
-            let List.746 : U64 = CallByName Num.51 List.178 List.747;
+            let List.745 : U64 = CallByName Num.51 List.178 List.746;
-            jump List.742 List.175 List.180 List.177 List.746 List.179;
+            jump List.741 List.175 List.180 List.177 List.745 List.179;
         else
             dec List.175;
             ret List.176;
     in
     inc #Derived_gen.42;
-    jump List.742 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46;
+    jump List.741 #Derived_gen.42 #Derived_gen.43 #Derived_gen.44 #Derived_gen.45 #Derived_gen.46;
 
 procedure List.102 (#Derived_gen.47, #Derived_gen.48, #Derived_gen.49, #Derived_gen.50, #Derived_gen.51):
     joinpoint List.717 List.184 List.185 List.186 List.187 List.188:
@@ -961,10 +961,10 @@ procedure List.18 (List.172, List.173, List.174):
     ret List.675;
 
 procedure List.18 (List.172, List.173, List.174):
-    let List.740 : U64 = 0i64;
+    let List.739 : U64 = 0i64;
-    let List.741 : U64 = CallByName List.6 List.172;
+    let List.740 : U64 = CallByName List.6 List.172;
-    let List.739 : {Str, Int1} = CallByName List.101 List.172 List.173 List.174 List.740 List.741;
+    let List.738 : {Str, Int1} = CallByName List.101 List.172 List.173 List.174 List.739 List.740;
-    ret List.739;
+    ret List.738;
 
 procedure List.3 (List.128, List.129, List.130):
     let List.701 : {List {U32, U32}, {U32, U32}} = CallByName List.64 List.128 List.129 List.130;
@@ -989,8 +989,8 @@ procedure List.6 (#Attr.2):
     ret List.691;
 
 procedure List.6 (#Attr.2):
-    let List.738 : U64 = lowlevel ListLenU64 #Attr.2;
+    let List.749 : U64 = lowlevel ListLenU64 #Attr.2;
-    ret List.738;
+    ret List.749;
 
 procedure List.6 (#Attr.2):
     let List.750 : U64 = lowlevel ListLenU64 #Attr.2;
@@ -1017,8 +1017,8 @@ procedure List.64 (List.125, List.126, List.127):
         ret List.704;
 
 procedure List.66 (#Attr.2, #Attr.3):
-    let List.749 : {Str, I64} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
+    let List.748 : {Str, I64} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
-    ret List.749;
+    ret List.748;
 
 procedure List.67 (#Attr.2, #Attr.3, #Attr.4):
     let List.698 : {List {U32, U32}, {U32, U32}} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;

crates/compiler/test_mono/generated/inspect_derived_string.txt

@@ -167,7 +167,7 @@ procedure Str.45 (Str.91, Str.92, Str.93):
         dec Str.342;
         ret Str.91;
 
-procedure Str.56 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3):
+procedure Str.56 (Bool.24, Bool.25, Bool.26, Bool.27):
     joinpoint Str.250 Str.96 Str.97 Str.98 Str.99:
         inc Str.97;
         let Str.251 : [C {}, C {Str, Str}] = CallByName Str.38 Str.97 Str.98;
@@ -191,9 +191,9 @@ procedure Str.56 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3
             dec Str.97;
             ret Str.255;
     in
-    inc #Derived_gen.3;
+    inc Bool.26;
-    inc #Derived_gen.2;
+    inc Bool.27;
-    jump Str.250 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3;
+    jump Str.250 Bool.24 Bool.25 Bool.26 Bool.27;
 
 procedure Str.57 (Str.121, Str.122):
     let Str.123 : U64 = CallByName Str.36 Str.121;
@@ -203,7 +203,7 @@ procedure Str.57 (Str.121, Str.122):
     let Str.276 : [C , C U64] = CallByName Str.58 Str.121 Str.122 Str.277 Str.125;
     ret Str.276;
 
-procedure Str.58 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7):
+procedure Str.58 (Bool.28, Bool.29, Bool.30, Bool.31):
     joinpoint Str.278 Str.126 Str.127 Str.128 Str.129:
         let Str.280 : Int1 = CallByName Num.23 Str.128 Str.129;
         if Str.280 then
@@ -223,9 +223,9 @@ procedure Str.58 (#Derived_gen.4, #Derived_gen.5, #Derived_gen.6, #Derived_gen.7
             let Str.279 : [C , C U64] = TagId(0) ;
             ret Str.279;
     in
-    inc #Derived_gen.5;
+    inc Bool.29;
-    inc #Derived_gen.4;
+    inc Bool.28;
-    jump Str.278 #Derived_gen.4 #Derived_gen.5 #Derived_gen.6 #Derived_gen.7;
+    jump Str.278 Bool.28 Bool.29 Bool.30 Bool.31;
 
 procedure Str.61 (Str.152, Str.153):
     let Str.309 : Int1 = CallByName Num.22 Str.152 Str.153;

crates/compiler/test_mono/generated/issue_3669.txt

@@ -2,7 +2,7 @@ procedure Bool.9 (#Attr.2, #Attr.3):
     let Bool.21 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
     ret Bool.21;
 
-procedure Test.2 (#Derived_gen.0):
+procedure Test.2 (Bool.22):
     joinpoint Test.13 Test.7:
         let Test.16 : U8 = 1i64;
         let Test.17 : U8 = GetTagId Test.7;
@@ -13,8 +13,8 @@ procedure Test.2 (#Derived_gen.0):
             ret Test.14;
         else
             let Test.5 : [<rnu><null>, C *self] = UnionAtIndex (Id 0) (Index 0) Test.7;
-            let #Derived_gen.1 : Int1 = lowlevel RefCountIsUnique Test.7;
+            let Bool.23 : Int1 = lowlevel RefCountIsUnique Test.7;
-            if #Derived_gen.1 then
+            if Bool.23 then
                 free Test.7;
                 jump Test.13 Test.5;
             else
@@ -22,7 +22,7 @@ procedure Test.2 (#Derived_gen.0):
                 decref Test.7;
                 jump Test.13 Test.5;
     in
-    jump Test.13 #Derived_gen.0;
+    jump Test.13 Bool.22;
 
 procedure Test.0 ():
     let Test.12 : [<rnu><null>, C *self] = TagId(1) ;

crates/compiler/test_mono/generated/issue_4770.txt

@@ -6,7 +6,7 @@ procedure Bool.2 ():
     let Bool.22 : Int1 = true;
     ret Bool.22;
 
-procedure List.106 (#Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen.9, #Derived_gen.10, #Derived_gen.11):
+procedure List.106 (Bool.30, Bool.31, Bool.32, Bool.33, Bool.34, Bool.35):
     joinpoint List.713 List.291 List.292 List.293 List.294 List.295 List.296:
         let List.715 : Int1 = CallByName Num.22 List.295 List.296;
         if List.715 then
@@ -24,9 +24,9 @@ procedure List.106 (#Derived_gen.6, #Derived_gen.7, #Derived_gen.8, #Derived_gen
             dec List.292;
             ret List.293;
     in
-    inc #Derived_gen.6;
+    inc Bool.30;
-    inc #Derived_gen.7;
+    inc Bool.31;
-    jump List.713 #Derived_gen.6 #Derived_gen.7 #Derived_gen.8 #Derived_gen.9 #Derived_gen.10 #Derived_gen.11;
+    jump List.713 Bool.30 Bool.31 Bool.32 Bool.33 Bool.34 Bool.35;
 
 procedure List.116 (List.563, List.564, List.565):
     let List.689 : U64 = 0i64;
@@ -91,7 +91,7 @@ procedure List.71 (#Attr.2, #Attr.3):
     let List.720 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListAppendUnsafe #Attr.2 #Attr.3;
     ret List.720;
 
-procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
+procedure List.80 (Bool.25, Bool.26, Bool.27, Bool.28, Bool.29):
     joinpoint List.691 List.566 List.567 List.568 List.569 List.570:
         let List.693 : Int1 = CallByName Num.22 List.569 List.570;
         if List.693 then
@@ -116,8 +116,8 @@ procedure List.80 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.
             let List.692 : [C {}, C {}] = TagId(1) List.567;
             ret List.692;
     in
-    inc #Derived_gen.1;
+    inc Bool.25;
-    jump List.691 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
+    jump List.691 Bool.25 Bool.26 Bool.27 Bool.28 Bool.29;
 
 procedure Num.148 (Num.226, Num.227):
     let Num.290 : Int1 = CallByName Num.22 Num.226 Num.227;
@@ -138,7 +138,7 @@ procedure Num.51 (#Attr.2, #Attr.3):
     let Num.286 : U64 = lowlevel NumAddWrap #Attr.2 #Attr.3;
     ret Num.286;
 
-procedure Test.1 (#Derived_gen.0):
+procedure Test.1 (Bool.24):
     joinpoint Test.26 Test.6:
         let Test.65 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
         let Test.66 : U8 = 0i64;
@@ -155,17 +155,17 @@ procedure Test.1 (#Derived_gen.0):
                 let Test.49 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
                 dec Test.50;
                 let Test.10 : I64 = UnionAtIndex (Id 0) (Index 0) Test.49;
-                joinpoint #Derived_gen.12:
+                joinpoint Bool.36:
                     let Test.27 : Int1 = CallByName Num.22 Test.8 Test.10;
                     ret Test.27;
                 in
-                let #Derived_gen.13 : Int1 = lowlevel RefCountIsUnique Test.49;
+                let Bool.37 : Int1 = lowlevel RefCountIsUnique Test.49;
-                if #Derived_gen.13 then
+                if Bool.37 then
                     free Test.49;
-                    jump #Derived_gen.12;
+                    jump Bool.36;
                 else
                     decref Test.49;
-                    jump #Derived_gen.12;
+                    jump Bool.36;
             else
                 let Test.39 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
                 let Test.42 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
@@ -185,7 +185,7 @@ procedure Test.1 (#Derived_gen.0):
                 let Test.51 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
                 dec Test.52;
                 let Test.14 : List [<r>C I64, C List *self] = UnionAtIndex (Id 1) (Index 0) Test.51;
-                joinpoint #Derived_gen.14:
+                joinpoint Bool.38:
                     let Test.35 : {} = Struct {};
                     let Test.33 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.23 Test.12 Test.14 Test.35;
                     let Test.34 : {} = Struct {};
@@ -204,14 +204,14 @@ procedure Test.1 (#Derived_gen.0):
                         let Test.28 : Int1 = CallByName Bool.1;
                         ret Test.28;
                 in
-                let #Derived_gen.15 : Int1 = lowlevel RefCountIsUnique Test.51;
+                let Bool.39 : Int1 = lowlevel RefCountIsUnique Test.51;
-                if #Derived_gen.15 then
+                if Bool.39 then
                     free Test.51;
-                    jump #Derived_gen.14;
+                    jump Bool.38;
                 else
                     inc Test.14;
                     decref Test.51;
-                    jump #Derived_gen.14;
+                    jump Bool.38;
             else
                 let Test.48 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
                 let Test.47 : List [<r>C I64, C List *self] = Array [Test.48];
@@ -220,7 +220,7 @@ procedure Test.1 (#Derived_gen.0):
                 let Test.44 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.45, Test.46};
                 jump Test.26 Test.44;
     in
-    jump Test.26 #Derived_gen.0;
+    jump Test.26 Bool.24;
 
 procedure Test.15 (Test.16, Test.17):
     let Test.36 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.16, Test.17};

crates/compiler/test_mono/generated/issue_6196.txt

@@ -2,7 +2,7 @@ procedure Num.20 (#Attr.2, #Attr.3):
     let Num.283 : U64 = lowlevel NumSub #Attr.2 #Attr.3;
     ret Num.283;
 
-procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
+procedure Test.1 (Bool.21, Bool.22):
     joinpoint Test.12 Test.2 Test.3:
         let Test.13 : {List Str, U64} = Struct {Test.2, Test.3};
         let Test.31 : List Str = StructAtIndex 0 Test.13;
@@ -37,8 +37,8 @@ procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
             let Test.14 : [C {}, C Str] = TagId(0) Test.15;
             ret Test.14;
     in
-    inc #Derived_gen.0;
+    inc Bool.21;
-    jump Test.12 #Derived_gen.0 #Derived_gen.1;
+    jump Test.12 Bool.21 Bool.22;
 
 procedure Test.0 ():
     let Test.35 : Str = "a";

crates/compiler/test_mono/generated/layout_cache_structure_with_multiple_recursive_structures.txt

@@ -1,4 +1,4 @@
-procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.101 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
     joinpoint List.678 List.175 List.176 List.177 List.178 List.179:
         let List.680 : Int1 = CallByName Num.22 List.178 List.179;
         if List.680 then
@@ -12,8 +12,8 @@ procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.0;
+    inc Bool.21;
-    jump List.678 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.678 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.676 : U64 = 0i64;

crates/compiler/test_mono/generated/linked_list_filter.txt

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

crates/compiler/test_mono/generated/linked_list_map.txt

@@ -7,39 +7,39 @@ procedure Test.10 (Test.11):
     let Test.27 : I64 = CallByName Num.19 Test.11 Test.28;
     ret Test.27;
 
-procedure Test.2 (#Derived_gen.0, #Derived_gen.1):
+procedure Test.2 (Bool.21, Bool.22):
-    let #Derived_gen.3 : [<rnu><null>, C I64 *self] = NullPointer;
+    let Bool.24 : [<rnu><null>, C I64 *self] = NullPointer;
-    let #Derived_gen.2 : Ptr([<rnu><null>, C I64 *self]) = Alloca #Derived_gen.3;
+    let Bool.23 : Ptr([<rnu><null>, C I64 *self]) = Alloca Bool.24;
-    joinpoint #Derived_gen.4 Test.4 Test.5 #Derived_gen.5 #Derived_gen.6:
+    joinpoint Bool.25 Test.4 Test.5 Bool.26 Bool.27:
         let Test.22 : U8 = 1i64;
         let Test.23 : U8 = GetTagId Test.5;
         let Test.24 : Int1 = lowlevel Eq Test.22 Test.23;
         if Test.24 then
             let Test.18 : [<rnu><null>, C I64 *self] = TagId(1) ;
-            let #Derived_gen.8 : {} = lowlevel PtrStore #Derived_gen.5 Test.18;
+            let Bool.29 : {} = lowlevel PtrStore Bool.26 Test.18;
-            let #Derived_gen.7 : [<rnu><null>, C I64 *self] = lowlevel PtrLoad #Derived_gen.6;
+            let Bool.28 : [<rnu><null>, C I64 *self] = lowlevel PtrLoad Bool.27;
-            ret #Derived_gen.7;
+            ret Bool.28;
         else
             let Test.7 : I64 = UnionAtIndex (Id 0) (Index 0) Test.5;
             let Test.8 : [<rnu><null>, C I64 *self] = UnionAtIndex (Id 0) (Index 1) Test.5;
-            joinpoint #Derived_gen.12 #Derived_gen.14:
+            joinpoint Bool.33 Bool.35:
                 let Test.20 : I64 = CallByName Test.10 Test.7;
-                let #Derived_gen.9 : [<rnu><null>, C I64 *self] = NullPointer;
+                let Bool.30 : [<rnu><null>, C I64 *self] = NullPointer;
-                let Test.19 : [<rnu><null>, C I64 *self] = Reuse #Derived_gen.14 UpdateModeId { id: 1 } TagId(0) Test.20 #Derived_gen.9;
+                let Test.19 : [<rnu><null>, C I64 *self] = Reuse Bool.35 UpdateModeId { id: 1 } TagId(0) Test.20 Bool.30;
-                let #Derived_gen.10 : Ptr([<rnu><null>, C I64 *self]) = GetElementPointer (Indices [0, 1]) Test.19;
+                let Bool.31 : Ptr([<rnu><null>, C I64 *self]) = GetElementPointer (Indices [0, 1]) Test.19;
-                let #Derived_gen.11 : {} = lowlevel PtrStore #Derived_gen.5 Test.19;
+                let Bool.32 : {} = lowlevel PtrStore Bool.26 Test.19;
-                jump #Derived_gen.4 Test.4 Test.8 #Derived_gen.10 #Derived_gen.6;
+                jump Bool.25 Test.4 Test.8 Bool.31 Bool.27;
             in
-            let #Derived_gen.13 : Int1 = lowlevel RefCountIsUnique Test.5;
+            let Bool.34 : Int1 = lowlevel RefCountIsUnique Test.5;
-            if #Derived_gen.13 then
+            if Bool.34 then
-                jump #Derived_gen.12 Test.5;
+                jump Bool.33 Test.5;
             else
                 inc Test.8;
                 decref Test.5;
-                let #Derived_gen.15 : [<rnu><null>, C I64 *self] = NullPointer;
+                let Bool.36 : [<rnu><null>, C I64 *self] = NullPointer;
-                jump #Derived_gen.12 #Derived_gen.15;
+                jump Bool.33 Bool.36;
     in
-    jump #Derived_gen.4 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.2;
+    jump Bool.25 Bool.21 Bool.22 Bool.23 Bool.23;
 
 procedure Test.0 ():
     let Test.15 : {} = Struct {};

crates/compiler/test_mono/generated/linked_list_reverse.txt

@@ -3,7 +3,7 @@ procedure Test.2 (Test.5):
     let Test.16 : [<rnu><null>, C I64 *self] = CallByName Test.3 Test.17 Test.5;
     ret Test.16;
 
-procedure Test.3 (#Derived_gen.0, #Derived_gen.1):
+procedure Test.3 (Bool.21, Bool.22):
     joinpoint Test.18 Test.7 Test.8:
         let Test.22 : U8 = 1i64;
         let Test.23 : U8 = GetTagId Test.8;
@@ -13,20 +13,20 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1):
         else
             let Test.9 : I64 = UnionAtIndex (Id 0) (Index 0) Test.8;
             let Test.10 : [<rnu><null>, C I64 *self] = UnionAtIndex (Id 0) (Index 1) Test.8;
-            joinpoint #Derived_gen.2 #Derived_gen.4:
+            joinpoint Bool.23 Bool.25:
-                let Test.21 : [<rnu><null>, C I64 *self] = Reuse #Derived_gen.4 UpdateModeId { id: 1 } TagId(0) Test.9 Test.7;
+                let Test.21 : [<rnu><null>, C I64 *self] = Reuse Bool.25 UpdateModeId { id: 1 } TagId(0) Test.9 Test.7;
                 jump Test.18 Test.21 Test.10;
             in
-            let #Derived_gen.3 : Int1 = lowlevel RefCountIsUnique Test.8;
+            let Bool.24 : Int1 = lowlevel RefCountIsUnique Test.8;
-            if #Derived_gen.3 then
+            if Bool.24 then
-                jump #Derived_gen.2 Test.8;
+                jump Bool.23 Test.8;
             else
                 inc Test.10;
                 decref Test.8;
-                let #Derived_gen.5 : [<rnu><null>, C I64 *self] = NullPointer;
+                let Bool.26 : [<rnu><null>, C I64 *self] = NullPointer;
-                jump #Derived_gen.2 #Derived_gen.5;
+                jump Bool.23 Bool.26;
     in
-    jump Test.18 #Derived_gen.0 #Derived_gen.1;
+    jump Test.18 Bool.21 Bool.22;
 
 procedure Test.0 ():
     let Test.25 : I64 = 42i64;

crates/compiler/test_mono/generated/list_map_closure_borrows.txt

@@ -1,4 +1,4 @@
-procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.101 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
     joinpoint List.689 List.175 List.176 List.177 List.178 List.179:
         let List.691 : Int1 = CallByName Num.22 List.178 List.179;
         if List.691 then
@@ -13,8 +13,8 @@ procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.0;
+    inc Bool.21;
-    jump List.689 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.689 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.687 : U64 = 0i64;

crates/compiler/test_mono/generated/list_map_closure_owns.txt

@@ -1,4 +1,4 @@
-procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.101 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
     joinpoint List.689 List.175 List.176 List.177 List.178 List.179:
         let List.691 : Int1 = CallByName Num.22 List.178 List.179;
         if List.691 then
@@ -12,8 +12,8 @@ procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.0;
+    inc Bool.21;
-    jump List.689 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.689 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.687 : U64 = 0i64;

crates/compiler/test_mono/generated/list_map_take_capturing_or_noncapturing.txt

@@ -1,4 +1,4 @@
-procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.101 (Bool.21, Bool.22, Bool.23, Bool.24, Bool.25):
     joinpoint List.681 List.175 List.176 List.177 List.178 List.179:
         let List.683 : Int1 = CallByName Num.22 List.178 List.179;
         if List.683 then
@@ -11,8 +11,8 @@ procedure List.101 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.0;
+    inc Bool.21;
-    jump List.681 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.681 Bool.21 Bool.22 Bool.23 Bool.24 Bool.25;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.679 : U64 = 0i64;

crates/compiler/test_mono/generated/pattern_as_toplevel.txt

@@ -21,11 +21,11 @@ procedure Test.0 ():
         let Test.6 : {I64, Str} = CallByName Test.1;
         let Test.5 : Int1 = CallByName Bool.9 Test.6 Test.4;
         dec Test.6;
-        let #Derived_gen.0 : Str = StructAtIndex 1 Test.4;
+        let Bool.23 : Str = StructAtIndex 1 Test.4;
-        dec #Derived_gen.0;
+        dec Bool.23;
         ret Test.5;
     else
-        let #Derived_gen.1 : Str = StructAtIndex 1 Test.4;
+        let Bool.24 : Str = StructAtIndex 1 Test.4;
-        dec #Derived_gen.1;
+        dec Bool.24;
         let Test.10 : Int1 = CallByName Bool.1;
         ret Test.10;

crates/compiler/test_mono/generated/peano1.txt

@@ -5,7 +5,7 @@ procedure Test.0 ():
     let Test.2 : [<rnu><null>, C *self] = TagId(0) Test.13;
     let Test.10 : U8 = 1i64;
     let Test.11 : U8 = GetTagId Test.2;
-    joinpoint #Derived_gen.0:
+    joinpoint Bool.21:
         let Test.12 : Int1 = lowlevel Eq Test.10 Test.11;
         if Test.12 then
             let Test.8 : I64 = 0i64;
@@ -14,11 +14,11 @@ procedure Test.0 ():
             let Test.9 : I64 = 1i64;
             ret Test.9;
     in
-    let #Derived_gen.1 : Int1 = lowlevel RefCountIsUnique Test.2;
+    let Bool.22 : Int1 = lowlevel RefCountIsUnique Test.2;
-    if #Derived_gen.1 then
+    if Bool.22 then
         dec Test.13;
         free Test.2;
-        jump #Derived_gen.0;
+        jump Bool.21;
     else
         decref Test.2;
-        jump #Derived_gen.0;
+        jump Bool.21;

crates/compiler/test_mono/generated/peano2.txt

@@ -8,7 +8,7 @@ procedure Test.0 ():
     let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
     if Test.18 then
         let Test.12 : [<rnu><null>, C *self] = UnionAtIndex (Id 0) (Index 0) Test.2;
-        joinpoint #Derived_gen.0:
+        joinpoint Bool.21:
             let Test.13 : U8 = 0i64;
             let Test.14 : U8 = GetTagId Test.12;
             dec Test.12;
@@ -20,14 +20,14 @@ procedure Test.0 ():
                 let Test.9 : I64 = 0i64;
                 ret Test.9;
         in
-        let #Derived_gen.1 : Int1 = lowlevel RefCountIsUnique Test.2;
+        let Bool.22 : Int1 = lowlevel RefCountIsUnique Test.2;
-        if #Derived_gen.1 then
+        if Bool.22 then
             free Test.2;
-            jump #Derived_gen.0;
+            jump Bool.21;
         else
             inc Test.12;
             decref Test.2;
-            jump #Derived_gen.0;
+            jump Bool.21;
     else
         let Test.10 : I64 = 0i64;
         ret Test.10;

crates/compiler/test_mono/generated/pizza_dbg.txt

@@ -47,13 +47,13 @@ procedure Str.3 (#Attr.2, #Attr.3):
     ret Str.246;
 
 procedure Test.0 ():
-    let Test.4 : I64 = 1i64;
+    let Test.2 : I64 = 1i64;
-    let Test.5 : Str = CallByName Inspect.33 Test.4;
+    let Test.3 : Str = CallByName Inspect.33 Test.2;
-    dbg Test.5;
+    dbg Test.3;
-    dec Test.5;
+    dec Test.3;
-    let Test.9 : I64 = 2i64;
+    let Test.7 : I64 = 2i64;
-    let Test.3 : I64 = CallByName Num.19 Test.4 Test.9;
+    let Test.1 : I64 = CallByName Num.19 Test.2 Test.7;
-    let Test.6 : Str = CallByName Inspect.33 Test.3;
+    let Test.4 : Str = CallByName Inspect.33 Test.1;
-    dbg Test.6;
+    dbg Test.4;
-    dec Test.6;
+    dec Test.4;
-    ret Test.3;
+    ret Test.1;

crates/compiler/test_mono/generated/polymorphic_expression_unification.txt

@@ -30,15 +30,15 @@ procedure Test.0 ():
     let Test.16 : Str = "";
     let Test.15 : [<r>C List *self, C Str] = TagId(1) Test.16;
     let Test.13 : Int1 = CallByName Bool.9 Test.14 Test.15;
-    joinpoint #Derived_gen.0:
+    joinpoint Bool.22:
         dec Test.14;
         ret Test.13;
     in
-    let #Derived_gen.1 : Int1 = lowlevel RefCountIsUnique Test.15;
+    let Bool.23 : Int1 = lowlevel RefCountIsUnique Test.15;
-    if #Derived_gen.1 then
+    if Bool.23 then
         dec Test.16;
         free Test.15;
-        jump #Derived_gen.0;
+        jump Bool.22;
     else
         decref Test.15;
-        jump #Derived_gen.0;
+        jump Bool.22;

crates/compiler/test_mono/generated/quicksort_help.txt

@@ -10,7 +10,7 @@ procedure Num.22 (#Attr.2, #Attr.3):
     let Num.285 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
     ret Num.285;
 
-procedure Test.1 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
+procedure Test.1 (Bool.21, Bool.22, Bool.23):
     joinpoint Test.12 Test.2 Test.3 Test.4:
         let Test.14 : Int1 = CallByName Num.22 Test.3 Test.4;
         if Test.14 then
@@ -29,7 +29,7 @@ procedure Test.1 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
         else
             ret Test.2;
     in
-    jump Test.12 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2;
+    jump Test.12 Bool.21 Bool.22 Bool.23;
 
 procedure Test.0 ():
     let Test.9 : List I64 = Array [];

crates/compiler/test_mono/generated/rb_tree_fbip.txt

@@ -6,10 +6,10 @@ procedure Num.24 (#Attr.2, #Attr.3):
     let Num.284 : Int1 = lowlevel NumGt #Attr.2 #Attr.3;
     ret Num.284;
 
-procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
+procedure Test.3 (Bool.21, Bool.22, Bool.23):
-    let #Derived_gen.4 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+    let Bool.25 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-    let #Derived_gen.3 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = Alloca #Derived_gen.4;
+    let Bool.24 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = Alloca Bool.25;
-    joinpoint #Derived_gen.5 Test.9 Test.10 Test.11 #Derived_gen.6 #Derived_gen.7:
+    joinpoint Bool.26 Test.9 Test.10 Test.11 Bool.27 Bool.28:
         let Test.254 : U8 = 0i64;
         let Test.255 : U8 = GetTagId Test.9;
         let Test.256 : Int1 = lowlevel Eq Test.254 Test.255;
@@ -18,9 +18,9 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
             let Test.114 : [<rnu>C *self I64 *self I32 Int1, <null>] = TagId(0) ;
             let Test.112 : Int1 = true;
             let Test.111 : [<rnu>C *self I64 *self I32 Int1, <null>] = TagId(1) Test.113 Test.11 Test.114 Test.10 Test.112;
-            let #Derived_gen.9 : {} = lowlevel PtrStore #Derived_gen.6 Test.111;
+            let Bool.30 : {} = lowlevel PtrStore Bool.27 Test.111;
-            let #Derived_gen.8 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+            let Bool.29 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-            ret #Derived_gen.8;
+            ret Bool.29;
         else
             let Test.251 : Int1 = UnionAtIndex (Id 1) (Index 4) Test.9;
             let Test.252 : Int1 = false;
@@ -30,16 +30,16 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                 let Test.18 : I64 = UnionAtIndex (Id 1) (Index 1) Test.9;
                 let Test.19 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.9;
                 let Test.17 : I32 = UnionAtIndex (Id 1) (Index 3) Test.9;
-                joinpoint #Derived_gen.114 #Derived_gen.118:
+                joinpoint Bool.135 Bool.139:
                     let Test.179 : Int1 = CallByName Num.22 Test.10 Test.17;
                     if Test.179 then
-                        joinpoint Test.238 #Derived_gen.166:
+                        joinpoint Test.238 Bool.187:
                             let Test.232 : Int1 = false;
-                            let #Derived_gen.10 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                            let Bool.31 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                            let Test.231 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.166 UpdateModeId { id: 56 } TagId(1) #Derived_gen.10 Test.18 Test.19 Test.17 Test.232;
+                            let Test.231 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.187 UpdateModeId { id: 56 } TagId(1) Bool.31 Test.18 Test.19 Test.17 Test.232;
-                            let #Derived_gen.11 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = GetElementPointer (Indices [1, 0]) Test.231;
+                            let Bool.32 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = GetElementPointer (Indices [1, 0]) Test.231;
-                            let #Derived_gen.12 : {} = lowlevel PtrStore #Derived_gen.6 Test.231;
+                            let Bool.33 : {} = lowlevel PtrStore Bool.27 Test.231;
-                            jump #Derived_gen.5 Test.16 Test.10 Test.11 #Derived_gen.11 #Derived_gen.7;
+                            jump Bool.26 Test.16 Test.10 Test.11 Bool.32 Bool.28;
                         in
                         let Test.236 : U8 = 1i64;
                         let Test.237 : U8 = GetTagId Test.16;
@@ -50,7 +50,7 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                             let Test.239 : Int1 = lowlevel Eq Test.235 Test.234;
                             if Test.239 then
                                 let Test.180 : [<rnu>C *self I64 *self I32 Int1, <null>] = CallByName Test.3 Test.16 Test.10 Test.11;
-                                joinpoint Test.199 #Derived_gen.187:
+                                joinpoint Test.199 Bool.208:
                                     let Test.198 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.180;
                                     let Test.20 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.198;
                                     inc Test.20;
@@ -61,55 +61,55 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                     let Test.25 : I64 = UnionAtIndex (Id 1) (Index 1) Test.180;
                                     let Test.26 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.180;
                                     let Test.24 : I32 = UnionAtIndex (Id 1) (Index 3) Test.180;
-                                    joinpoint #Derived_gen.72 #Derived_gen.189 #Derived_gen.190 #Derived_gen.191:
+                                    joinpoint Bool.93 Bool.210 Bool.211 Bool.212:
                                         let Test.186 : Int1 = false;
-                                        let Test.183 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.191 UpdateModeId { id: 85 } TagId(1) Test.20 Test.22 Test.23 Test.21 Test.186;
+                                        let Test.183 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.212 UpdateModeId { id: 85 } TagId(1) Test.20 Test.22 Test.23 Test.21 Test.186;
                                         let Test.185 : Int1 = false;
-                                        let Test.184 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.190 UpdateModeId { id: 84 } TagId(1) Test.26 Test.18 Test.19 Test.17 Test.185;
+                                        let Test.184 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.211 UpdateModeId { id: 84 } TagId(1) Test.26 Test.18 Test.19 Test.17 Test.185;
                                         let Test.182 : Int1 = true;
-                                        let Test.181 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.189 UpdateModeId { id: 83 } TagId(1) Test.183 Test.25 Test.184 Test.24 Test.182;
+                                        let Test.181 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.210 UpdateModeId { id: 83 } TagId(1) Test.183 Test.25 Test.184 Test.24 Test.182;
-                                        let #Derived_gen.14 : {} = lowlevel PtrStore #Derived_gen.6 Test.181;
+                                        let Bool.35 : {} = lowlevel PtrStore Bool.27 Test.181;
-                                        let #Derived_gen.13 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                                        let Bool.34 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                                        ret #Derived_gen.13;
+                                        ret Bool.34;
                                     in
-                                    let #Derived_gen.73 : Int1 = lowlevel RefCountIsUnique Test.180;
+                                    let Bool.94 : Int1 = lowlevel RefCountIsUnique Test.180;
-                                    if #Derived_gen.73 then
+                                    if Bool.94 then
-                                        let #Derived_gen.192 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.198, id: UpdateModeId { id: 86 } };
+                                        let Bool.213 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.198, id: UpdateModeId { id: 86 } };
-                                        jump #Derived_gen.72 #Derived_gen.187 #Derived_gen.192 Test.180;
+                                        jump Bool.93 Bool.208 Bool.213 Test.180;
                                     else
                                         inc Test.26;
                                         decref Test.180;
-                                        let #Derived_gen.193 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                                        let Bool.214 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                                        jump #Derived_gen.72 #Derived_gen.193 #Derived_gen.193 #Derived_gen.187;
+                                        jump Bool.93 Bool.214 Bool.214 Bool.208;
                                 in
                                 let Test.228 : U8 = 1i64;
                                 let Test.229 : U8 = GetTagId Test.180;
                                 let Test.230 : Int1 = lowlevel Eq Test.228 Test.229;
                                 if Test.230 then
-                                    joinpoint Test.225 #Derived_gen.201:
+                                    joinpoint Test.225 Bool.222:
-                                        joinpoint Test.216 #Derived_gen.202:
+                                        joinpoint Test.216 Bool.223:
                                             let Test.46 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.180;
                                             let Test.48 : I64 = UnionAtIndex (Id 1) (Index 1) Test.180;
                                             let Test.49 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.180;
                                             let Test.47 : I32 = UnionAtIndex (Id 1) (Index 3) Test.180;
-                                            joinpoint #Derived_gen.66 #Derived_gen.203 #Derived_gen.204:
+                                            joinpoint Bool.87 Bool.224 Bool.225:
                                                 let Test.196 : Int1 = true;
-                                                let Test.195 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.204 UpdateModeId { id: 100 } TagId(1) Test.46 Test.48 Test.49 Test.47 Test.196;
+                                                let Test.195 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.225 UpdateModeId { id: 100 } TagId(1) Test.46 Test.48 Test.49 Test.47 Test.196;
                                                 let Test.194 : Int1 = false;
-                                                let Test.193 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.203 UpdateModeId { id: 99 } TagId(1) Test.195 Test.18 Test.19 Test.17 Test.194;
+                                                let Test.193 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.224 UpdateModeId { id: 99 } TagId(1) Test.195 Test.18 Test.19 Test.17 Test.194;
-                                                let #Derived_gen.16 : {} = lowlevel PtrStore #Derived_gen.6 Test.193;
+                                                let Bool.37 : {} = lowlevel PtrStore Bool.27 Test.193;
-                                                let #Derived_gen.15 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                                                let Bool.36 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                                                ret #Derived_gen.15;
+                                                ret Bool.36;
                                             in
-                                            let #Derived_gen.67 : Int1 = lowlevel RefCountIsUnique Test.180;
+                                            let Bool.88 : Int1 = lowlevel RefCountIsUnique Test.180;
-                                            if #Derived_gen.67 then
+                                            if Bool.88 then
-                                                jump #Derived_gen.66 #Derived_gen.202 Test.180;
+                                                jump Bool.87 Bool.223 Test.180;
                                             else
                                                 inc Test.46;
                                                 inc Test.49;
                                                 decref Test.180;
-                                                let #Derived_gen.205 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                                                let Bool.226 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                                                jump #Derived_gen.66 #Derived_gen.205 #Derived_gen.202;
+                                                jump Bool.87 Bool.226 Bool.223;
                                         in
                                         let Test.213 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.180;
                                         let Test.214 : U8 = 1i64;
@@ -121,11 +121,11 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                             let Test.212 : Int1 = true;
                                             let Test.217 : Int1 = lowlevel Eq Test.212 Test.211;
                                             if Test.217 then
-                                                jump Test.199 #Derived_gen.201;
+                                                jump Test.199 Bool.222;
                                             else
-                                                jump Test.216 #Derived_gen.201;
+                                                jump Test.216 Bool.222;
                                         else
-                                            jump Test.216 #Derived_gen.201;
+                                            jump Test.216 Bool.222;
                                     in
                                     let Test.222 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.180;
                                     let Test.223 : U8 = 1i64;
@@ -137,7 +137,7 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                         let Test.221 : Int1 = true;
                                         let Test.226 : Int1 = lowlevel Eq Test.221 Test.220;
                                         if Test.226 then
-                                            joinpoint Test.207 #Derived_gen.206:
+                                            joinpoint Test.207 Bool.227:
                                                 let Test.33 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.180;
                                                 let Test.35 : I64 = UnionAtIndex (Id 1) (Index 1) Test.180;
                                                 let Test.200 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.180;
@@ -148,26 +148,26 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                                 inc Test.39;
                                                 let Test.37 : I32 = UnionAtIndex (Id 1) (Index 3) Test.200;
                                                 let Test.34 : I32 = UnionAtIndex (Id 1) (Index 3) Test.180;
-                                                joinpoint #Derived_gen.70 #Derived_gen.208 #Derived_gen.209 #Derived_gen.210:
+                                                joinpoint Bool.91 Bool.229 Bool.230 Bool.231:
                                                     let Test.192 : Int1 = false;
-                                                    let Test.189 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.210 UpdateModeId { id: 107 } TagId(1) Test.33 Test.35 Test.36 Test.34 Test.192;
+                                                    let Test.189 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.231 UpdateModeId { id: 107 } TagId(1) Test.33 Test.35 Test.36 Test.34 Test.192;
                                                     let Test.191 : Int1 = false;
-                                                    let Test.190 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.209 UpdateModeId { id: 106 } TagId(1) Test.39 Test.18 Test.19 Test.17 Test.191;
+                                                    let Test.190 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.230 UpdateModeId { id: 106 } TagId(1) Test.39 Test.18 Test.19 Test.17 Test.191;
                                                     let Test.188 : Int1 = true;
-                                                    let Test.187 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.208 UpdateModeId { id: 105 } TagId(1) Test.189 Test.38 Test.190 Test.37 Test.188;
+                                                    let Test.187 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.229 UpdateModeId { id: 105 } TagId(1) Test.189 Test.38 Test.190 Test.37 Test.188;
-                                                    let #Derived_gen.18 : {} = lowlevel PtrStore #Derived_gen.6 Test.187;
+                                                    let Bool.39 : {} = lowlevel PtrStore Bool.27 Test.187;
-                                                    let #Derived_gen.17 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                                                    let Bool.38 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                                                    ret #Derived_gen.17;
+                                                    ret Bool.38;
                                                 in
-                                                let #Derived_gen.71 : Int1 = lowlevel RefCountIsUnique Test.180;
+                                                let Bool.92 : Int1 = lowlevel RefCountIsUnique Test.180;
-                                                if #Derived_gen.71 then
+                                                if Bool.92 then
-                                                    let #Derived_gen.211 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.200, id: UpdateModeId { id: 108 } };
+                                                    let Bool.232 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.200, id: UpdateModeId { id: 108 } };
-                                                    jump #Derived_gen.70 #Derived_gen.206 #Derived_gen.211 Test.180;
+                                                    jump Bool.91 Bool.227 Bool.232 Test.180;
                                                 else
                                                     inc Test.33;
                                                     decref Test.180;
-                                                    let #Derived_gen.212 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                                                    let Bool.233 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                                                    jump #Derived_gen.70 #Derived_gen.212 #Derived_gen.212 #Derived_gen.206;
+                                                    jump Bool.91 Bool.233 Bool.233 Bool.227;
                                             in
                                             let Test.204 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.180;
                                             let Test.205 : U8 = 1i64;
@@ -179,36 +179,36 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                                 let Test.203 : Int1 = true;
                                                 let Test.208 : Int1 = lowlevel Eq Test.203 Test.202;
                                                 if Test.208 then
-                                                    jump Test.199 #Derived_gen.118;
+                                                    jump Test.199 Bool.139;
                                                 else
-                                                    jump Test.207 #Derived_gen.118;
+                                                    jump Test.207 Bool.139;
                                             else
-                                                jump Test.207 #Derived_gen.118;
+                                                jump Test.207 Bool.139;
                                         else
-                                            jump Test.225 #Derived_gen.118;
+                                            jump Test.225 Bool.139;
                                     else
-                                        jump Test.225 #Derived_gen.118;
+                                        jump Test.225 Bool.139;
                                 else
-                                    decref #Derived_gen.118;
+                                    decref Bool.139;
                                     dec Test.19;
                                     let Test.197 : [<rnu>C *self I64 *self I32 Int1, <null>] = TagId(0) ;
-                                    let #Derived_gen.20 : {} = lowlevel PtrStore #Derived_gen.6 Test.197;
+                                    let Bool.41 : {} = lowlevel PtrStore Bool.27 Test.197;
-                                    let #Derived_gen.19 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                                    let Bool.40 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                                    ret #Derived_gen.19;
+                                    ret Bool.40;
                             else
-                                jump Test.238 #Derived_gen.118;
+                                jump Test.238 Bool.139;
                         else
-                            jump Test.238 #Derived_gen.118;
+                            jump Test.238 Bool.139;
                     else
                         let Test.117 : Int1 = CallByName Num.24 Test.10 Test.17;
                         if Test.117 then
-                            joinpoint Test.176 #Derived_gen.288:
+                            joinpoint Test.176 Bool.309:
                                 let Test.170 : Int1 = false;
-                                let #Derived_gen.21 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                                let Bool.42 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                                let Test.169 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.288 UpdateModeId { id: 196 } TagId(1) Test.16 Test.18 #Derived_gen.21 Test.17 Test.170;
+                                let Test.169 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.309 UpdateModeId { id: 196 } TagId(1) Test.16 Test.18 Bool.42 Test.17 Test.170;
-                                let #Derived_gen.22 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = GetElementPointer (Indices [1, 2]) Test.169;
+                                let Bool.43 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = GetElementPointer (Indices [1, 2]) Test.169;
-                                let #Derived_gen.23 : {} = lowlevel PtrStore #Derived_gen.6 Test.169;
+                                let Bool.44 : {} = lowlevel PtrStore Bool.27 Test.169;
-                                jump #Derived_gen.5 Test.19 Test.10 Test.11 #Derived_gen.22 #Derived_gen.7;
+                                jump Bool.26 Test.19 Test.10 Test.11 Bool.43 Bool.28;
                             in
                             let Test.174 : U8 = 1i64;
                             let Test.175 : U8 = GetTagId Test.19;
@@ -219,9 +219,9 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                 let Test.177 : Int1 = lowlevel Eq Test.173 Test.172;
                                 if Test.177 then
                                     inc Test.19;
-                                    let #Derived_gen.289 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.16, id: UpdateModeId { id: 197 } };
+                                    let Bool.310 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.16, id: UpdateModeId { id: 197 } };
                                     let Test.118 : [<rnu>C *self I64 *self I32 Int1, <null>] = CallByName Test.3 Test.19 Test.10 Test.11;
-                                    joinpoint Test.137 #Derived_gen.322 #Derived_gen.323:
+                                    joinpoint Test.137 Bool.343 Bool.344:
                                         let Test.136 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.118;
                                         let Test.57 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.136;
                                         inc Test.57;
@@ -232,56 +232,56 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                         let Test.62 : I64 = UnionAtIndex (Id 1) (Index 1) Test.118;
                                         let Test.63 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.118;
                                         let Test.61 : I32 = UnionAtIndex (Id 1) (Index 3) Test.118;
-                                        joinpoint #Derived_gen.112 #Derived_gen.326 #Derived_gen.327 #Derived_gen.328:
+                                        joinpoint Bool.133 Bool.347 Bool.348 Bool.349:
                                             let Test.124 : Int1 = false;
-                                            let Test.121 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.328 UpdateModeId { id: 242 } TagId(1) Test.57 Test.59 Test.60 Test.58 Test.124;
+                                            let Test.121 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.349 UpdateModeId { id: 242 } TagId(1) Test.57 Test.59 Test.60 Test.58 Test.124;
                                             let Test.123 : Int1 = false;
-                                            let Test.122 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.327 UpdateModeId { id: 241 } TagId(1) Test.63 Test.18 Test.19 Test.17 Test.123;
+                                            let Test.122 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.348 UpdateModeId { id: 241 } TagId(1) Test.63 Test.18 Test.19 Test.17 Test.123;
                                             let Test.120 : Int1 = true;
-                                            let Test.119 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.326 UpdateModeId { id: 240 } TagId(1) Test.121 Test.62 Test.122 Test.61 Test.120;
+                                            let Test.119 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.347 UpdateModeId { id: 240 } TagId(1) Test.121 Test.62 Test.122 Test.61 Test.120;
-                                            let #Derived_gen.25 : {} = lowlevel PtrStore #Derived_gen.6 Test.119;
+                                            let Bool.46 : {} = lowlevel PtrStore Bool.27 Test.119;
-                                            let #Derived_gen.24 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                                            let Bool.45 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                                            ret #Derived_gen.24;
+                                            ret Bool.45;
                                         in
-                                        let #Derived_gen.113 : Int1 = lowlevel RefCountIsUnique Test.118;
+                                        let Bool.134 : Int1 = lowlevel RefCountIsUnique Test.118;
-                                        if #Derived_gen.113 then
+                                        if Bool.134 then
-                                            decref #Derived_gen.322;
+                                            decref Bool.343;
-                                            let #Derived_gen.329 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.136, id: UpdateModeId { id: 243 } };
+                                            let Bool.350 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.136, id: UpdateModeId { id: 243 } };
-                                            jump #Derived_gen.112 #Derived_gen.323 #Derived_gen.329 Test.118;
+                                            jump Bool.133 Bool.344 Bool.350 Test.118;
                                         else
                                             inc Test.63;
                                             decref Test.118;
-                                            let #Derived_gen.330 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                                            let Bool.351 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                                            jump #Derived_gen.112 #Derived_gen.330 #Derived_gen.322 #Derived_gen.323;
+                                            jump Bool.133 Bool.351 Bool.343 Bool.344;
                                     in
                                     let Test.166 : U8 = 1i64;
                                     let Test.167 : U8 = GetTagId Test.118;
                                     let Test.168 : Int1 = lowlevel Eq Test.166 Test.167;
                                     if Test.168 then
-                                        joinpoint Test.163 #Derived_gen.340 #Derived_gen.341:
+                                        joinpoint Test.163 Bool.361 Bool.362:
-                                            joinpoint Test.154 #Derived_gen.342 #Derived_gen.343:
+                                            joinpoint Test.154 Bool.363 Bool.364:
                                                 let Test.83 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.118;
                                                 let Test.85 : I64 = UnionAtIndex (Id 1) (Index 1) Test.118;
                                                 let Test.86 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.118;
                                                 let Test.84 : I32 = UnionAtIndex (Id 1) (Index 3) Test.118;
-                                                joinpoint #Derived_gen.102 #Derived_gen.345 #Derived_gen.346:
+                                                joinpoint Bool.123 Bool.366 Bool.367:
                                                     let Test.134 : Int1 = true;
-                                                    let Test.133 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.346 UpdateModeId { id: 262 } TagId(1) Test.83 Test.85 Test.86 Test.84 Test.134;
+                                                    let Test.133 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.367 UpdateModeId { id: 262 } TagId(1) Test.83 Test.85 Test.86 Test.84 Test.134;
                                                     let Test.132 : Int1 = false;
-                                                    let Test.131 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.345 UpdateModeId { id: 261 } TagId(1) Test.133 Test.18 Test.19 Test.17 Test.132;
+                                                    let Test.131 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.366 UpdateModeId { id: 261 } TagId(1) Test.133 Test.18 Test.19 Test.17 Test.132;
-                                                    let #Derived_gen.27 : {} = lowlevel PtrStore #Derived_gen.6 Test.131;
+                                                    let Bool.48 : {} = lowlevel PtrStore Bool.27 Test.131;
-                                                    let #Derived_gen.26 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                                                    let Bool.47 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                                                    ret #Derived_gen.26;
+                                                    ret Bool.47;
                                                 in
-                                                let #Derived_gen.103 : Int1 = lowlevel RefCountIsUnique Test.118;
+                                                let Bool.124 : Int1 = lowlevel RefCountIsUnique Test.118;
-                                                if #Derived_gen.103 then
+                                                if Bool.124 then
-                                                    decref #Derived_gen.342;
+                                                    decref Bool.363;
-                                                    jump #Derived_gen.102 #Derived_gen.343 Test.118;
+                                                    jump Bool.123 Bool.364 Test.118;
                                                 else
                                                     inc Test.83;
                                                     inc Test.86;
                                                     decref Test.118;
-                                                    jump #Derived_gen.102 #Derived_gen.342 #Derived_gen.343;
+                                                    jump Bool.123 Bool.363 Bool.364;
                                             in
                                             let Test.151 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.118;
                                             let Test.152 : U8 = 1i64;
@@ -293,11 +293,11 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                                 let Test.150 : Int1 = true;
                                                 let Test.155 : Int1 = lowlevel Eq Test.150 Test.149;
                                                 if Test.155 then
-                                                    jump Test.137 #Derived_gen.340 #Derived_gen.341;
+                                                    jump Test.137 Bool.361 Bool.362;
                                                 else
-                                                    jump Test.154 #Derived_gen.340 #Derived_gen.341;
+                                                    jump Test.154 Bool.361 Bool.362;
                                             else
-                                                jump Test.154 #Derived_gen.340 #Derived_gen.341;
+                                                jump Test.154 Bool.361 Bool.362;
                                         in
                                         let Test.160 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.118;
                                         let Test.161 : U8 = 1i64;
@@ -309,7 +309,7 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                             let Test.159 : Int1 = true;
                                             let Test.164 : Int1 = lowlevel Eq Test.159 Test.158;
                                             if Test.164 then
-                                                joinpoint Test.145 #Derived_gen.347 #Derived_gen.348:
+                                                joinpoint Test.145 Bool.368 Bool.369:
                                                     let Test.70 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.118;
                                                     let Test.72 : I64 = UnionAtIndex (Id 1) (Index 1) Test.118;
                                                     let Test.138 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.118;
@@ -320,27 +320,27 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                                     inc Test.76;
                                                     let Test.74 : I32 = UnionAtIndex (Id 1) (Index 3) Test.138;
                                                     let Test.71 : I32 = UnionAtIndex (Id 1) (Index 3) Test.118;
-                                                    joinpoint #Derived_gen.106 #Derived_gen.351 #Derived_gen.352 #Derived_gen.353:
+                                                    joinpoint Bool.127 Bool.372 Bool.373 Bool.374:
                                                         let Test.130 : Int1 = false;
-                                                        let Test.127 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.353 UpdateModeId { id: 271 } TagId(1) Test.70 Test.72 Test.73 Test.71 Test.130;
+                                                        let Test.127 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.374 UpdateModeId { id: 271 } TagId(1) Test.70 Test.72 Test.73 Test.71 Test.130;
                                                         let Test.129 : Int1 = false;
-                                                        let Test.128 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.352 UpdateModeId { id: 270 } TagId(1) Test.76 Test.18 Test.19 Test.17 Test.129;
+                                                        let Test.128 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.373 UpdateModeId { id: 270 } TagId(1) Test.76 Test.18 Test.19 Test.17 Test.129;
                                                         let Test.126 : Int1 = true;
-                                                        let Test.125 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.351 UpdateModeId { id: 269 } TagId(1) Test.127 Test.75 Test.128 Test.74 Test.126;
+                                                        let Test.125 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.372 UpdateModeId { id: 269 } TagId(1) Test.127 Test.75 Test.128 Test.74 Test.126;
-                                                        let #Derived_gen.29 : {} = lowlevel PtrStore #Derived_gen.6 Test.125;
+                                                        let Bool.50 : {} = lowlevel PtrStore Bool.27 Test.125;
-                                                        let #Derived_gen.28 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                                                        let Bool.49 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                                                        ret #Derived_gen.28;
+                                                        ret Bool.49;
                                                     in
-                                                    let #Derived_gen.107 : Int1 = lowlevel RefCountIsUnique Test.118;
+                                                    let Bool.128 : Int1 = lowlevel RefCountIsUnique Test.118;
-                                                    if #Derived_gen.107 then
+                                                    if Bool.128 then
-                                                        decref #Derived_gen.347;
+                                                        decref Bool.368;
-                                                        let #Derived_gen.354 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.138, id: UpdateModeId { id: 272 } };
+                                                        let Bool.375 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reset { symbol: Test.138, id: UpdateModeId { id: 272 } };
-                                                        jump #Derived_gen.106 #Derived_gen.348 #Derived_gen.354 Test.118;
+                                                        jump Bool.127 Bool.369 Bool.375 Test.118;
                                                     else
                                                         inc Test.70;
                                                         decref Test.118;
-                                                        let #Derived_gen.355 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                                                        let Bool.376 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                                                        jump #Derived_gen.106 #Derived_gen.355 #Derived_gen.347 #Derived_gen.348;
+                                                        jump Bool.127 Bool.376 Bool.368 Bool.369;
                                                 in
                                                 let Test.142 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.118;
                                                 let Test.143 : U8 = 1i64;
@@ -352,96 +352,96 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2):
                                                     let Test.141 : Int1 = true;
                                                     let Test.146 : Int1 = lowlevel Eq Test.141 Test.140;
                                                     if Test.146 then
-                                                        jump Test.137 #Derived_gen.118 #Derived_gen.289;
+                                                        jump Test.137 Bool.139 Bool.310;
                                                     else
-                                                        jump Test.145 #Derived_gen.118 #Derived_gen.289;
+                                                        jump Test.145 Bool.139 Bool.310;
                                                 else
-                                                    jump Test.145 #Derived_gen.118 #Derived_gen.289;
+                                                    jump Test.145 Bool.139 Bool.310;
                                             else
-                                                jump Test.163 #Derived_gen.118 #Derived_gen.289;
+                                                jump Test.163 Bool.139 Bool.310;
                                         else
-                                            jump Test.163 #Derived_gen.118 #Derived_gen.289;
+                                            jump Test.163 Bool.139 Bool.310;
                                     else
-                                        decref #Derived_gen.289;
+                                        decref Bool.310;
-                                        decref #Derived_gen.118;
+                                        decref Bool.139;
-                                        joinpoint #Derived_gen.108:
+                                        joinpoint Bool.129:
                                             let Test.135 : [<rnu>C *self I64 *self I32 Int1, <null>] = TagId(0) ;
-                                            let #Derived_gen.31 : {} = lowlevel PtrStore #Derived_gen.6 Test.135;
+                                            let Bool.52 : {} = lowlevel PtrStore Bool.27 Test.135;
-                                            let #Derived_gen.30 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                                            let Bool.51 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                                            ret #Derived_gen.30;
+                                            ret Bool.51;
                                         in
-                                        let #Derived_gen.111 : Int1 = lowlevel RefCountIsUnique Test.19;
+                                        let Bool.132 : Int1 = lowlevel RefCountIsUnique Test.19;
-                                        if #Derived_gen.111 then
+                                        if Bool.132 then
-                                            let #Derived_gen.110 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.19;
+                                            let Bool.131 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.19;
-                                            dec #Derived_gen.110;
+                                            dec Bool.131;
-                                            let #Derived_gen.109 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.19;
+                                            let Bool.130 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.19;
-                                            dec #Derived_gen.109;
+                                            dec Bool.130;
                                             free Test.19;
-                                            jump #Derived_gen.108;
+                                            jump Bool.129;
                                         else
                                             decref Test.19;
-                                            jump #Derived_gen.108;
+                                            jump Bool.129;
                                 else
-                                    jump Test.176 #Derived_gen.118;
+                                    jump Test.176 Bool.139;
                             else
-                                jump Test.176 #Derived_gen.118;
+                                jump Test.176 Bool.139;
                         else
                             let Test.116 : Int1 = false;
-                            let Test.115 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.118 UpdateModeId { id: 1 } TagId(1) Test.16 Test.11 Test.19 Test.10 Test.116;
+                            let Test.115 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.139 UpdateModeId { id: 1 } TagId(1) Test.16 Test.11 Test.19 Test.10 Test.116;
-                            let #Derived_gen.33 : {} = lowlevel PtrStore #Derived_gen.6 Test.115;
+                            let Bool.54 : {} = lowlevel PtrStore Bool.27 Test.115;
-                            let #Derived_gen.32 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                            let Bool.53 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                            ret #Derived_gen.32;
+                            ret Bool.53;
                 in
-                let #Derived_gen.115 : Int1 = lowlevel RefCountIsUnique Test.9;
+                let Bool.136 : Int1 = lowlevel RefCountIsUnique Test.9;
-                if #Derived_gen.115 then
+                if Bool.136 then
-                    jump #Derived_gen.114 Test.9;
+                    jump Bool.135 Test.9;
                 else
                     inc Test.16;
                     inc Test.19;
                     decref Test.9;
-                    let #Derived_gen.363 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                    let Bool.384 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                    jump #Derived_gen.114 #Derived_gen.363;
+                    jump Bool.135 Bool.384;
             else
                 let Test.96 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 0) Test.9;
                 let Test.98 : I64 = UnionAtIndex (Id 1) (Index 1) Test.9;
                 let Test.99 : [<rnu>C *self I64 *self I32 Int1, <null>] = UnionAtIndex (Id 1) (Index 2) Test.9;
                 let Test.97 : I32 = UnionAtIndex (Id 1) (Index 3) Test.9;
-                joinpoint #Derived_gen.116 #Derived_gen.364:
+                joinpoint Bool.137 Bool.385:
                     let Test.247 : Int1 = CallByName Num.22 Test.10 Test.97;
                     if Test.247 then
                         let Test.249 : Int1 = true;
-                        let #Derived_gen.34 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                        let Bool.55 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                        let Test.248 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.364 UpdateModeId { id: 284 } TagId(1) #Derived_gen.34 Test.98 Test.99 Test.97 Test.249;
+                        let Test.248 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.385 UpdateModeId { id: 284 } TagId(1) Bool.55 Test.98 Test.99 Test.97 Test.249;
-                        let #Derived_gen.35 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = GetElementPointer (Indices [1, 0]) Test.248;
+                        let Bool.56 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = GetElementPointer (Indices [1, 0]) Test.248;
-                        let #Derived_gen.36 : {} = lowlevel PtrStore #Derived_gen.6 Test.248;
+                        let Bool.57 : {} = lowlevel PtrStore Bool.27 Test.248;
-                        jump #Derived_gen.5 Test.96 Test.10 Test.11 #Derived_gen.35 #Derived_gen.7;
+                        jump Bool.26 Test.96 Test.10 Test.11 Bool.56 Bool.28;
                     else
                         let Test.243 : Int1 = CallByName Num.24 Test.10 Test.97;
                         if Test.243 then
                             let Test.245 : Int1 = true;
-                            let #Derived_gen.37 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                            let Bool.58 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                            let Test.244 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.364 UpdateModeId { id: 284 } TagId(1) Test.96 Test.98 #Derived_gen.37 Test.97 Test.245;
+                            let Test.244 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.385 UpdateModeId { id: 284 } TagId(1) Test.96 Test.98 Bool.58 Test.97 Test.245;
-                            let #Derived_gen.38 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = GetElementPointer (Indices [1, 2]) Test.244;
+                            let Bool.59 : Ptr([<rnu>C *self I64 *self I32 Int1, <null>]) = GetElementPointer (Indices [1, 2]) Test.244;
-                            let #Derived_gen.39 : {} = lowlevel PtrStore #Derived_gen.6 Test.244;
+                            let Bool.60 : {} = lowlevel PtrStore Bool.27 Test.244;
-                            jump #Derived_gen.5 Test.99 Test.10 Test.11 #Derived_gen.38 #Derived_gen.7;
+                            jump Bool.26 Test.99 Test.10 Test.11 Bool.59 Bool.28;
                         else
                             let Test.242 : Int1 = true;
-                            let Test.241 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse #Derived_gen.364 UpdateModeId { id: 284 } TagId(1) Test.96 Test.11 Test.99 Test.10 Test.242;
+                            let Test.241 : [<rnu>C *self I64 *self I32 Int1, <null>] = Reuse Bool.385 UpdateModeId { id: 284 } TagId(1) Test.96 Test.11 Test.99 Test.10 Test.242;
-                            let #Derived_gen.41 : {} = lowlevel PtrStore #Derived_gen.6 Test.241;
+                            let Bool.62 : {} = lowlevel PtrStore Bool.27 Test.241;
-                            let #Derived_gen.40 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad #Derived_gen.7;
+                            let Bool.61 : [<rnu>C *self I64 *self I32 Int1, <null>] = lowlevel PtrLoad Bool.28;
-                            ret #Derived_gen.40;
+                            ret Bool.61;
                 in
-                let #Derived_gen.117 : Int1 = lowlevel RefCountIsUnique Test.9;
+                let Bool.138 : Int1 = lowlevel RefCountIsUnique Test.9;
-                if #Derived_gen.117 then
+                if Bool.138 then
-                    jump #Derived_gen.116 Test.9;
+                    jump Bool.137 Test.9;
                 else
                     inc Test.96;
                     inc Test.99;
                     decref Test.9;
-                    let #Derived_gen.365 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
+                    let Bool.386 : [<rnu>C *self I64 *self I32 Int1, <null>] = NullPointer;
-                    jump #Derived_gen.116 #Derived_gen.365;
+                    jump Bool.137 Bool.386;
     in
-    jump #Derived_gen.5 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.3;
+    jump Bool.26 Bool.21 Bool.22 Bool.23 Bool.24 Bool.24;
 
 procedure Test.0 ():
     let Test.281 : [<rnu>C *self I64 *self I32 Int1, <null>] = TagId(0) ;

crates/compiler/test_mono/generated/recursive_call_capturing_function.txt

@@ -11,7 +11,7 @@ procedure Test.1 (Test.2):
     let Test.7 : U32 = CallByName Test.3 Test.8 Test.2;
     ret Test.7;
 
-procedure Test.3 (#Derived_gen.0, #Derived_gen.1):
+procedure Test.3 (Bool.22, Bool.23):
     joinpoint Test.9 Test.4 Test.2:
         let Test.13 : Int1 = CallByName Bool.2;
         if Test.13 then
@@ -20,7 +20,7 @@ procedure Test.3 (#Derived_gen.0, #Derived_gen.1):
             let Test.11 : U32 = CallByName Num.19 Test.4 Test.2;
             jump Test.9 Test.11 Test.2;
     in
-    jump Test.9 #Derived_gen.0 #Derived_gen.1;
+    jump Test.9 Bool.22 Bool.23;
 
 procedure Test.0 ():
     let Test.6 : U32 = 6i64;

crates/compiler/test_mono/generated/recursive_function_and_union_with_inference_hole.txt

@@ -1,4 +1,4 @@
-procedure List.101 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4, #Derived_gen.5):
+procedure List.101 (Bool.22, Bool.23, Bool.24, Bool.25, Bool.26):
     joinpoint List.681 List.175 List.176 List.177 List.178 List.179:
         let List.683 : Int1 = CallByName Num.22 List.178 List.179;
         if List.683 then
@@ -12,8 +12,8 @@ procedure List.101 (#Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen
             dec List.175;
             ret List.176;
     in
-    inc #Derived_gen.1;
+    inc Bool.22;
-    jump List.681 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4 #Derived_gen.5;
+    jump List.681 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
 
 procedure List.18 (List.172, List.173, List.174):
     let List.679 : U64 = 0i64;
@@ -59,11 +59,11 @@ procedure Num.51 (#Attr.2, #Attr.3):
 procedure Test.2 (Test.5):
     let Test.6 : List [<rnnu>C List *self] = UnionAtIndex (Id 0) (Index 0) Test.5;
     inc Test.6;
-    let #Derived_gen.9 : [<rnnu>C List *self] = Reset { symbol: Test.5, id: UpdateModeId { id: 0 } };
+    let Bool.30 : [<rnnu>C List *self] = Reset { symbol: Test.5, id: UpdateModeId { id: 0 } };
     let Test.15 : {} = Struct {};
     let Test.7 : List [<rnnu>C List *self] = CallByName List.5 Test.6 Test.15;
     dec Test.6;
-    let Test.14 : [<rnnu>C List *self] = Reuse #Derived_gen.9 UpdateModeId { id: 0 } TagId(0) Test.7;
+    let Test.14 : [<rnnu>C List *self] = Reuse Bool.30 UpdateModeId { id: 0 } TagId(0) Test.7;
     ret Test.14;
 
 procedure Test.0 ():

crates/compiler/test_mono/generated/recursive_lambda_set_has_nested_non_recursive_lambda_sets_issue_5026.txt

@@ -25,7 +25,7 @@ procedure Test.3 (Test.7):
 
 procedure Test.6 (Test.16, #Attr.12):
     let Test.23 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    joinpoint #Derived_gen.2:
+    joinpoint Bool.24:
         let Test.19 : {} = Struct {};
         let Test.22 : Str = "foobar";
         let Test.20 : [<rnu><null>, C {}] = CallByName Test.8 Test.22 Test.23;
@@ -42,13 +42,13 @@ procedure Test.6 (Test.16, #Attr.12):
                 ret Test.18;
         
     in
-    let #Derived_gen.3 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+    let Bool.25 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-    if #Derived_gen.3 then
+    if Bool.25 then
         free #Attr.12;
-        jump #Derived_gen.2;
+        jump Bool.24;
     else
         decref #Attr.12;
-        jump #Derived_gen.2;
+        jump Bool.24;
 
 procedure Test.8 (Test.9, Test.7):
     let Test.25 : [<rnu><null>, C {}] = CallByName Test.10 Test.9;

crates/compiler/test_mono/generated/recursive_lambda_set_resolved_only_upon_specialization.txt

@@ -10,7 +10,7 @@ procedure Num.21 (#Attr.2, #Attr.3):
     let Num.283 : U8 = lowlevel NumMul #Attr.2 #Attr.3;
     ret Num.283;
 
-procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
+procedure Test.1 (Bool.22, Bool.23):
     joinpoint Test.11 Test.2 Test.3:
         let Test.26 : U8 = 0i64;
         let Test.22 : Int1 = CallByName Bool.9 Test.2 Test.26;
@@ -33,13 +33,13 @@ procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
             let Test.14 : [<rnu><null>, C *self U8] = TagId(0) Test.3 Test.2;
             jump Test.11 Test.13 Test.14;
     in
-    jump Test.11 #Derived_gen.0 #Derived_gen.1;
+    jump Test.11 Bool.22 Bool.23;
 
-procedure Test.4 (#Derived_gen.2, #Derived_gen.3):
+procedure Test.4 (Bool.24, Bool.25):
     joinpoint Test.15 Test.5 #Attr.12:
         let Test.20 : U8 = UnionAtIndex (Id 0) (Index 1) #Attr.12;
         let Test.19 : [<rnu><null>, C *self U8] = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-        joinpoint #Derived_gen.4:
+        joinpoint Bool.26:
             let Test.17 : U8 = CallByName Num.21 Test.20 Test.5;
             let Test.18 : U8 = GetTagId Test.19;
             switch Test.18:
@@ -52,16 +52,16 @@ procedure Test.4 (#Derived_gen.2, #Derived_gen.3):
                     ret Test.16;
             
         in
-        let #Derived_gen.5 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+        let Bool.27 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-        if #Derived_gen.5 then
+        if Bool.27 then
             free #Attr.12;
-            jump #Derived_gen.4;
+            jump Bool.26;
         else
             inc Test.19;
             decref #Attr.12;
-            jump #Derived_gen.4;
+            jump Bool.26;
     in
-    jump Test.15 #Derived_gen.2 #Derived_gen.3;
+    jump Test.15 Bool.24 Bool.25;
 
 procedure Test.6 (Test.7):
     ret Test.7;

crates/compiler/test_mono/generated/recursively_build_effect.txt

@@ -8,8 +8,8 @@ procedure Str.3 (#Attr.2, #Attr.3):
 
 procedure Test.11 (Test.29, #Attr.12):
     let Test.32 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
-    let #Derived_gen.9 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+    let Bool.30 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-    if #Derived_gen.9 then
+    if Bool.30 then
         free #Attr.12;
         ret Test.32;
     else
@@ -19,11 +19,11 @@ procedure Test.11 (Test.29, #Attr.12):
 procedure Test.11 (Test.29, Test.10):
     ret Test.10;
 
-procedure Test.14 (#Derived_gen.7, #Derived_gen.8):
+procedure Test.14 (Bool.28, Bool.29):
     joinpoint Test.38 Test.37 #Attr.12:
         let Test.46 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
         let Test.45 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
-        joinpoint #Derived_gen.10:
+        joinpoint Bool.31:
             let Test.44 : {} = Struct {};
             let Test.43 : {} = CallByName Test.11 Test.44 Test.46;
             let Test.39 : [<r>C {}, C I64 {}] = CallByName Test.9 Test.43 Test.45;
@@ -38,15 +38,15 @@ procedure Test.14 (#Derived_gen.7, #Derived_gen.8):
                     jump Test.38 Test.41 Test.39;
             
         in
-        let #Derived_gen.11 : Int1 = lowlevel RefCountIsUnique #Attr.12;
+        let Bool.32 : Int1 = lowlevel RefCountIsUnique #Attr.12;
-        if #Derived_gen.11 then
+        if Bool.32 then
             free #Attr.12;
-            jump #Derived_gen.10;
+            jump Bool.31;
         else
             decref #Attr.12;
-            jump #Derived_gen.10;
+            jump Bool.31;
     in
-    jump Test.38 #Derived_gen.7 #Derived_gen.8;
+    jump Test.38 Bool.28 Bool.29;
 
 procedure Test.2 ():
     let Test.6 : Str = "Hello";

crates/compiler/test_mono/generated/specialize_after_match.txt

@@ -23,7 +23,7 @@ procedure Test.2 (Test.9, Test.10):
             let Test.29 : U64 = CallByName Test.3 Test.9;
             ret Test.29;
         else
-            joinpoint #Derived_gen.4:
+            joinpoint Bool.25:
                 let Test.13 : Str = UnionAtIndex (Id 0) (Index 0) Test.10;
                 let Test.14 : [<rnu><null>, C Str *self] = UnionAtIndex (Id 0) (Index 1) Test.10;
                 let Test.33 : U64 = CallByName Test.3 Test.12;
@@ -36,15 +36,15 @@ procedure Test.2 (Test.9, Test.10):
                 else
                     ret Test.16;
             in
-            let #Derived_gen.5 : Int1 = lowlevel RefCountIsUnique Test.9;
+            let Bool.26 : Int1 = lowlevel RefCountIsUnique Test.9;
-            if #Derived_gen.5 then
+            if Bool.26 then
                 dec Test.11;
                 free Test.9;
-                jump #Derived_gen.4;
+                jump Bool.25;
             else
                 inc Test.12;
                 decref Test.9;
-                jump #Derived_gen.4;
+                jump Bool.25;
 
 procedure Test.3 (Test.17):
     let Test.26 : U8 = 1i64;
@@ -55,22 +55,22 @@ procedure Test.3 (Test.17):
         ret Test.22;
     else
         let Test.18 : [<rnu><null>, C Str *self] = UnionAtIndex (Id 0) (Index 1) Test.17;
-        joinpoint #Derived_gen.1:
+        joinpoint Bool.22:
             let Test.24 : U64 = 1i64;
             let Test.25 : U64 = CallByName Test.3 Test.18;
             let Test.23 : U64 = CallByName Num.19 Test.24 Test.25;
             ret Test.23;
         in
-        let #Derived_gen.3 : Int1 = lowlevel RefCountIsUnique Test.17;
+        let Bool.24 : Int1 = lowlevel RefCountIsUnique Test.17;
-        if #Derived_gen.3 then
+        if Bool.24 then
-            let #Derived_gen.2 : Str = UnionAtIndex (Id 0) (Index 0) Test.17;
+            let Bool.23 : Str = UnionAtIndex (Id 0) (Index 0) Test.17;
-            dec #Derived_gen.2;
+            dec Bool.23;
             free Test.17;
-            jump #Derived_gen.1;
+            jump Bool.22;
         else
             inc Test.18;
             decref Test.17;
-            jump #Derived_gen.1;
+            jump Bool.22;
 
 procedure Test.0 ():
     let Test.5 : [<rnu><null>, C Str *self] = TagId(1) ;

crates/compiler/test_mono/generated/tail_call_elimination.txt

@@ -6,7 +6,7 @@ procedure Num.20 (#Attr.2, #Attr.3):
     let Num.284 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
     ret Num.284;
 
-procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
+procedure Test.1 (Bool.21, Bool.22):
     joinpoint Test.7 Test.2 Test.3:
         let Test.13 : I64 = 0i64;
         let Test.14 : Int1 = lowlevel Eq Test.13 Test.2;
@@ -18,7 +18,7 @@ procedure Test.1 (#Derived_gen.0, #Derived_gen.1):
             let Test.11 : I64 = CallByName Num.19 Test.2 Test.3;
             jump Test.7 Test.10 Test.11;
     in
-    jump Test.7 #Derived_gen.0 #Derived_gen.1;
+    jump Test.7 Bool.21 Bool.22;
 
 procedure Test.0 ():
     let Test.5 : I64 = 1000000i64;

crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification.txt

@@ -59,8 +59,8 @@ procedure Test.43 (Test.44, Test.42):
         jump Test.62 Test.61;
     else
         let Test.69 : U8 = StructAtIndex 1 Test.42;
-        let #Derived_gen.5 : Str = StructAtIndex 0 Test.42;
+        let Bool.27 : Str = StructAtIndex 0 Test.42;
-        dec #Derived_gen.5;
+        dec Bool.27;
         let Test.63 : Int1 = CallByName Test.15 Test.69;
         let Test.61 : Int1 = CallByName Test.14 Test.63;
         jump Test.62 Test.61;

crates/compiler/test_mono/generated/weakening_avoids_overspecialization.txt

@@ -51,7 +51,7 @@ procedure List.72 (#Attr.2, #Attr.3, #Attr.4):
     let List.681 : List U8 = lowlevel ListSublist #Attr.2 #Attr.3 #Attr.4;
     ret List.681;
 
-procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.3, #Derived_gen.4):
+procedure List.80 (Bool.22, Bool.23, Bool.24, Bool.25, Bool.26):
     joinpoint List.695 List.566 List.567 List.568 List.569 List.570:
         let List.697 : Int1 = CallByName Num.22 List.569 List.570;
         if List.697 then
@@ -75,8 +75,8 @@ procedure List.80 (#Derived_gen.0, #Derived_gen.1, #Derived_gen.2, #Derived_gen.
             let List.696 : [C U64, C U64] = TagId(1) List.567;
             ret List.696;
     in
-    inc #Derived_gen.0;
+    inc Bool.22;
-    jump List.695 #Derived_gen.0 #Derived_gen.1 #Derived_gen.2 #Derived_gen.3 #Derived_gen.4;
+    jump List.695 Bool.22 Bool.23 Bool.24 Bool.25 Bool.26;
 
 procedure Num.22 (#Attr.2, #Attr.3):
     let Num.286 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;

crates/compiler/test_syntax/Cargo.toml

@@ -13,6 +13,7 @@ version.workspace = true
 [dependencies]
 bumpalo.workspace = true
 roc_can.workspace = true
+roc_can_solo.workspace = true
 roc_collections.workspace = true
 roc_error_macros.workspace = true
 roc_fmt.workspace = true

crates/compiler/test_syntax/src/test_helpers.rs

@@ -1,10 +1,11 @@
 use std::path::Path;
 
 use bumpalo::Bump;
-use roc_can::desugar;
 use roc_can::env::Env;
 use roc_can::expr::canonicalize_expr;
 use roc_can::scope::Scope;
+use roc_can_solo::env::SoloEnv;
+use roc_can_solo::scope::SoloScope;
 use roc_error_macros::set_panic_not_exit;
 use roc_fmt::{annotation::Formattable, header::fmt_header, MigrationFlags};
 use roc_module::ident::QualifiedModuleName;
@@ -217,7 +218,10 @@ impl<'a> Output<'a> {
                 // visited a BinOp node we'd recursively try to apply this to each of its nested
                 // operators, and then again on *their* nested operators, ultimately applying the
                 // rules multiple times unnecessarily.
-                let loc_expr = desugar::desugar_expr(&mut env, &mut scope, loc_expr);
+                let mut solo_env = SoloEnv::new(arena, src, Path::new("Test.roc"));
+                let mut solo_scope = SoloScope::new();
+                let loc_expr =
+                    roc_can_solo::desugar::desugar_expr(&mut solo_env, &mut solo_scope, loc_expr);
 
                 scope.add_alias(
                     Symbol::NUM_INT,

crates/compiler/uitest/tests/lambda_set/erased/multi_branch_capturing.txt

@@ -38,18 +38,18 @@ procedure Test.3 (Test.36):
 procedure Test.4 (Test.27, #Attr.12):
     let Test.29 : [<rnu><null>, C {Str}] = ErasedLoad #Attr.12 .Value;
     let Test.30 : {Str} = UnionAtIndex (Id 0) (Index 0) Test.29;
-    joinpoint #Derived_gen.0:
+    joinpoint Bool.22:
         let Test.2 : Str = StructAtIndex 0 Test.30;
         ret Test.2;
     in
-    let #Derived_gen.1 : Int1 = lowlevel RefCountIsUnique Test.29;
+    let Bool.23 : Int1 = lowlevel RefCountIsUnique Test.29;
-    if #Derived_gen.1 then
+    if Bool.23 then
         free Test.29;
-        jump #Derived_gen.0;
+        jump Bool.22;
     else
         inc Test.30;
         decref Test.29;
-        jump #Derived_gen.0;
+        jump Bool.22;
 
 procedure Test.0 ():
     let Test.6 : {} = Struct {};

crates/compiler/uitest/tests/specialize/record_update_between_modules.txt

@@ -25,8 +25,8 @@ procedure Dep.0 ():
 procedure Test.0 ():
     let Test.6 : {Str, Str} = CallByName Dep.0;
     let Test.3 : Str = StructAtIndex 0 Test.6;
-    let #Derived_gen.0 : Str = StructAtIndex 1 Test.6;
+    let Bool.21 : Str = StructAtIndex 1 Test.6;
-    dec #Derived_gen.0;
+    dec Bool.21;
     let Test.5 : Str = "http://www.example.com";
     let Test.2 : {Str, Str} = Struct {Test.3, Test.5};
     ret Test.2;

crates/compiler/work/src/work.rs

@@ -12,6 +12,7 @@ use std::collections::hash_map::Entry;
 pub enum Phase {
     LoadHeader,
     Parse,
+    SoloCanonicalize,
     CanonicalizeAndConstrain,
     SolveTypes,
     FindSpecializations,
@@ -19,9 +20,10 @@ pub enum Phase {
 }
 
 /// NOTE keep up to date manually, from ParseAndGenerateConstraints to the highest phase we support
-const PHASES: [Phase; 6] = [
+const PHASES: [Phase; 7] = [
     Phase::LoadHeader,
     Phase::Parse,
+    Phase::SoloCanonicalize,
     Phase::CanonicalizeAndConstrain,
     Phase::SolveTypes,
     Phase::FindSpecializations,

crates/test_compile/Cargo.toml

@@ -15,6 +15,7 @@ roc_collections.workspace = true
 roc_load.workspace = true
 roc_parse.workspace = true
 roc_can.workspace = true
+roc_can_solo.workspace = true
 roc_module.workspace = true
 roc_types.workspace = true
 roc_problem.workspace = true

crates/test_compile/src/help_can.rs

@@ -1,11 +1,12 @@
 use crate::help_parse::ParseExpr;
 use bumpalo::Bump;
 use roc_can::{
-    desugar,
     env::Env,
     expr::{canonicalize_expr, Expr, Output},
     scope::Scope,
 };
+use roc_can_solo::env::SoloEnv;
+use roc_can_solo::scope::SoloScope;
 use roc_module::symbol::{IdentIds, Interns, ModuleId, ModuleIds, PackageModuleIds, Symbol};
 use roc_problem::can::Problem;
 use roc_region::all::{Loc, Region};
@@ -80,7 +81,10 @@ impl CanExpr {
                 // visited a BinOp node we'd recursively try to apply this to each of its nested
                 // operators, and then again on *their* nested operators, ultimately applying the
                 // rules multiple times unnecessarily.
-                let loc_expr = desugar::desugar_expr(&mut env, &mut scope, &loc_expr);
+                let mut solo_env = SoloEnv::new(self.arena(), input, Path::new("Test.roc"));
+                let mut solo_scope = SoloScope::new();
+                let loc_expr =
+                    roc_can_solo::desugar::desugar_expr(&mut solo_env, &mut solo_scope, &loc_expr);
 
                 scope.add_alias(
                     Symbol::NUM_INT,