radiance · commit

lang: Implement explicit generics

28caf3e98df50e8d372eefa8cd54e7a4ea25cb68d9695da0f4a0b4046eef9cc0

Alexis Sellier committed 1 month ago 1 parent c7ed103c

compiler/radiance.rad +33 -29

/// Maximum number of test functions we can discover.
constant MAX_TESTS: u32 = 1024;
/// Maximum number of assembly source paths we can load per package.
constant MAX_ASM_MODULES: u32 = 64;

/// AST arena size (32 MB) - retains parsed nodes throughout compilation.
constant TEMP_ARENA_SIZE: u32 = 33554432;
/// AST arena size (40 MB) - retains parsed nodes throughout compilation.
constant TEMP_ARENA_SIZE: u32 = 41943040;
/// Per-function lowering and register-allocation arena size (16 MB).
constant FN_ARENA_SIZE: u32 = 16777216;
/// Main arena size (96 MB) - lives throughout compilation.
/// Used for: resolver data, types, symbols, global IL data, and codegen output.
/// Resolution owns the prefix it consumes; later phases own the remaining slice.
constant MAIN_ARENA_SIZE: u32 = 100663296;

/// AST storage arena.
static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
/// Scratch storage reclaimed after each generated function.


/// Lower all packages into a single IL program.
/// Dependencies are lowered first, then the entry package.
fn lowerAllPackages(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver
    res: *resolver::Resolver,
    arena: *mut alloc::Arena,
) -> il::Program throws (Error) {
    let entryIdx = ctx.entryPkgIdx else {
        panic "lowerAllPackages: no entry package";
    };
    let entryPkg = &ctx.packages[entryIdx];

    // Create the lowerer accumulator using entry package's name.
    let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };
    let mut low = lower::lowerer(
        res, &ctx.graph, entryPkg.name, &mut res.arena, &mut res.arena, options
        res, &ctx.graph, entryPkg.name, arena, arena, options
    );
    try lowerAllPackagesInto(ctx, res, &mut low);
    try lowerAllPackagesInto(ctx, &mut low);

    // Finalize and return the unified program.
    return lower::finalize(&low);
}

/// Lower all packages into an existing lowerer.
fn lowerAllPackagesInto(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver,
    low: *mut lower::Lowerer
    low: *mut lower::Lowerer,
) throws (Error) {
    let entryIdx = ctx.entryPkgIdx else {
        panic "lowerAllPackagesInto: no entry package";
    };
    // Lower all packages except entry.
    for i in 0..ctx.packageCount {
        if i <> entryIdx {
            try lowerPackage(ctx, res, low, &mut ctx.packages[i], false);
            try lowerPackage(ctx, low, &mut ctx.packages[i], false);
        }
    }
    // Lower entry package.
    try lowerPackage(ctx, res, low, &mut ctx.packages[entryIdx], true);
    try lowerPackage(ctx, low, &mut ctx.packages[entryIdx], true);
}

/// Lower all modules in a package into the lowerer accumulator.
fn lowerPackage(
    ctx: *CompileContext,
    res: *mut resolver::Resolver,
    low: *mut lower::Lowerer,
    pkg: *mut package::Package,
    isEntry: bool
) throws (Error) {
    let rootId = pkg.rootModuleId else {

    let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
    let attrList = ast::nodeSlice(arena, 1).append(attrNode, a);
    let fnAttrs = ast::Attributes { list: attrList };

    return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
        name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
        name: fnName, params: ast::nodeSlice(arena, 0), sig: fnSig, body: fnBody, attrs: fnAttrs,
    }));
}

/// Append a declaration to a block node's statement list.
fn injectIntoBlock(

}

/// Lower all packages while streaming each lowered function into RV64 codegen.
fn lowerAndGenerateAllPackages(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver,
    res: *resolver::Resolver,
    arena: *mut alloc::Arena,
    fnArena: *mut alloc::Arena,
    codegenOptions: CodegenOptions
) -> rv64::Program throws (Error) {
    let entryIdx = ctx.entryPkgIdx else {
        panic "lowerAndGenerateAllPackages: no entry package";

        }
        else => {}
    }
    let mut generator = rv64::beginProgram(
        rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug },
        &mut res.arena
        arena
    );
    let mut codegenCtx = CodegenSinkContext {
        generator: &mut generator,
        fnArena,
    };
    let mut low = lower::lowerer(
        res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena, options
        res, &ctx.graph, entryPkg.name, arena, fnArena, options
    );
    set low.output = lower::FnOutput::Stream(lower::FnSink {
        ctx: &mut codegenCtx as *mut opaque,
        emitFn: generateLoweredFn,
    });
    let mut asmDataLen: u32 = 0;
    if let path = startupPath {
        try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, &mut res.arena);
        try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, arena);
    }
    try lowerAllPackagesInto(ctx, res, &mut low);
    let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, &mut res.arena);
    try lowerAllPackagesInto(ctx, &mut low);
    let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, arena);

    match generator.entryPatch {
        case rv64::EntryPatch::Reserved(targetName) => {
            if targetName == nil {
                throw error(&["fatal:", "no default function found"]);

}

/// Lower, optionally dump, and optionally generate binary output.
fn compile(
    ctx: *mut CompileContext,
    res: *mut resolver::Resolver,
    fnArena: *mut alloc::Arena
    res: *resolver::Resolver,
    arena: *mut alloc::Arena,
    fnArena: *mut alloc::Arena,
) throws (Error) {
    let entryPkg = try getEntryPackage(ctx);
    let mut out = sexpr::Output::Stdout;

    if ctx.dump == Dump::Il {
        // Lower all packages into a single unified IL program for dumping.
        let program = try lowerAllPackages(ctx, res);
        il::printer::printProgram(&mut out, &mut res.arena, &program);
        let program = try lowerAllPackages(ctx, res, arena);
        il::printer::printProgram(&mut out, arena, &program);
        io::print("\n");
        return;
    }
    if ctx.dump == Dump::Asm {
        let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {
        let result = try lowerAndGenerateAllPackages(ctx, res, arena, fnArena, CodegenOptions {
            logPath: nil,
            debug: false,
            entryMode: CodegenEntryMode::None,
        });
        printer::printCodeTo(&mut out, entryPkg.name, result.code, result.funcs, &mut res.arena);
        printer::printCodeTo(&mut out, entryPkg.name, result.code, result.funcs, arena);
        io::print("\n");

        return;
    }
    // Generate binary output if path specified.
    let outPath = ctx.outputPath else {
        try lowerAllPackages(ctx, res);
        try lowerAllPackages(ctx, res, arena);
        return;
    };
    let startupPath = getEntryStartupPath(ctx);
    let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {
    let result = try lowerAndGenerateAllPackages(ctx, res, arena, fnArena, CodegenOptions {
        logPath: outPath,
        debug: ctx.debug,
        entryMode: CodegenEntryMode::None
            if startupPath <> nil
            else CodegenEntryMode::DefaultEntry,

        throw error(&["fatal:", "failed to write output file"]);
    }

    // Write debug info file if enabled.
    if ctx.debug {
        try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);
        try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, arena);
    }
    pkgLog(entryPkg, &["ok", "(", outPath, ")"]);
}

@default fn main(env: *sys::Env) -> i32 {

        try generateTestRunner(&mut ctx, &mut arena) catch {
            return 1;
        };
    }
    // Run resolution phase.
    let mut res = try runResolver(&mut ctx, arena.nextId) catch {
    let res = try runResolver(&mut ctx, arena.nextId) catch {
        return 1;
    };
    // Continue from the resolver's final arena cursor through a phase-owned
    // copy; lowering and code generation never mutate resolver state.
    let mut compileArena = res.arena;
    let mut fnArena = alloc::new(&mut FN_ARENA[..]);

    // Lower, dump, and/or generate output.
    try compile(&mut ctx, &mut res, &mut fnArena) catch {
    try compile(&mut ctx, &res, &mut compileArena, &mut fnArena) catch {
        return 1;
    };
    return 0;
}

lib/std/lang/ast.rad +39 -1

    arena: alloc::Arena,
    /// Next node ID to assign. Incremented on each node allocation.
    nextId: u32,
}

/// Generic declaration parameter.
export union GenericParam {
    /// Rigid type parameter with optional trait bounds.
    Type {
        /// Parameter name.
        name: *Node,
        /// Trait bounds in declaration order.
        bounds: *mut [*Node],
    },
    /// Compile-time constant parameter.
    Const {
        /// Parameter name.
        name: *Node,
        /// Declared integer type.
        type: *Node,
    },
}

/// Application of ordered generic arguments to a declaration or path.
export record GenericApply {
    /// Declaration or path receiving the arguments.
    target: *Node,
    /// Arguments in source order.
    args: *mut [*Node],
}

/// Initialize a node arena backed by the given byte slice.
export fn nodeArena(data: *mut [u8]) -> NodeArena {
    return NodeArena {
        arena: alloc::new(data),
        nextId: 0,


/// Record declaration.
export record RecordDecl {
    /// Identifier naming the record.
    name: *Node,
    /// Generic parameters in declaration order.
    params: *mut [*Node],
    /// Field declaration nodes.
    fields: *mut [*Node],
    /// Optional attribute list applied to the record.
    attrs: ?Attributes,
    /// Trait derivations attached to the record.


/// Union declarations.
export record UnionDecl {
    /// Identifier naming the union.
    name: *Node,
    /// Generic parameters in declaration order.
    params: *mut [*Node],
    /// Variant nodes making up the union.
    variants: *mut [*Node],
    /// Optional attribute list applied to the union.
    attrs: ?Attributes,
    /// Trait derivations attached to the union.


/// Function declaration.
export record FnDecl {
    /// Identifier naming the function.
    name: *Node,
    /// Generic parameters in declaration order.
    params: *mut [*Node],
    /// Function type signature.
    sig: FnSig,
    /// Optional function body (`nil` for extern functions).
    body: ?*Node,
    /// Optional attribute list applied to the function.

        /// Array or slice.
        container: *Node,
        /// Index expression.
        index: *Node
    },
    /// Generic declaration or function application.
    GenericApply(GenericApply),
    /// Binary operator expression.
    BinOp(BinOp),
    /// Unary operator expression.
    UnOp(UnOp),
    /// Builtin function call (e.g. `@sizeOf(T)`).

    UnionDeclVariant(UnionDeclVariant),
    /// Attribute node.
    Attribute(Attribute),
    /// Record type declaration.
    RecordDecl(RecordDecl),
    /// Generic declaration parameter.
    GenericParam(GenericParam),
    /// Explicit generic specialization roots declared as one group.
    Instantiate(*mut [*Node]),
    /// Record field declaration.
    RecordField {
        /// Identifier bound by the declaration.
        field: ?*Node,
        /// Declared type annotation.

    let params: *mut [*Node] = &mut [];
    let throwList: *mut [*Node] = &mut [];
    let fnSig = FnSig { params, returnType: nil, throwList };
    let fnBody = synthNode(arena, NodeValue::Block(Block { statements: bodyStmts }));
    let fnDecl = synthNode(arena, NodeValue::FnDecl(FnDecl {
        name: fnName, sig: fnSig, body: fnBody, attrs: nil,
        name: fnName, params: &mut [], sig: fnSig, body: fnBody, attrs: nil,
    }));
    let mut rootStmts: *mut [*Node] = &mut [];
    rootStmts.append(fnDecl, a);
    let modBody = synthNode(arena, NodeValue::Block(Block { statements: rootStmts }));


lib/std/lang/ast/printer.rad +33 -0

        }
        case super::NodeValue::BuiltinCall { kind, args } =>
            return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args[..])),
        case super::NodeValue::Subscript { container, index } =>
            return sexpr::list(a, "[]", &[toExpr(a, container), toExpr(a, index)]),
        case super::NodeValue::GenericApply(app) => {
            let buf = try! sexpr::allocExprs(a, app.args.len as u32 + 1);
            set buf[0] = toExpr(a, app.target);
            for arg, i in app.args { set buf[i + 1] = toExpr(a, arg); }
            return sexpr::Expr::List { head: "apply", tail: buf, multiline: false };
        }
        case super::NodeValue::FieldAccess(acc) =>
            return sexpr::list(a, ".", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),
        case super::NodeValue::ScopeAccess(acc) =>
            return sexpr::list(a, "::", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),
        case super::NodeValue::AddressOf(addr) =>

            return prongToExpr(a, p);
        }
        case super::NodeValue::FnDecl(f) => {
            let params = sexpr::list(a, "params", nodeListToExprs(a, &f.sig.params[..]));
            let ret = toExprOrNull(a, f.sig.returnType);
            if f.params.len > 0 {
                let generics = sexpr::list(a, "generics", nodeListToExprs(a, &f.params[..]));
                if let body = f.body {
                    return sexpr::block(a, "fn", &[toExpr(a, f.name), generics, params, ret], &[toExpr(a, body)]);
                }
                return sexpr::list(a, "fn", &[toExpr(a, f.name), generics, params, ret]);
            }
            if let body = f.body {
                return sexpr::block(a, "fn", &[toExpr(a, f.name), params, ret], &[toExpr(a, body)]);
            }
            return sexpr::list(a, "fn", &[toExpr(a, f.name), params, ret]);
        }
        case super::NodeValue::Mod(m) => return sexpr::list(a, "mod", &[toExpr(a, m.name)]),
        case super::NodeValue::Use(u_) => return sexpr::list(a, "use", &[toExpr(a, u_.path)]),
        case super::NodeValue::RecordDecl(r) => {
            let children = fieldListToExprs(a, &r.fields[..]);
            if r.params.len > 0 {
                let generics = sexpr::list(a, "generics", nodeListToExprs(a, &r.params[..]));
                return sexpr::block(a, "record", &[toExpr(a, r.name), generics], children);
            }
            return sexpr::block(a, "record", &[toExpr(a, r.name)], children);
        }
        case super::NodeValue::RecordField { field, type, value } => {
            return fieldToExpr(a, field, type, value);
        }
        case super::NodeValue::UnionDecl(u_) => {
            let children = variantListToExprs(a, &u_.variants[..]);
            if u_.params.len > 0 {
                let generics = sexpr::list(a, "generics", nodeListToExprs(a, &u_.params[..]));
                return sexpr::block(a, "union", &[toExpr(a, u_.name), generics], children);
            }
            return sexpr::block(a, "union", &[toExpr(a, u_.name)], children);
        }
        case super::NodeValue::UnionDeclVariant(v) => {
            return variantToExpr(a, v.name, v.type);
        }
        case super::NodeValue::ExprStmt(e) => return toExpr(a, e),
        case super::NodeValue::GenericParam(param) => {
            match param {
                case super::GenericParam::Type { name, bounds } => {
                    let boundExpr = sexpr::list(a, "bounds", nodeListToExprs(a, &bounds[..]));
                    return sexpr::list(a, "type-param", &[toExpr(a, name), boundExpr]);
                }
                case super::GenericParam::Const { name, type } =>
                    return sexpr::list(a, "const-param", &[toExpr(a, name), toExpr(a, type)]),
            }
        }
        case super::NodeValue::Instantiate(applications) =>
            return sexpr::list(a, "instantiate", nodeListToExprs(a, &applications[..])),
        case super::NodeValue::TraitDecl { name, supertraits, methods, .. } => {
            let children = nodeListToExprs(a, &methods[..]);
            let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits[..]));
            return sexpr::block(a, "trait", &[toExpr(a, name), supers], children);
        }

lib/std/lang/lower.rad +938 -176

//!       ↓
//!   il::DataValue
//!       ↓
//!   il::Data
//!
/// Unit tests for lowering.
@test mod tests;

use std::fmt;
use std::io;
use std::lang::alloc;
use std::lang::types;
use std::mem;

    UnknownIntrinsic,
    /// Allocation failure.
    AllocationFailed,
}

/// Incrementally build deterministic internal symbol names.
record NameBuilder {
    /// Accumulated name bytes.
    bytes: *mut [u8],
    /// Allocator used to grow the name.
    allocator: alloc::Allocator,
}

/// Print a LowerError for debugging.
export fn printError(err: LowerError) {
    match err {
        case LowerError::MissingSymbol(_) => io::print("MissingSymbol"),
        case LowerError::MissingType(_) => io::print("MissingType"),

    Accumulate(*mut [*il::Fn]),
    /// Send lowered functions to an external consumer immediately.
    Stream(FnSink),
}

/// Module-level lowering context. Shared across all function lowerings.
/// Holds global state like the data section (strings, constants) and provides
/// access to the resolver for type queries.
/// Module-level lowering context shared across all function lowerings.
///
/// The resolver is immutable in this phase. Lowering owns its structural type
/// substitutions and all emitted IL, data, and symbol-name allocations.
export record Lowerer {
    /// Arena for persistent lowering state, including data and symbol names.
    arena: *mut alloc::Arena,
    /// Arena for allocations owned by the function currently being lowered.
    fnArena: *mut alloc::Arena,
    /// Allocator backed by the arena.
    /// Allocator backed by the persistent lowering arena.
    allocator: alloc::Allocator,
    /// Resolver for type information. Used to query types, symbols, and
    /// compile-time constant values during lowering.
    /// Fully resolved semantic metadata queried without mutation.
    resolver: *resolver::Resolver,
    /// Module graph for cross-module symbol resolution.
    moduleGraph: ?*module::ModuleGraph,
    /// Package name for qualified symbol names.
    pkgName: *[u8],
    /// Current module being lowered.
    currentMod: ?u16,
    /// Rigid-to-concrete mapping for the function currently being lowered.
    specialization: ?*resolver::Substitution,
    /// Concrete generic function whose body is currently being lowered.
    genericSpecialization: ?*resolver::GenericFnSpecialization,
    /// Global data items (string literals, constants, static arrays).
    /// These become the data sections in the final binary.
    data: *mut [il::Data],
    /// Destination for lowered functions.
    output: FnOutput,
    /// Map of function symbols to qualified names.
    fnSyms: *mut [FnSymEntry],
    /// Global error type tag table. Maps nominal types to unique tags.
    /// Global error tag table keyed by persistent concrete types.
    errTags: *mut [ErrTagEntry],
    /// Next error tag to assign (starts at 1; 0 = success).
    errTagCounter: u32,
    /// Lowering options.
    options: LowerOptions,

record FnSymEntry {
    sym: *resolver::Symbol,
    qualName: *[u8],
}

/// Entry mapping a local data symbol to its qualified lowering-owned name.
record DataSymEntry {
    /// Resolver symbol identifying the declaration.
    sym: *resolver::Symbol,
    /// Function-local qualified data name.
    qualName: *[u8],
}

/// Entry in the global error tag table.
record ErrTagEntry {
    /// The type of this error, identified by its interned pointer.
    /// Persistent concrete error type.
    ty: resolver::Type,
    /// The globally unique tag assigned to this error type (non-zero).
    tag: u32,
}


        }
    }
    return maxSize;
}

/// Get or assign a globally unique error tag for the given error type.
/// Tag `0` is reserved for success; error tags start at `1`.
fn getOrAssignErrorTag(self: *mut Lowerer, errType: resolver::Type) -> u32 {
/// Allocate one persistent structural type component.
fn allocPersistentType(
    self: *mut Lowerer,
    ty: resolver::Type,
) -> *resolver::Type {
    let stored = try! alloc::alloc(
        self.arena,
        @sizeOf(resolver::Type),
        @alignOf(resolver::Type),
    ) as *mut resolver::Type;
    set *stored = ty;
    return stored;
}

/// Copy a concrete structural type into persistent lowering storage.
///
/// Nominal pointers retain their canonical identity; only structural
/// components that may live in the function arena are copied.
fn persistStructuralType(
    self: *mut Lowerer,
    ty: resolver::Type,
) -> resolver::Type {
    match ty {
        case resolver::Type::Pointer(pointer) => {
            let target = persistStructuralType(self, *pointer.target);
            return resolver::Type::Pointer(resolver::PointerType {
                class: pointer.class,
                target: allocPersistentType(self, target),
                mutable: pointer.mutable,
            });
        }
        case resolver::Type::Slice(slice) => {
            let item = persistStructuralType(self, *slice.item);
            return resolver::Type::Slice(resolver::SliceType {
                class: slice.class,
                item: allocPersistentType(self, item),
                mutable: slice.mutable,
            });
        }
        case resolver::Type::Array(array) => {
            let item = persistStructuralType(self, *array.item);
            return resolver::Type::Array(resolver::ArrayType {
                item: allocPersistentType(self, item),
                length: array.length,
            });
        }
        case resolver::Type::Optional(inner) => {
            let stored = persistStructuralType(self, *inner);
            return resolver::Type::Optional(allocPersistentType(self, stored));
        }
        case resolver::Type::Fn(info) => {
            let mut params: *mut [*resolver::Type] = &mut [];
            let mut throwList: *mut [*resolver::Type] = &mut [];
            for param in info.paramTypes {
                let stored = persistStructuralType(self, *param);
                params.append(allocPersistentType(self, stored), self.allocator);
            }
            for thrown in info.throwList {
                let stored = persistStructuralType(self, *thrown);
                throwList.append(
                    allocPersistentType(self, stored), self.allocator
                );
            }
            let returnType = persistStructuralType(self, *info.returnType);
            let storedInfo = try! alloc::alloc(
                self.arena,
                @sizeOf(resolver::FnType),
                @alignOf(resolver::FnType),
            ) as *mut resolver::FnType;
            set *storedInfo = resolver::FnType {
                paramTypes: &params[..],
                returnType: allocPersistentType(self, returnType),
                throwList: &throwList[..],
                isUnsafe: info.isUnsafe,
                localCount: info.localCount,
            };
            return resolver::Type::Fn(storedInfo);
        }
        case resolver::Type::Range { start, end } => {
            let mut storedStart: ?*resolver::Type = nil;
            let mut storedEnd: ?*resolver::Type = nil;
            if let value = start {
                let stored = persistStructuralType(self, *value);
                set storedStart = allocPersistentType(self, stored);
            }
            if let value = end {
                let stored = persistStructuralType(self, *value);
                set storedEnd = allocPersistentType(self, stored);
            }
            return resolver::Type::Range {
                start: storedStart,
                end: storedEnd,
            };
        }
        else => return ty,
    }
}

/// Get or assign a globally unique tag for a concrete error type.
fn getOrAssignErrorTag(
    self: *mut Lowerer,
    errType: resolver::Type,
) -> u32 {
    assert not resolver::containsGenericParameter(errType);
    for entry in self.errTags {
        if entry.ty == errType {
        if resolver::typesEqual(entry.ty, errType) {
            return entry.tag;
        }
    }
    let tag = self.errTagCounter;

    set self.errTagCounter += 1;
    self.errTags.append(ErrTagEntry { ty: errType, tag }, self.allocator);

    self.errTags.append(ErrTagEntry {
        ty: persistStructuralType(self, errType),
        tag,
    }, self.allocator);
    return tag;
}

/// Emit one function to the active output.
fn emitFunction(self: *mut Lowerer, func: *il::Fn, role: FnRole) {

    allocator: alloc::Allocator,
    /// Type signature of the function being lowered.
    fnType: *resolver::FnType,
    /// Function name, used as prefix for generated data symbols.
    fnName: *[u8],
    /// Names assigned to data declarations in this function.
    dataSyms: *mut [DataSymEntry],

    // ~ SSA variable tracking ~ //

    /// Metadata (name, type, mutability) for each variable. Indexed by variable
    /// id. Doesn't change after declaration. For the SSA value of a variable in

// Module Lowering Entry Point //
/////////////////////////////////

/// Lower a complete module AST to an IL program.
///
/// This is the main entry point for the lowering pass. It:
/// 1. Counts functions to preallocate the output array.
/// 2. Iterates over top-level declarations, lowering each.
/// 3. Returns the complete IL program with functions and data section.
///
/// The resolver must have already processed the AST -- we rely on its type
/// annotations, symbol table, and constant evaluations.
/// The resolver must have completed semantic analysis and generic
/// specialization before this phase. Lowering treats all resolver metadata as
/// immutable and allocates emitted state exclusively from `arena`.
export fn lower(
    res: *resolver::Resolver,
    root: *ast::Node,
    pkgName: *[u8],
    arena: *mut alloc::Arena

        allocator: alloc::arenaAllocator(arena),
        resolver: res,
        moduleGraph: nil,
        pkgName,
        currentMod: nil,
        specialization: nil,
        genericSpecialization: nil,
        data: &mut [],
        output: FnOutput::Accumulate(&mut []),
        fnSyms: &mut [],
        errTags: &mut [],
        errTagCounter: 1,


/////////////////////////////////
// Multi-Module Lowering API   //
/////////////////////////////////

/// Create a lowerer for multi-module compilation.
/// Create a multi-module lowerer over fully resolved immutable metadata.
export fn lowerer(
    res: *resolver::Resolver,
    graph: *module::ModuleGraph,
    pkgName: *[u8],
    arena: *mut alloc::Arena,

        allocator: alloc::arenaAllocator(arena),
        resolver: res,
        moduleGraph: graph,
        pkgName,
        currentMod: nil,
        specialization: nil,
        genericSpecialization: nil,
        data: &mut [],
        output: FnOutput::Accumulate(&mut []),
        fnSyms: &mut [],
        errTags: &mut [],
        errTagCounter: 1,

    let stmtsList = block.statements;

    for node in stmtsList {
        match node.value {
            case ast::NodeValue::FnDecl(decl) => {
                // Generic declarations are templates, not emitted functions.
                if decl.params.len > 0 {
                    continue;
                }
                if let f = try lowerFnDecl(low, node, decl) {
                    let role = lowerFnRole(isRoot, decl.attrs);
                    emitFunction(low, f, role);
                }
            }
            case ast::NodeValue::ConstDecl(decl) => {
                try lowerDataDecl(low, node, decl.value, true);
                try lowerDataDecl(low, node, decl.value, true, nil);
            }
            case ast::NodeValue::StaticDecl(decl) => {
                try lowerDataDecl(low, node, decl.value, false);
                try lowerDataDecl(low, node, decl.value, false, nil);
            }
            case ast::NodeValue::InstanceDecl { traitName, targetType, methods } => {
                try lowerInstanceDecl(low, node, traitName, targetType, methods);
            }
            case ast::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, .. } => {

                }
            }
            else => {},
        }
    }
    try lowerGenericFnSpecializations(low);
}

/// Lower explicit generic function roots owned by the current module.
fn lowerGenericFnSpecializations(low: *mut Lowerer) throws (LowerError) {
    let mut cursor = resolver::genericFnSpecializations(low.resolver);
    while let specialization = cursor {
        let templateSym = specialization.template;
        if low.moduleGraph <> nil and templateSym.moduleId <> low.currentMod {
            set cursor = specialization.next;
            continue;
        }
        let case ast::NodeValue::FnDecl(decl) = templateSym.node.value else {
            throw LowerError::ExpectedFunction;
        };
        if not shouldLowerFn(&decl, low.options.buildTest) {
            set cursor = specialization.next;
            continue;
        }
        let template = resolver::genericTemplateFor(low.resolver, templateSym)
            else throw LowerError::MissingMetadata;
        let sub = resolver::Substitution {
            params: template.params,
            args: specialization.args,
        };
        let symbolicFnType = template.signature
            else throw LowerError::MissingMetadata;
        let mut concreteFnType = *specialization.fnType;
        set concreteFnType.localCount = symbolicFnType.localCount;
        set low.genericSpecialization = specialization;
        set low.specialization = &sub;
        let name = specializationName(low, specialization);
        let func = try lowerConcreteFn(
            low,
            templateSym.node,
            decl,
            &concreteFnType,
            name,
            false,
        ) catch e {
            set low.genericSpecialization = nil;
            set low.specialization = nil;
            throw e;
        };
        set low.genericSpecialization = nil;
        set low.specialization = nil;
        emitFunction(low, func, FnRole::Normal);
        set cursor = specialization.next;
    }
}

/// Finalize lowering and return the unified IL program.
export fn finalize(low: *Lowerer) -> il::Program {
    let mut fns: *mut [*il::Fn] = undefined;

        return name;
    }
    return il::formatQualifiedName(self.arena, path, name);
}

/// Append bytes to a symbol name.
fn namePush(builder: *mut NameBuilder, text: *[u8]) {
    for byte in text {
        builder.bytes.append(byte, builder.allocator);
    }
}

/// Append a decimal `u32` to a symbol name.
fn namePushU32(builder: *mut NameBuilder, value: u32) {
    let mut digits: [u8; 10] = undefined;
    namePush(builder, fmt::formatU32(value, &mut digits[..]));
}

/// Append a decimal `u64` to a symbol name.
fn namePushU64(builder: *mut NameBuilder, value: u64) {
    let mut digits: [u8; 20] = undefined;
    namePush(builder, fmt::formatU64(value, &mut digits[..]));
}

/// Append the stable, source-qualified name of a module-level declaration.
fn namePushQualified(
    self: *mut Lowerer,
    builder: *mut NameBuilder,
    modId: ?u16,
    name: *[u8],
) {
    let path = getModulePath(self, modId);
    if path.len == 0 or path[0] <> self.pkgName {
        namePush(builder, self.pkgName);
        namePush(builder, "::");
    }
    for segment in path {
        namePush(builder, segment);
        namePush(builder, "::");
    }
    namePush(builder, name);
}

/// Append a trait's qualified name.
fn namePushTrait(
    self: *mut Lowerer,
    builder: *mut NameBuilder,
    traitInfo: *resolver::TraitType,
) {
    namePushQualified(self, builder, traitInfo.moduleId, traitInfo.name);
}

/// Append a canonical resolved type using Radiance source syntax.
fn namePushType(
    self: *mut Lowerer,
    builder: *mut NameBuilder,
    ty: resolver::Type,
) {
    match ty {
        case resolver::Type::Void => namePush(builder, "void"),
        case resolver::Type::Opaque => namePush(builder, "opaque"),
        case resolver::Type::Never => namePush(builder, "!"),
        case resolver::Type::Bool => namePush(builder, "bool"),
        case resolver::Type::U8 => namePush(builder, "u8"),
        case resolver::Type::U16 => namePush(builder, "u16"),
        case resolver::Type::U32 => namePush(builder, "u32"),
        case resolver::Type::U64 => namePush(builder, "u64"),
        case resolver::Type::I8 => namePush(builder, "i8"),
        case resolver::Type::I16 => namePush(builder, "i16"),
        case resolver::Type::I32 => namePush(builder, "i32"),
        case resolver::Type::I64 => namePush(builder, "i64"),
        case resolver::Type::Pointer(pointer) => {
            match pointer.class {
                case types::PointerClass::Owned => namePush(builder, "*"),
                case types::PointerClass::Ref => namePush(builder, "&"),
                case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
            }
            if pointer.mutable { namePush(builder, "mut "); }
            namePushType(self, builder, *pointer.target);
        }
        case resolver::Type::Slice(slice) => {
            match slice.class {
                case types::PointerClass::Owned => namePush(builder, "*"),
                case types::PointerClass::Ref => namePush(builder, "&"),
                case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
            }
            if slice.mutable { namePush(builder, "mut "); }
            namePush(builder, "[");
            namePushType(self, builder, *slice.item);
            namePush(builder, "]");
        }
        case resolver::Type::Array(array) => {
            namePush(builder, "[");
            namePushType(self, builder, *array.item);
            namePush(builder, "; ");
            namePushU32(builder, array.length);
            namePush(builder, "]");
        }
        case resolver::Type::ConstArgument { value, .. } => {
            if value.negative { namePush(builder, "-"); }
            namePushU64(builder, value.magnitude);
        }
        case resolver::Type::Optional(inner) => {
            namePush(builder, "?");
            namePushType(self, builder, *inner);
        }
        case resolver::Type::Fn(info) => {
            if info.isUnsafe { namePush(builder, "unsafe "); }
            namePush(builder, "fn(");
            for param, i in info.paramTypes {
                if i > 0 { namePush(builder, ", "); }
                namePushType(self, builder, *param);
            }
            namePush(builder, ") -> ");
            namePushType(self, builder, *info.returnType);
            if info.throwList.len > 0 {
                namePush(builder, " throws ");
                for thrown, i in info.throwList {
                    if i > 0 { namePush(builder, ", "); }
                    namePushType(self, builder, *thrown);
                }
            }
        }
        case resolver::Type::Nominal(nominal) => {
            if let data = resolver::genericDataSpecializationForNominal(
                self.resolver, nominal
            ) {
                namePushQualified(
                    self, builder, data.template.moduleId, data.template.name
                );
                namePush(builder, "⟨");
                for arg, i in data.args {
                    if i > 0 { namePush(builder, ", "); }
                    namePushType(self, builder, *arg);
                }
                namePush(builder, "⟩");
                return;
            }
            if let sym = resolver::symbolForNominal(self.resolver, nominal) {
                namePushQualified(self, builder, sym.moduleId, sym.name);
                return;
            }
            match *nominal {
                case resolver::NominalType::Record(recordType) => {
                    namePush(builder, "{ ");
                    for field, i in recordType.fields {
                        if i > 0 { namePush(builder, ", "); }
                        if let name = field.name {
                            namePush(builder, name);
                            namePush(builder, ": ");
                        }
                        namePushType(self, builder, field.fieldType);
                    }
                    namePush(builder, " }");
                }
                case resolver::NominalType::Union(_) =>
                    panic "namePushType: anonymous union has no source identity",
                case resolver::NominalType::Placeholder(_) =>
                    panic "namePushType: unresolved nominal type",
            }
        }
        case resolver::Type::TraitObject(object) => {
            match object.class {
                case types::PointerClass::Owned => namePush(builder, "*"),
                case types::PointerClass::Ref => namePush(builder, "&"),
                case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
            }
            if object.mutable { namePush(builder, "mut "); }
            namePush(builder, "opaque ");
            namePushTrait(self, builder, object.traitInfo);
        }
        else => panic "namePushType: non-concrete type",
    }
}

/// Build a readable specialization name from source identity and canonical arguments.
fn specializationName(
    self: *mut Lowerer,
    specialization: *resolver::GenericFnSpecialization,
) -> *[u8] {
    let template = specialization.template;
    let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
    namePushQualified(self, &mut builder, template.moduleId, template.name);
    namePush(&mut builder, "⟨");
    for arg, i in specialization.args {
        if i > 0 { namePush(&mut builder, ", "); }
        namePushType(self, &mut builder, *arg);
    }
    namePush(&mut builder, "⟩");
    return &builder.bytes[..];
}

/// Register a function symbol with its qualified name.
/// Called when lowering function declarations, so cross-package calls can find
/// the function by name.
fn registerFnSym(self: *mut Lowerer, sym: *resolver::Symbol, qualName: *[u8]) {
    self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);

        }
    }
    return nil;
}

/// Register a local data symbol with its lowering-owned qualified name.
fn registerDataSym(
    self: *mut FnLowerer,
    sym: *resolver::Symbol,
    qualName: *[u8],
) {
    self.dataSyms.append(DataSymEntry { sym, qualName }, self.allocator);
}

/// Look up the current function's most recently registered local data name.
fn lookupDataSym(self: *FnLowerer, sym: *resolver::Symbol) -> ?*[u8] {
    let mut i = self.dataSyms.len;
    while i > 0 {
        set i -= 1;
        let entry = &self.dataSyms[i];
        if entry.sym == sym {
            return entry.qualName;
        }
    }
    return nil;
}

/// Set the package context for lowering.
/// Called before lowering each package.
export fn setPackage(self: *mut Lowerer, graph: *module::ModuleGraph, pkgName: *[u8]) {
    set self.moduleGraph = graph;
    set self.pkgName = pkgName;

    let mut fnLow = FnLowerer {
        low: self,
        allocator: alloc::arenaAllocator(self.fnArena),
        fnType: fnType,
        fnName: qualName,
        dataSyms: &mut [],
        vars: &mut [],
        params: &mut [],
        blockData: &mut [],
        entryBlock: nil,
        currentBlock: nil,


    // Register function symbol for cross-package call resolution.
    if let sym = data.sym {
        registerFnSym(self, sym, qualName);
    }
    let mut fnLow = fnLowerer(self, node, fnType, qualName);
    return try lowerConcreteFn(self, node, decl, fnType, qualName, isExtern);
}

    // If the function returns an aggregate or is throwing, prepend a hidden
    // return parameter. The caller allocates the buffer and passes it
    // as the first argument; the callee writes the return value into it.
/// Lower one already-concrete function signature through the shared body path.
fn lowerConcreteFn(
    self: *mut Lowerer,
    node: *ast::Node,
    decl: ast::FnDecl,
    fnType: *resolver::FnType,
    qualName: *[u8],
    isExtern: bool,
) -> *il::Fn throws (LowerError) {
    let mut fnLow = fnLowerer(self, node, fnType, qualName);
    if requiresReturnParam(fnType) and not isExtern {
        set fnLow.returnReg = nextReg(&mut fnLow);
    }
    let lowParams = try lowerParams(&mut fnLow, *fnType, decl.sig.params, nil);
    let func = try! alloc::alloc(self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *mut il::Fn;

    let func = try! alloc::alloc(
        self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)
    ) as *mut il::Fn;
    set *func = il::Fn {
        name: qualName,
        params: lowParams,
        returnType: undefined,
        isExtern,
        isLeaf: true,
        blocks: &[],
    };
    // Throwing functions return a result aggregate (word-sized pointer).
    // TODO: The resolver should set an appropriate type that takes into account
    //       the throws list. It shouldn't set the return type to the "success"
    //       value only.
    if fnType.throwList.len > 0 {
        set func.returnType = il::Type::W64;
    } else {
        set func.returnType = ilType(self, *fnType.returnType);
    }
    let body = decl.body else {
        // Extern functions have no body.
        assert isExtern;
        return func;
    };
    set func.blocks = try lowerFnBody(&mut fnLow, body);
    set func.isLeaf = fnLow.isLeaf;

    return func;
}

/// Build a qualified name of the form "Type::method".
fn instanceMethodName(self: *mut Lowerer, modId: ?u16, typeName: *[u8], methodName: *[u8]) -> *[u8] {
    let sepLen: u32 = 2; // "::"
    let totalLen = typeName.len + sepLen + methodName.len;
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
    let mut pos: u32 = 0;

    set pos += try! mem::copy(&mut buf[pos..], typeName);
    set pos += try! mem::copy(&mut buf[pos..], "::");
    set pos += try! mem::copy(&mut buf[pos..], methodName);
    assert pos == totalLen;

    return qualifyName(self, modId, &buf[..totalLen]);
}

/// Build a v-table data name of the form "vtable::Type::Trait".
fn vtableName(self: *mut Lowerer, modId: ?u16, typeName: *[u8], traitName: *[u8]) -> *[u8] {
    let prefix = "vtable::";
    let sepLen: u32 = 2; // "::"
    let totalLen = prefix.len + typeName.len + sepLen + traitName.len;
    let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
    let mut pos: u32 = 0;

    set pos += try! mem::copy(&mut buf[pos..], prefix);
    set pos += try! mem::copy(&mut buf[pos..], typeName);
    set pos += try! mem::copy(&mut buf[pos..], "::");
    set pos += try! mem::copy(&mut buf[pos..], traitName);
    assert pos == totalLen;

    return qualifyName(self, modId, &buf[..totalLen]);
/// Build a readable method name from its concrete type, trait, and source name.
fn instanceMethodName(
    self: *mut Lowerer,
    concreteType: resolver::Type,
    traitInfo: ?*resolver::TraitType,
    methodName: *[u8],
) -> *[u8] {
    let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
    namePushType(self, &mut builder, concreteType);
    if let traitValue = traitInfo {
        namePush(&mut builder, " ");
        namePushTrait(self, &mut builder, traitValue);
    }
    namePush(&mut builder, "::");
    namePush(&mut builder, methodName);
    return &builder.bytes[..];
}

/// Build a readable v-table name from its concrete type and trait.
fn vtableName(
    self: *mut Lowerer,
    concreteType: resolver::Type,
    traitInfo: *resolver::TraitType,
) -> *[u8] {
    let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
    namePush(&mut builder, "vtable::");
    namePushType(self, &mut builder, concreteType);
    namePush(&mut builder, " ");
    namePushTrait(self, &mut builder, traitInfo);
    return &builder.bytes[..];
}

/// Lower an instance declaration (`instance Trait for Type { ... }`).
///
/// Each method in the instance block is lowered as a standalone function
/// with a qualified name of the form `Type::method`. A read-only v-table
/// data record is emitted containing pointers to these functions, ordered
/// by the trait's method indices. The v-table is later referenced when
/// with a qualified name containing both concrete and declaring-trait
/// identities. A read-only v-table data record points to these functions,
/// ordered by the trait's method indices. The v-table is later referenced when
/// constructing trait objects for dynamic dispatch.
fn lowerInstanceDecl(
    self: *mut Lowerer,
    node: *ast::Node,
    traitNameNode: *ast::Node,
    targetTypeNode: *ast::Node,
    methods: *mut [*ast::Node]
) throws (LowerError) {
    // Look up the trait and type from the resolver.
    // Look up the trait and concrete instance from resolver metadata.
    let traitSym = resolver::nodeData(self.resolver, traitNameNode).sym
        else throw LowerError::MissingSymbol(traitNameNode);
    let case resolver::SymbolData::Trait(traitInfo) = traitSym.data
        else throw LowerError::MissingMetadata;
    let typeSym = resolver::nodeData(self.resolver, targetTypeNode).sym
        else throw LowerError::MissingSymbol(targetTypeNode);

    let tName = traitSym.name;
    let typeName = typeSym.name;
    let concreteType = resolver::typeFor(self.resolver, targetTypeNode)
        else throw LowerError::MissingType(targetTypeNode);
    let instEntry = resolver::findInstance(self.resolver, traitInfo, concreteType)
        else throw LowerError::MissingMetadata;

    // Lower each instance method as a regular function.
    // Collect qualified names for the v-table. Empty entries are filled
    // later from inherited supertrait methods.
    let mut methodNames: [*[u8]; ast::MAX_TRAIT_METHODS] = undefined;

        } = methodNode.value else continue;

        let case ast::NodeValue::Ident(mName) = name.value else {
            throw LowerError::ExpectedIdentifier;
        };
        let qualName = instanceMethodName(self, nil, typeName, mName);
        let method = resolver::findTraitMethod(traitInfo, mName)
            else panic "lowerInstanceDecl: method not found in trait";
        let qualName = instanceMethodName(
            self, instEntry.concreteType, method.owner, mName
        );
        let func = try lowerMethod(self, methodNode, qualName, receiverName, sig, body)
            else continue;
        emitFunction(self, func, FnRole::Normal);

        let method = resolver::findTraitMethod(traitInfo, mName)
            else panic "lowerInstanceDecl: method not found in trait";

        set methodNames[method.index] = qualName;
        set methodNameSet[method.index] = true;
    }

    // Fill inherited method slots from supertraits.
    // These methods were already lowered as part of the supertrait instance
    // declarations and use the same `Type::method` qualified name.
    // Fill inherited method slots from their declaring supertraits. Their
    // declaring-trait identity selects the already lowered implementation.
    for method, i in traitInfo.methods {
        if not methodNameSet[i] {
            set methodNames[i] = instanceMethodName(self, nil, typeName, method.name);
            let inheritedInst = resolver::findInstance(
                self.resolver, method.owner, instEntry.concreteType
            ) else throw LowerError::MissingMetadata;
            set methodNames[i] = instanceMethodName(
                self,
                inheritedInst.concreteType,
                method.owner,
                method.name,
            );
        }
    }

    // Create v-table in data section, used for dynamic dispatch.
    let vName = vtableName(self, nil, typeName, tName);
    let vName = vtableName(self, instEntry.concreteType, traitInfo);
    let values = try! alloc::allocSlice(
        self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), traitInfo.methods.len as u32
    ) as *mut [il::DataValue];

    for i in 0..traitInfo.methods.len {

        else throw LowerError::MissingSymbol(node);
    let case ast::NodeValue::Ident(mName) = name.value
        else throw LowerError::ExpectedIdentifier;
    let me = resolver::findMethodBySymbol(self.resolver, sym)
        else throw LowerError::MissingMetadata;
    let qualName = instanceMethodName(self, nil, me.concreteTypeName, mName);
    let qualName = instanceMethodName(
        self, me.concreteType, nil, mName
    );

    return try lowerMethod(self, node, qualName, receiverName, sig, body);
}

/// Check if a function should be lowered.

        }
        throw LowerError::MissingConst(node);
    };

    if let case resolver::ConstValue::String(s) = val {
        if let case resolver::Type::Slice { .. } = ty {
        if let case resolver::Type::Slice(_) = ty {
            let strSym = try getOrCreateStringData(self, s, dataPrefix);
            dataSliceHeader(b, strSym, s.len);
            return;
        }
    }

/// Lower a constant or static declaration to the data section.
fn lowerDataDecl(
    self: *mut Lowerer,
    node: *ast::Node,
    value: *ast::Node,
    readOnly: bool
    readOnly: bool,
    localName: ?*[u8],
) throws (LowerError) {
    let data = resolver::nodeData(self.resolver, node);
    let sym = data.sym else {
        throw LowerError::MissingSymbol(node);
    };
    if data.ty == resolver::Type::Unknown {
        throw LowerError::MissingType(node);
    }
    let layout = resolver::getTypeLayout(data.ty);
    let qualName = qualifyName(self, nil, sym.name);
    let mut qualName: *[u8] = undefined;
    if let name = localName {
        set qualName = name;
    } else {
        set qualName = qualifyName(self, nil, sym.name);
    }
    let mut b = dataBuilder(self.allocator);
    try lowerConstDataInto(self, value, data.ty, layout.size, qualName, &mut b);
    let result = dataBuilderFinish(&b);

    self.data.append(il::Data {

    addr: ast::AddressOf,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
) throws (LowerError) {
    let case resolver::Type::Slice { mutable, .. } = ty
    let case resolver::Type::Slice(slice) = ty
        else throw LowerError::ExpectedSliceOrArray;
    let targetTy = resolver::typeFor(self.resolver, addr.target)
        else throw LowerError::MissingType(addr.target);
    let case resolver::Type::Array(arrInfo) = targetTy
        else throw LowerError::ExpectedArray;

    let mut nested = dataBuilder(self.allocator);
    let layout = resolver::getTypeLayout(targetTy);
    try lowerConstDataInto(self, addr.target, targetTy, layout.size, dataPrefix, &mut nested);

    let backing = dataBuilderFinish(&nested);
    let readOnly = not mutable;
    let readOnly = not slice.mutable;
    let mut dataName: *[u8] = undefined;
    if readOnly {
        if let found = findConstData(self, backing.values, layout.alignment) {
            set dataName = found;
        } else {

    set self.dataCounter += 1;
    return try nextDeclDataName(self.low, self.fnName, counter, "literal");
}

/// Assign a unique function-local data symbol name.
fn registerLocalDataDeclName(self: *mut FnLowerer, node: *ast::Node) throws (LowerError) {
fn registerLocalDataDeclName(
    self: *mut FnLowerer,
    node: *ast::Node,
) -> *[u8] throws (LowerError) {
    let sym = resolver::nodeData(self.low.resolver, node).sym
        else throw LowerError::MissingSymbol(node);

    let prefix = self.fnName;
    let segments: *mut [*[u8]] = &mut [prefix, "nominal", sym.name];
    let name = try buildSegmentedName(self.low, segments);

    set sym.name = name;
    let localName = try buildSegmentedName(self.low, segments);
    let modId = resolver::moduleIdForSymbol(self.low.resolver, sym);
    let qualName = qualifyName(self.low, modId, localName);
    registerDataSym(self, sym, qualName);
    return qualName;
}

/// Get the next available SSA register.
fn nextReg(self: *mut FnLowerer) -> il::Reg {
    let reg = il::Reg { n: self.regCounter };
    set self.regCounter += 1;
    return reg;
}

/// Allocate a structural type component in the current function arena.
fn allocSpecializedType(
    self: *mut FnLowerer,
    ty: resolver::Type,
) -> *resolver::Type {
    let value = try! alloc::alloc(
        self.low.fnArena,
        @sizeOf(resolver::Type),
        @alignOf(resolver::Type),
    ) as *mut resolver::Type;
    set *value = ty;
    return value;
}

/// Apply the current generic function specialization without mutating resolver
/// metadata or allocating from resolver-owned arenas.
fn specializeType(
    self: *mut FnLowerer,
    ty: resolver::Type,
) -> resolver::Type throws (LowerError) {
    let sub = self.low.specialization else return ty;
    if not resolver::containsGenericParameter(ty) {
        return ty;
    }
    match ty {
        case resolver::Type::Parameter(param) =>
            return resolver::substitutionArg(sub, param),
        case resolver::Type::ConstParameter(param) =>
            return resolver::substitutionArg(sub, param),
        case resolver::Type::GenericConstExpr { type, expr } => {
            let value = resolver::constIntWithSubstitution(
                self.low.resolver, expr, *type, sub
            ) else throw LowerError::MissingMetadata;
            return resolver::Type::ConstArgument { type, value };
        }
        case resolver::Type::Pointer(pointer) => {
            let target = try specializeType(self, *pointer.target);
            return resolver::Type::Pointer(resolver::PointerType {
                class: pointer.class,
                target: allocSpecializedType(self, target),
                mutable: pointer.mutable,
            });
        }
        case resolver::Type::Slice(slice) => {
            let item = try specializeType(self, *slice.item);
            return resolver::Type::Slice(resolver::SliceType {
                class: slice.class,
                item: allocSpecializedType(self, item),
                mutable: slice.mutable,
            });
        }
        case resolver::Type::Array(array) => {
            let item = try specializeType(self, *array.item);
            return resolver::Type::Array(resolver::ArrayType {
                item: allocSpecializedType(self, item),
                length: array.length,
            });
        }
        case resolver::Type::GenericArray { item, length } => {
            let concreteItem = try specializeType(self, *item);
            let value = resolver::constIntWithSubstitution(
                self.low.resolver, length, resolver::Type::U32, sub
            ) else throw LowerError::MissingMetadata;
            return resolver::Type::Array(resolver::ArrayType {
                item: allocSpecializedType(self, concreteItem),
                length: value.magnitude as u32,
            });
        }
        case resolver::Type::Optional(inner) => {
            let value = try specializeType(self, *inner);
            return resolver::Type::Optional(allocSpecializedType(self, value));
        }
        case resolver::Type::GenericDataApply(app) => {
            let mut args: *mut [*resolver::Type] = &mut [];
            for arg in app.args {
                let concrete = try specializeType(self, *arg);
                if resolver::containsGenericParameter(concrete) {
                    throw LowerError::MissingMetadata;
                }
                args.append(allocSpecializedType(self, concrete), self.allocator);
            }
            let specialization = resolver::findGenericDataSpecialization(
                self.low.resolver, app.template, &args[..]
            ) else throw LowerError::MissingMetadata;
            return resolver::Type::Nominal(specialization.nominal);
        }
        case resolver::Type::GenericRecord(genericRecord) => {
            let mut fields: *mut [resolver::RecordField] = &mut [];
            let mut offset: u32 = 0;
            let mut alignment: u32 = 1;
            for field in genericRecord.fields {
                let fieldType = try specializeType(self, field.fieldType);
                if resolver::containsGenericParameter(fieldType) {
                    throw LowerError::MissingMetadata;
                }
                let fieldLayout = resolver::getTypeLayout(fieldType);
                set offset = mem::alignUp(offset, fieldLayout.alignment);
                fields.append(resolver::RecordField {
                    name: field.name,
                    fieldType: persistStructuralType(self.low, fieldType),
                    offset: offset as i32,
                }, self.low.allocator);
                set offset += fieldLayout.size;
                if fieldLayout.alignment > alignment {
                    set alignment = fieldLayout.alignment;
                }
            }
            let nominal = try! alloc::alloc(
                self.low.arena,
                @sizeOf(resolver::NominalType),
                @alignOf(resolver::NominalType),
            ) as *mut resolver::NominalType;
            set *nominal = resolver::NominalType::Record(resolver::RecordType {
                fields: &fields[..],
                labeled: genericRecord.labeled,
                layout: resolver::Layout {
                    size: mem::alignUp(offset, alignment),
                    alignment,
                },
                declaredLinear: false,
            });
            return resolver::Type::Nominal(nominal);
        }
        case resolver::Type::Fn(info) => {
            let mut params: *mut [*resolver::Type] = &mut [];
            let mut throwTypes: *mut [*resolver::Type] = &mut [];
            for param in info.paramTypes {
                let concrete = try specializeType(self, *param);
                params.append(allocSpecializedType(self, concrete), self.allocator);
            }
            for thrown in info.throwList {
                let concrete = try specializeType(self, *thrown);
                throwTypes.append(
                    allocSpecializedType(self, concrete), self.allocator
                );
            }
            let result = try specializeType(self, *info.returnType);
            let fnType = try! alloc::alloc(
                self.low.fnArena,
                @sizeOf(resolver::FnType),
                @alignOf(resolver::FnType),
            ) as *mut resolver::FnType;
            set *fnType = resolver::FnType {
                paramTypes: &params[..],
                returnType: allocSpecializedType(self, result),
                throwList: &throwTypes[..],
                isUnsafe: info.isUnsafe,
                localCount: info.localCount,
            };
            return resolver::Type::Fn(fnType);
        }
        case resolver::Type::Range { start, end } => {
            let mut concreteStart: ?*resolver::Type = nil;
            let mut concreteEnd: ?*resolver::Type = nil;
            if let value = start {
                let concrete = try specializeType(self, *value);
                set concreteStart = allocSpecializedType(self, concrete);
            }
            if let value = end {
                let concrete = try specializeType(self, *value);
                set concreteEnd = allocSpecializedType(self, concrete);
            }
            return resolver::Type::Range {
                start: concreteStart,
                end: concreteEnd,
            };
        }
        else => return ty,
    }
}

/// Look up the resolved type of an AST node, or throw `MissingType`.
fn typeOf(self: *mut FnLowerer, node: *ast::Node) -> resolver::Type throws (LowerError) {
    let ty = resolver::typeFor(self.low.resolver, node)
        else throw LowerError::MissingType(node);
    return ty;
    return try specializeType(self, ty);
}

/// Look up the symbol for an AST node, or throw `MissingSymbol`.
fn symOf(self: *mut FnLowerer, node: *ast::Node) -> *mut resolver::Symbol throws (LowerError) {
    let sym = resolver::nodeData(self.low.resolver, node).sym

}

/// Emit a copy instruction that loads a data symbol's address into a register.
fn emitDataAddr(self: *mut FnLowerer, sym: *resolver::Symbol) -> il::Reg {
    let dst = nextReg(self);
    let modId = resolver::moduleIdForSymbol(self.low.resolver, sym);
    let qualName = qualifyName(self.low, modId, sym.name);
    let mut qualName: *[u8] = undefined;
    if let localName = lookupDataSym(self, sym) {
        set qualName = localName;
    } else {
        let modId = resolver::moduleIdForSymbol(self.low.resolver, sym);
        set qualName = qualifyName(self.low, modId, sym.name);
    }

    emit(self, il::Instr::Copy { dst, val: il::Val::DataSym(qualName) });

    return dst;
}

/// For null-ptr-optimized types, loads the data pointer, or returns it
/// directly for scalar pointers. For aggregates, returns the tag register.
fn optionalNilReg(self: *mut FnLowerer, val: il::Val, typ: resolver::Type) -> il::Reg throws (LowerError) {
    let reg = emitValToReg(self, val);

    match typ {
        case resolver::Type::Optional(resolver::Type::Slice { .. }) => {
    if let case resolver::Type::Optional(inner) = typ {
        if let case resolver::Type::Slice(_) = *inner {
            let ptrReg = nextReg(self);
            emitLoadW64At(self, ptrReg, reg, SLICE_PTR_OFFSET);
            return ptrReg;
        }
        case resolver::Type::Optional(resolver::Type::Pointer { .. }) => return reg,
        case resolver::Type::Optional(_) => return tvalTagReg(self, reg),
        else => return reg,
        if let case resolver::Type::Pointer(_) = *inner {
            return reg;
        }
        return tvalTagReg(self, reg);
    }
    return reg;
}

/// Lower an optional nil check (`opt == nil` or `opt <> nil`).
fn lowerNilCheck(self: *mut FnLowerer, opt: *ast::Node, isEq: bool) -> il::Val throws (LowerError) {
    let optTy = try typeOf(self, opt);

            }
            // Plain nested record destructuring pattern.
            // Auto-deref: if the field is a pointer, load it first.
            let mut derefType = fieldInfo.fieldType;
            let mut nestedBase = emitPtrOffset(self, base, fieldInfo.offset);
            if let case resolver::Type::Pointer { target, .. } = fieldInfo.fieldType {
            if let case resolver::Type::Pointer(pointer) = fieldInfo.fieldType {
                let ptrReg = nextReg(self);
                emitLoadW64At(self, ptrReg, nestedBase, 0);
                set nestedBase = ptrReg;
                set derefType = *target;
                set derefType = *pointer.target;
            }
            let recInfo = resolver::getRecord(derefType)
                else throw LowerError::ExpectedRecord;

            try bindNestedRecordFields(self, nestedBase, lit, recInfo, matchBy, failBlock);


    // Auto-deref: when the field is a pointer and the pattern destructures
    // the pointed-to value, load the pointer and use the target type.
    // The loaded pointer becomes the base address for the nested subject.
    let mut derefBase: ?il::Reg = nil;
    if let case resolver::Type::Pointer { target, .. } = fieldType {
    if let case resolver::Type::Pointer(pointer) = fieldType {
        if resolver::isDestructuringPattern(pattern) {
            let ptrReg = nextReg(self);
            emitLoadW64At(self, ptrReg, fieldPtr, 0);
            set derefBase = ptrReg;
            set fieldType = *target;
            set fieldType = *pointer.target;
        }
    }
    // Build a MatchSubject for the nested field.
    let ilTy = ilType(self.low, fieldType);
    let kind = matchSubjectKind(fieldType);

        case ast::NodeValue::Let(l) => {
            try lowerLet(self, node, l);
        }
        case ast::NodeValue::ConstDecl(decl) => {
            // Local constants lower to data declarations and emit no runtime code.
            try registerLocalDataDeclName(self, node);
            try lowerDataDecl(self.low, node, decl.value, true);
            let qualName = try registerLocalDataDeclName(self, node);
            try lowerDataDecl(self.low, node, decl.value, true, qualName);
        }
        case ast::NodeValue::StaticDecl(decl) => {
            // Local statics lower to data declarations and emit no runtime code.
            try registerLocalDataDeclName(self, node);
            try lowerDataDecl(self.low, node, decl.value, false);
            let qualName = try registerLocalDataDeclName(self, node);
            try lowerDataDecl(self.low, node, decl.value, false, qualName);
        }
        case ast::NodeValue::If(i) => {
            try lowerIf(self, i);
        }
        case ast::NodeValue::IfLet(i) => {

/// choosing how to compare or store that value.
fn effectiveType(self: *mut FnLowerer, node: *ast::Node) -> resolver::Type throws (LowerError) {
    let ty = try typeOf(self, node);
    if let coerce = resolver::coercionFor(self.low.resolver, node) {
        if let case resolver::Coercion::OptionalLift(optTy) = coerce {
            return optTy;
            return try specializeType(self, optTy);
        }
    }
    return ty;
}

/// Check if a resolver type lowers to an aggregate in memory.
fn isAggregateType(typ: resolver::Type) -> bool {
    match typ {
        case resolver::Type::Slice { .. },
             resolver::Type::TraitObject { .. } => return true,
        case resolver::Type::Optional(resolver::Type::Pointer { .. }) => {
        case resolver::Type::Optional(resolver::Type::Pointer(_)) => {
            // Optional pointers are scalar due to NPO.
            return false;
        }
        case resolver::Type::Optional(_) => {
            // All other optionals, including optional slices, are aggregates.

        }
        case resolver::Type::Nominal(_) => {
            // Void unions are small enough to pass by value.
            return not resolver::isVoidUnion(typ);
        }
        case resolver::Type::Array(_),
        case resolver::Type::Slice(_),
             resolver::Type::TraitObject(_),
             resolver::Type::Array(_),
             resolver::Type::Nil => return true,
        else => return false,
    }
}


/// For optional pointers (`?*T`), returns an immediate `0` (null pointer).
/// For other optionals, builds a tagged aggregate with tag set to `0` (absent).
fn buildNilOptional(self: *mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {
    let case resolver::Type::Optional(inner) = optType
        else throw LowerError::ExpectedOptional;
    if let case resolver::Type::Pointer { .. } = *inner {
    if let case resolver::Type::Pointer(_) = *inner {
        return il::Val::Imm(0);
    }
    if let case resolver::Type::Slice { item, mutable, .. } = *inner {
    if let case resolver::Type::Slice(slice) = *inner {
        return try buildSliceValue(
            self, item, mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
            self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
        );
    }
    let valOffset = resolver::getOptionalValOffset(*inner) as i32;
    return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);
}

    mutable: bool,
    ptrVal: il::Val,
    lenVal: il::Val,
    capVal: il::Val
) -> il::Val throws (LowerError) {
    let sliceType = resolver::Type::Slice {
    let sliceType = resolver::Type::Slice(resolver::SliceType {
        class: types::PointerClass::Unsafe,
        item: elemTy,
        mutable,
    };
    });
    let dst = try emitReserve(self, sliceType);
    let ptrTy = resolver::Type::Pointer {
    let ptrTy = resolver::Type::Pointer(resolver::PointerType {
        class: types::PointerClass::Unsafe,
        target: elemTy,
        mutable,
    };
    });

    try emitStore(self, dst, SLICE_PTR_OFFSET, ptrTy, ptrVal);
    try emitStore(self, dst, SLICE_LEN_OFFSET, resolver::Type::U32, lenVal);
    try emitStore(self, dst, SLICE_CAP_OFFSET, resolver::Type::U32, capVal);


    self: *mut FnLowerer,
    dataVal: il::Val,
    traitInfo: *resolver::TraitType,
    inst: *resolver::InstanceEntry
) -> il::Val throws (LowerError) {
    let vName = vtableName(self.low, inst.moduleId, inst.concreteTypeName, traitInfo.name);
    let vName = vtableName(
        self.low, inst.concreteType, traitInfo
    );

    // Reserve space for the trait object on the stack.
    let slot = emitReserveLayout(self, resolver::Layout {
        size: resolver::PTR_SIZE * 2,
        alignment: resolver::PTR_SIZE,

    mutable: bool,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
    let ptrTy = resolver::Type::Pointer {
    let ptrTy = resolver::Type::Pointer(resolver::PointerType {
        class: types::PointerClass::Unsafe,
        target: elemTy,
        mutable,
    };
    });
    let ptrEq = try emitEqAtOffset(self, a, b, offset + SLICE_PTR_OFFSET, ptrTy);
    let lenEq = try emitEqAtOffset(self, a, b, offset + SLICE_LEN_OFFSET, resolver::Type::U32);

    return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, ptrEq, lenEq);
}

    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
    match typ {
        case resolver::Type::Slice { item, mutable, .. } =>
            return try lowerSliceEq(self, item, mutable, a, b, offset),
        case resolver::Type::Slice(slice) =>
            return try lowerSliceEq(self, slice.item, slice.mutable, a, b, offset),
        case resolver::Type::Optional(inner) => {
            if let case resolver::Type::Slice { item, mutable, .. } = *inner {
            if let case resolver::Type::Slice(slice) = *inner {
                // Optional slices use null pointer optimization.
                return try lowerSliceEq(self, item, mutable, a, b, offset);
                return try lowerSliceEq(self, slice.item, slice.mutable, a, b, offset);
            }
            return try lowerOptionalEq(self, *inner, a, b, offset);
        }
        case resolver::Type::Array(arr) =>
            return try lowerArrayEq(self, arr, a, b, offset),

    range: ast::Range,
    info: resolver::SliceRangeInfo
) -> SliceRangeResult throws (LowerError) {
    let baseVal = try lowerExpr(self, container);
    let baseReg = emitValToReg(self, baseVal);
    let itemType = try specializeType(self, *info.itemType);

    // Extract data pointer and container length.
    let mut dataReg = baseReg;
    let mut containerLen: il::Val = undefined;
    if let cap = info.capacity { // Slice from array.

    // Only compute range offset and count if the start value is not
    // statically known to be zero.
    if startVal <> il::Val::Imm(0) {
        // Offset the data pointer by the start value.
        set dataReg = emitElem(
            self, resolver::getTypeLayout(*info.itemType).size, dataReg, startVal
            self, resolver::getTypeLayout(itemType).size, dataReg, startVal
        );
        // Compute the count as `end - start`.
        let lenReg = nextReg(self);
        emit(self, il::Instr::BinOp {
            op: il::BinOp::Sub,

) -> il::Val throws (LowerError) {
    let info = resolver::sliceRangeInfoFor(self.low.resolver, sliceNode) else {
        throw LowerError::MissingMetadata;
    };
    let r = try resolveSliceRangePtr(self, container, range, info);
    let itemType = try specializeType(self, *info.itemType);
    return try buildSliceValue(
        self, info.itemType, info.mutable, il::Val::Reg(r.dataReg), r.count, r.count
        self, &itemType, info.mutable, il::Val::Reg(r.dataReg), r.count, r.count
    );
}

/// Lower an address-of (`&x`) expression.
fn lowerAddressOf(self: *mut FnLowerer, node: *ast::Node, addr: ast::AddressOf) -> il::Val throws (LowerError) {

    self: *mut FnLowerer,
    sliceNode: *ast::Node,
    arrayNode: *ast::Node
) -> il::Val throws (LowerError) {
    let sliceTy = try typeOf(self, sliceNode);
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy else {
    let case resolver::Type::Slice(slice) = sliceTy else {
        throw LowerError::UnexpectedType(&sliceTy);
    };
    let arrayTy = try typeOf(self, arrayNode);
    let case resolver::Type::Array(arrayInfo) = arrayTy else {
        throw LowerError::ExpectedArray;
    };
    let length = arrayInfo.length;
    if length == 0 {
        return try buildSliceValue(
            self, item, mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
            self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
        );
    }
    if resolver::isConstExpr(self.low.resolver, arrayNode) {
        let mut b = dataBuilder(self.low.allocator);
        match arrayNode.value {

            case ast::NodeValue::ArrayRepeatLit(repeat) =>
                try lowerConstArrayRepeatInto(self.low, repeat, arrayTy, self.fnName, &mut b),
            else => throw LowerError::UnexpectedNodeValue(arrayNode),
        }
        let result = dataBuilderFinish(&b);
        let alignment = resolver::getTypeLayout(*item).alignment;
        let alignment = resolver::getTypeLayout(*slice.item).alignment;
        return try lowerConstDataAsSlice(
            self, result.values, alignment, not mutable,
            item, mutable, length
            self, result.values, alignment, not slice.mutable,
            slice.item, slice.mutable, length
        );
    }
    let data = try lowerExpr(self, arrayNode);
    let count = il::Val::Imm(length as i64);
    return try buildSliceValue(self, item, mutable, data, count, count);
    return try buildSliceValue(self, slice.item, slice.mutable, data, count, count);
}

/// Lower the common element pointer computation for subscript operations.
/// Handles both arrays and slices by resolving the container type, extracting
/// the data pointer (for slices), and emitting an [`il::Instr::Elem`] to compute


    let mut dataReg = baseReg;
    let mut elemType: resolver::Type = undefined;

    match subjectTy {
        case resolver::Type::Slice { item, .. } => {
            set elemType = *item;
        case resolver::Type::Slice(slice) => {
            set elemType = *slice.item;
            let sliceLen = loadSliceLen(self, baseReg);
            // Runtime safety check: index must be strictly less than slice length.
            try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, sliceLen);

            set dataReg = loadSlicePtr(self, baseReg);

    container: *ast::Node,
    range: ast::Range,
    info: resolver::SliceRangeInfo
) throws (LowerError) {
    let r = try resolveSliceRangePtr(self, container, range, info);
    let elemSize = resolver::getTypeLayout(*info.itemType).size;
    let itemType = try specializeType(self, *info.itemType);
    let elemSize = resolver::getTypeLayout(itemType).size;
    let rhsTy = try typeOf(self, rhs);

    if let case resolver::Type::Slice { .. } = rhsTy {
    if let case resolver::Type::Slice(_) = rhsTy {
        // Copy from source slice.
        let srcReg = emitValToReg(self, try lowerExpr(self, rhs));
        let srcData = loadSlicePtr(self, srcReg);
        let srcLen = loadSliceLen(self, srcReg);


        );
        try emitByteCopyLoop(self, r.dataReg, srcData, bytes, "copy");
    } else {
        // Fill with scalar value.
        let fillVal = try lowerExpr(self, rhs);
        try emitFillLoop(self, r.dataReg, fillVal, r.count, *info.itemType, elemSize);
        try emitFillLoop(self, r.dataReg, fillVal, r.count, itemType, elemSize);
    }
}

/// Emit a typed fill loop: `for i in 0..count { dst[i * stride] = value; }`.
fn emitFillLoop(

    match info {
        case resolver::ForLoopInfo::Range { valType, range, bindingName, indexName } => {
            let endExpr = range.end else {
                throw LowerError::MissingMetadata;
            };
            let concreteValType = try specializeType(self, *valType);
            let mut startVal = il::Val::Imm(0);
            if let start = range.start {
                set startVal = try lowerExpr(self, start);
            }
            let endVal = try lowerExpr(self, endExpr);
            let iterType = ilType(self.low, *valType);
            let iterType = ilType(self.low, concreteValType);
            let valVar = newVar(self, bindingName, iterType, false, startVal);

            let mut indexVar: ?Var = nil;
            if indexName <> nil { // Optional index always starts at zero.
                set indexVar = newVar(self, indexName, il::Type::W32, false, il::Val::Imm(0));
            if indexName <> nil {
                set indexVar = newVar(
                    self, indexName, il::Type::W32, false, il::Val::Imm(0)
                );
            }
            let iter = ForIter::Range {
                valVar, indexVar, endVal, valType: iterType,
                unsigned: isUnsignedType(*valType),
                valVar,
                indexVar,
                endVal,
                valType: iterType,
                unsigned: isUnsignedType(concreteValType),
            };

            try lowerForLoop(self, &iter, f.body);
        }
        case resolver::ForLoopInfo::Collection { elemType, length, bindingName, indexName } => {
            let concreteElemType = try specializeType(self, *elemType);
            let containerVal = try lowerExpr(self, f.iterable);
            let containerReg = emitValToReg(self, containerVal);

            let mut dataReg = containerReg;
            let mut lengthVal: il::Val = undefined;
            if let len = length { // Array (length is known).
            if let len = length {
                set lengthVal = il::Val::Imm(len as i64);
            } else { // Slice (length must be loaded).
            } else {
                set lengthVal = loadSliceLen(self, containerReg);
                set dataReg = loadSlicePtr(self, containerReg);
            }
            // Declare index value binidng.
            let idxVar = newVar(self, indexName, il::Type::W32, false, il::Val::Imm(0));

            // Declare element value binding.
            let idxVar = newVar(
                self, indexName, il::Type::W32, false, il::Val::Imm(0)
            );
            let mut valVar: ?Var = nil;
            if bindingName <> nil {
                set valVar = newVar(
                    self,
                    bindingName,
                    ilType(self.low, *elemType),
                    ilType(self.low, concreteElemType),
                    false,
                    il::Val::Undef
                    il::Val::Undef,
                );
            }
            let iter = ForIter::Collection { valVar, idxVar, dataReg, lengthVal, elemType };

            let iter = ForIter::Collection {
                valVar,
                idxVar,
                dataReg,
                lengthVal,
                elemType: &concreteElemType,
            };
            try lowerForLoop(self, &iter, f.body);
        }
    }
    exitVarScope(self, savedVarsLen);
}

/// String literals are stored as global data and the result is a slice
/// pointing to the data with the appropriate length.
fn lowerStringLit(self: *mut FnLowerer, node: *ast::Node, s: *[u8]) -> il::Val throws (LowerError) {
    // Get the slice type from the node.
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy
    let case resolver::Type::Slice(slice) = sliceTy
        else throw LowerError::ExpectedSliceOrArray;
    // Build the string data value.
    let ptr = try! alloc::alloc(
        self.low.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue)
    ) as *mut il::DataValue;

    set *ptr = il::DataValue { item: il::DataItem::Str(s), count: 1 };

    return try lowerConstDataAsSlice(
        self, @sliceOf(ptr, 1), 1, true, item, mutable, s.len
        self, @sliceOf(ptr, 1), 1, true, slice.item, slice.mutable, s.len
    );
}

/// Lower a builtin call expression.
fn lowerBuiltinCall(self: *mut FnLowerer, node: *ast::Node, kind: ast::Builtin, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {

fn lowerSliceOf(self: *mut FnLowerer, node: *ast::Node, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    if args.len <> 2 and args.len <> 3 {
        throw LowerError::InvalidArgCount;
    }
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice { item, mutable, .. } = sliceTy
    let case resolver::Type::Slice(slice) = sliceTy
        else throw LowerError::ExpectedSliceOrArray;
    let ptrVal = try lowerExpr(self, args[0]);
    let lenVal = try lowerExpr(self, args[1]);
    let mut capVal = lenVal;
    if args.len == 3 {
        set capVal = try lowerExpr(self, args[2]);
    }
    if not isLtEq(lenVal, capVal) {
        try emitTrapIfLt(self, il::Type::W32, capVal, lenVal);
    }
    return try buildSliceValue(self, item, mutable, ptrVal, lenVal, capVal);
    return try buildSliceValue(self, slice.item, slice.mutable, ptrVal, lenVal, capVal);
}

/// Lower a `try` expression.
fn lowerTry(self: *mut FnLowerer, node: *ast::Node, t: ast::Try) -> il::Val throws (LowerError) {
    let case ast::NodeValue::Call(callExpr) = t.expr.value else {

    let callNodeExtra = resolver::nodeData(self.low.resolver, t.expr).extra;
    if let case resolver::NodeExtra::TraitMethodCall {
        traitInfo, methodIndex
    } = callNodeExtra {
        set resVal = try lowerTraitMethodCall(self, t.expr, callExpr, traitInfo, methodIndex);
    } else if let case resolver::NodeExtra::GenericBoundMethodCall {
        param, traitInfo, methodIndex, explicitReceiver,
    } = callNodeExtra {
        set resVal = try lowerGenericBoundMethodCall(
            self, t.expr, callExpr, param, traitInfo, methodIndex, explicitReceiver
        );
    } else if let case resolver::NodeExtra::MethodCall { method } = callNodeExtra {
        set resVal = try lowerMethodCall(self, t.expr, callExpr, method);
    } else {
        set resVal = try lowerCall(self, t.expr, callExpr);
    }

fn lowerCallOrCtor(self: *mut FnLowerer, node: *ast::Node, call: ast::Call) -> il::Val throws (LowerError) {
    let nodeData = resolver::nodeData(self.low.resolver, node).extra;

    // Check for slice method dispatch.
    if let case resolver::NodeExtra::SliceAppend { elemType } = nodeData {
        return try lowerSliceAppend(self, call, elemType);
        let concrete = try specializeType(self, *elemType);
        return try lowerSliceAppend(self, call, &concrete);
    }
    if let case resolver::NodeExtra::SliceDelete { elemType } = nodeData {
        try lowerSliceDelete(self, call, elemType);
        let concrete = try specializeType(self, *elemType);
        try lowerSliceDelete(self, call, &concrete);
        return il::Val::Undef;
    }
    // Check for trait method dispatch.
    if let case resolver::NodeExtra::TraitMethodCall { traitInfo, methodIndex } = nodeData {
        return try lowerTraitMethodCall(self, node, call, traitInfo, methodIndex);
    }
    if let case resolver::NodeExtra::GenericBoundMethodCall {
        param, traitInfo, methodIndex, explicitReceiver,
    } = nodeData {
        return try lowerGenericBoundMethodCall(
            self, node, call, param, traitInfo, methodIndex, explicitReceiver
        );
    }
    // Check for standalone method call.
    if let case resolver::NodeExtra::MethodCall { method } = nodeData {
        return try lowerMethodCall(self, node, call, method);
    }
    if let sym = resolver::nodeData(self.low.resolver, call.callee).sym {

/// If the parent is already a pointer type, the value is used directly.
/// If the parent is a value type (eg. a local record), its address is taken.
fn lowerReceiver(self: *mut FnLowerer, parent: *ast::Node, parentTy: resolver::Type) -> il::Val
    throws (LowerError)
{
    if let case resolver::Type::Pointer { .. } = parentTy {
    if let case resolver::Type::Pointer(_) = parentTy {
        // Already a pointer: lower and use directly.
        return try lowerExpr(self, parent);
    }
    // Value type: take its address by lowering it and returning the slot pointer.
    // Aggregate types are already lowered as pointers to stack slots.

    try emitStore(self, slot, 0, parentTy, val);

    return il::Val::Reg(slot);
}

/// Lower a bounded generic method to its concrete instance function.
fn lowerGenericBoundMethodCall(
    self: *mut FnLowerer,
    node: *ast::Node,
    call: ast::Call,
    param: *resolver::GenericParamType,
    traitInfo: *resolver::TraitType,
    methodIndex: u32,
    explicitReceiver: bool,
) -> il::Val throws (LowerError) {
    let mut receiverNode: *ast::Node = undefined;
    if explicitReceiver {
        if call.args.len == 0 {
            throw LowerError::MissingMetadata;
        }
        set receiverNode = call.args[0];
    } else {
        let case ast::NodeValue::FieldAccess(access) = call.callee.value
            else throw LowerError::MissingMetadata;
        set receiverNode = access.parent;
    }
    let concreteType = try specializeType(self, resolver::Type::Parameter(param));
    let inst = resolver::findInstance(
        self.low.resolver, traitInfo, concreteType
    ) else throw LowerError::MissingMetadata;
    let method = &traitInfo.methods[methodIndex];
    let _ = resolver::findInstance(
        self.low.resolver, method.owner, concreteType
    ) else throw LowerError::MissingMetadata;
    let methodSym = inst.methods[methodIndex];
    let case resolver::SymbolData::Value {
        type: resolver::Type::Fn(fnInfo), ..
    } = methodSym.data else throw LowerError::MissingMetadata;
    let mut receiverVal: il::Val = undefined;
    if explicitReceiver {
        set receiverVal = try lowerCallArg(self, receiverNode, call.args.len > 1);
    } else {
        let receiverType = try typeOf(self, receiverNode);
        set receiverVal = try lowerReceiver(self, receiverNode, receiverType);
    }
    let qualName = instanceMethodName(
        self.low,
        concreteType,
        method.owner,
        method.name,
    );
    let argOffset: u32 = 1 if requiresReturnParam(fnInfo) else 0;
    let receiverCount: u32 = 0 if explicitReceiver else 1;
    let args = try allocVals(self, call.args.len + receiverCount + argOffset);
    set args[argOffset] = receiverVal;
    for arg, i in call.args {
        if explicitReceiver and i == 0 {
            continue;
        }
        set args[i + receiverCount + argOffset] = try lowerCallArg(
            self, arg, i + 1 < call.args.len
        );
    }
    return try emitCallValue(self, il::Val::FnAddr(qualName), fnInfo, args);
}

/// Lower a standalone method call via direct dispatch.
///
/// Given `obj.method(args)` where `method` is a standalone method on a concrete type,
/// emits a direct call with the receiver address as the first argument:
///


    // Get the receiver as a pointer.
    let parentTy = try typeOf(self, access.parent);
    let receiverVal = try lowerReceiver(self, access.parent, parentTy);

    let qualName = instanceMethodName(self.low, nil, method.concreteTypeName, method.name);
    let case resolver::SymbolData::Value { type: resolver::Type::Fn(fnInfo), .. } = method.symbol.data
        else panic "lowerMethodCall: expected Fn type on method symbol";
    let qualName = instanceMethodName(
        self.low, method.concreteType, nil, method.name
    );

    // Build args: optional return param slot + receiver + user args.
    let argOffset: u32 = 1 if requiresReturnParam(fnInfo) else 0;
    let args = try allocVals(self, call.args.len + 1 + argOffset);
    set args[argOffset] = receiverVal;


/// Resolve callee to an IL value. For direct function calls, use the symbol name.
/// For variables holding function pointers or complex expressions (eg. `array[i]()`),
/// lower the callee expression.
fn lowerCallee(self: *mut FnLowerer, callee: *ast::Node) -> il::Val throws (LowerError) {
    if let generic = try lowerGenericFnValue(self, callee) {
        return generic;
    }
    if let sym = resolver::nodeData(self.low.resolver, callee).sym {
        if let case ast::NodeValue::FnDecl(_) = sym.node.value {
            // First try to look up the symbol in our registered functions.
            // This handles cross-package calls correctly, since packages are
            // lowered in dependency order.

    let coerce = resolver::coercionFor(self.low.resolver, node) else {
        return val;
    };
    match coerce {
        case resolver::Coercion::OptionalLift(optType) => {
            let concrete = try specializeType(self, optType);
            if let case ast::NodeValue::Nil = node.value {
                return try buildNilOptional(self, optType);
                return try buildNilOptional(self, concrete);
            }
            return try wrapInOptional(self, val, optType);
            return try wrapInOptional(self, val, concrete);
        }
        case resolver::Coercion::NumericCast { from, to } => {
            return lowerNumericCast(self, val, from, to);
            return lowerNumericCast(
                self,
                val,
                try specializeType(self, from),
                try specializeType(self, to),
            );
        }
        case resolver::Coercion::ResultWrap => {
            let payloadType = *self.fnType.returnType;
            return try buildResult(self, 0, val, payloadType);
        }

        else =>
            throw LowerError::UnexpectedNodeValue(node),
    }
}

/// Lower a rigid constant parameter using the active specialization.
fn lowerGenericConstValue(
    self: *mut FnLowerer,
    node: *ast::Node,
) -> ?il::Val {
    let sub = self.low.specialization else return nil;
    let sym = resolver::symbolFor(self.low.resolver, node) else return nil;
    let case resolver::SymbolData::ConstParameter(param) = sym.data else return nil;
    let arg = resolver::substitutionArg(sub, param);
    let case resolver::Type::ConstArgument { value, .. } = arg else return nil;
    return il::Val::Imm(constIntToI64(value));
}

/// Lower resolver-selected generic function metadata to a concrete address.
fn lowerGenericFnValue(
    self: *mut FnLowerer,
    node: *ast::Node,
) -> ?il::Val throws (LowerError) {
    let data = resolver::nodeData(self.low.resolver, node);
    match data.extra {
        case resolver::NodeExtra::GenericFnCall(specialization) => {
            return il::Val::FnAddr(
                specializationName(self.low, specialization)
            );
        }
        case resolver::NodeExtra::GenericFnDependency(dependency) => {
            let caller = self.low.genericSpecialization
                else throw LowerError::MissingMetadata;
            let specialization = resolver::genericFnSpecializationForDependency(
                self.low.resolver, dependency, caller
            ) else throw LowerError::MissingMetadata;
            return il::Val::FnAddr(
                specializationName(self.low, specialization)
            );
        }
        else => return nil,
    }
}

/// Lower an expression AST node to an IL value.
/// This is the main expression dispatch, all expression nodes go through here.
fn lowerExpr(self: *mut FnLowerer, node: *ast::Node) -> il::Val throws (LowerError) {
    if self.low.options.debug {
        set self.srcLoc.offset = node.span.offset;
    }
    let mut val: il::Val = undefined;

    match node.value {
        case ast::NodeValue::Ident(_) => {
            // First try local variable lookup.
            // Otherwise fall back to global symbol lookup.
            if let v = lookupLocalVar(self, node) {
            if let constVal = lowerGenericConstValue(self, node) {
                set val = constVal;
            } else if let generic = try lowerGenericFnValue(self, node) {
                set val = generic;
            // First try local variable lookup, then global symbol lookup.
            } else if let v = lookupLocalVar(self, node) {
                set val = try useVar(self, v);
                if self.vars[*v].addressTaken {
                    let typ = try typeOf(self, node);
                    let ptr = emitValToReg(self, val);
                    set val = emitRead(self, ptr, 0, typ);

            } else {
                set val = try lowerGlobalSymbol(self, node);
            }
        }
        case ast::NodeValue::ScopeAccess(_) => {
            set val = try lowerScopeAccess(self, node);
            if let generic = try lowerGenericFnValue(self, node) {
                set val = generic;
            } else {
                set val = try lowerScopeAccess(self, node);
            }
        }
        case ast::NodeValue::Number(lit) => {
            set val = il::Val::Imm(lit.magnitude as i64);
        }
        case ast::NodeValue::Bool(b) => {

            set val = try lowerUnOp(self, node, unop);
        }
        case ast::NodeValue::Subscript { container, index } => {
            set val = try lowerSubscript(self, node, container, index);
        }
        case ast::NodeValue::GenericApply(_) => {
            let generic = try lowerGenericFnValue(self, node)
                else panic "lowerExpr: unresolved generic application";
            set val = generic;
        }
        case ast::NodeValue::BuiltinCall { kind, args } => {
            set val = try lowerBuiltinCall(self, node, kind, args);
        }
        case ast::NodeValue::Call(call) => {
            set val = try lowerCallOrCtor(self, node, call);

                    //       Perhaps just store the `ConstInt`.
                    case resolver::ConstValue::Int(i) => set val = il::Val::Imm(constIntToI64(i)),
                    else => set val = try lowerFieldAccess(self, access),
                }
            } else {
                set val = try lowerFieldAccess(self, access);
                let parentTy = try typeOf(self, access.parent);
                let mut handled = false;
                if let case resolver::Type::Array(array) = parentTy {
                    if let case ast::NodeValue::Ident(name) = access.child.value;
                       mem::eq(name, "len")
                    {
                        set val = il::Val::Imm(array.length as i64);
                        set handled = true;
                    }
                }
                if not handled {
                    set val = try lowerFieldAccess(self, access);
                }
            }
        }
        case ast::NodeValue::ArrayLit(elements) => {
            set val = try lowerArrayLit(self, node, elements);
        }

            let _ = expr;
            set val = il::Val::Undef;
        }
        // Lower these as statements.
        case ast::NodeValue::ConstDecl(decl) => {
            try registerLocalDataDeclName(self, node);
            try lowerDataDecl(self.low, node, decl.value, true);
            let qualName = try registerLocalDataDeclName(self, node);
            try lowerDataDecl(self.low, node, decl.value, true, qualName);
            set val = il::Val::Undef;
        }
        case ast::NodeValue::StaticDecl(decl) => {
            try registerLocalDataDeclName(self, node);
            try lowerDataDecl(self.low, node, decl.value, false);
            let qualName = try registerLocalDataDeclName(self, node);
            try lowerDataDecl(self.low, node, decl.value, false, qualName);
            set val = il::Val::Undef;
        }
        case ast::NodeValue::Throw { .. },
             ast::NodeValue::Return { .. },
             ast::NodeValue::Continue,

             resolver::Type::U16 => return il::Type::W16,
        case resolver::Type::I32,
             resolver::Type::U32 => return il::Type::W32,
        case resolver::Type::I64,
             resolver::Type::U64,
             resolver::Type::Pointer { .. },
             resolver::Type::Slice { .. },
             resolver::Type::TraitObject { .. },
             resolver::Type::Pointer(_),
             resolver::Type::Slice(_),
             resolver::Type::TraitObject(_),
             resolver::Type::Array(_),
             resolver::Type::Optional(_),
             resolver::Type::Fn(_) => return il::Type::W64,
        case resolver::Type::Nominal(_) => {
            if resolver::isVoidUnion(typ) {

lib/std/lang/lower/tests.rad added +18 -0

1	+	//! Lowering tests.
2	+
3	+	use std::testing;
4	+	use std::lang::alloc;
5	+	use std::lang::module;
6	+	use std::lang::resolver;
7	+
8	+	/// Verify that a lowerer constructor accepts an immutable resolver pointer.
9	+	@test fn testLowererAcceptsImmutableResolver() throws (testing::TestError) {
10	+	let constructor: fn(
11	+	*resolver::Resolver,
12	+	*module::ModuleGraph,
13	+	*[u8],
14	+	*mut alloc::Arena,
15	+	*mut alloc::Arena,
16	+	super::LowerOptions
17	+	) -> super::Lowerer = super::lowerer;
18	+	}

lib/std/lang/parser.rad +152 -12

    return node(p, ast::NodeValue::CondExpr(
        ast::CondExpr { condition, thenExpr, elseExpr }
    ));
}

/// Return whether a token can begin an unambiguous type argument.
fn isDefiniteTypeStart(kind: scanner::TokenKind) -> bool {
    match kind {
        case scanner::TokenKind::Question,
             scanner::TokenKind::Star,
             scanner::TokenKind::Amp,
             scanner::TokenKind::LBracket,
             scanner::TokenKind::U8,
             scanner::TokenKind::U16,
             scanner::TokenKind::U32,
             scanner::TokenKind::U64,
             scanner::TokenKind::I8,
             scanner::TokenKind::I16,
             scanner::TokenKind::I32,
             scanner::TokenKind::I64,
             scanner::TokenKind::Bool,
             scanner::TokenKind::Opaque,
             scanner::TokenKind::Fn => return true,
        else => return false,
    }
}

/// Parse one generic argument. A bare nominal path remains a type because the
/// parser cannot know the template parameter kind yet. If a following operator
/// continues the path as an expression, restore the speculative type parse and
/// retain the whole expression for constant-parameter resolution.
fn parseGenericArg(p: *mut Parser) -> *ast::Node throws (ParseError) {
    if isDefiniteTypeStart(p.current.kind) or
       p.current.kind == scanner::TokenKind::Ident or
       p.current.kind == scanner::TokenKind::Super
    {
        let saved = saveState(p);
        if let arg = try? parseType(p);
           check(p, scanner::TokenKind::Comma) or
           check(p, scanner::TokenKind::RAngle)
        {
            return arg;
        }
        restoreState(p, &saved);
    }
    return try parseNormalExpr(p);
}

/// Parse a non-empty generic argument list.
fn parseGenericArgs(p: *mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    try expect(p, scanner::TokenKind::LAngle, "expected left angle before generic arguments");
    if check(p, scanner::TokenKind::RAngle) {
        throw failParsing(p, "generic argument list cannot be empty");
    }
    let mut args = ast::nodeSlice(p.arena, 4);
    loop {
        args.append(try parseGenericArg(p), p.allocator);
        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
        if check(p, scanner::TokenKind::RAngle) {
            throw failParsing(p, "expected generic argument after `,`");
        }
    }
    try expect(p, scanner::TokenKind::RAngle, "expected right angle after generic arguments");
    return args;
}

/// Parse generic arguments following a target.
fn parseGenericApply(p: *mut Parser, target: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    let args = try parseGenericArgs(p);
    return node(p, ast::NodeValue::GenericApply(ast::GenericApply {
        target, args,
    }));
}

/// Parse array subscript or slice expression after `[`.
fn parseSubscriptOrSlice(p: *mut Parser, container: *ast::Node) -> *ast::Node
    throws (ParseError)
{
    try expect(p, scanner::TokenKind::LBracket, "expected `[`");

                ));
            }
            case scanner::TokenKind::LBracket => {
                set result = try parseSubscriptOrSlice(p, result);
            }
            case scanner::TokenKind::LAngle => {
                set result = try parseGenericApply(p, result);
            }
            case scanner::TokenKind::LParen => {
                set result = try parseCall(p, result);
            }
            case scanner::TokenKind::LBrace if p.context <> Context::Condition => {
                set result = try parseRecordLit(p, result);

        case scanner::TokenKind::Comma,
             scanner::TokenKind::Semicolon,
             scanner::TokenKind::RParen,
             scanner::TokenKind::RBrace,
             scanner::TokenKind::RBracket,
             scanner::TokenKind::RAngle,
             scanner::TokenKind::Else,
             scanner::TokenKind::In,
             scanner::TokenKind::LBrace,
             scanner::TokenKind::Eof =>
            return true,

            return try parseTraitDecl(p, attrs);
        }
        case scanner::TokenKind::Instance => {
            return try parseInstanceDecl(p);
        }
        case scanner::TokenKind::Instantiate => {
            return try parseInstantiate(p);
        }
        else => {
            return try parseExprStmt(p);
        }
    }
}

    try expect(p, terminator, "expected closing delimiter after record fields");

    return fields;
}

/// Parse an optional generic parameter list.
fn parseGenericParams(p: *mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    let mut params = ast::nodeSlice(p.arena, 4);
    if not consume(p, scanner::TokenKind::LAngle) {
        return params;
    }
    if check(p, scanner::TokenKind::RAngle) {
        throw failParsing(p, "generic parameter list cannot be empty");
    }
    loop {
        let isConst = consume(p, scanner::TokenKind::Constant);
        if isConst and consume(p, scanner::TokenKind::Constant) {
            throw failParsing(p, "duplicate `constant` in generic parameter");
        }
        let name = try parseIdent(p, "expected generic parameter name");
        let mut param: *ast::Node = undefined;
        if isConst {
            try expect(p, scanner::TokenKind::Colon, "expected `:` after constant parameter");
            let type = try parseType(p);
            set param = node(p, ast::NodeValue::GenericParam(
                ast::GenericParam::Const { name, type }
            ));
        } else {
            let bounds = try parseDerives(p);
            set param = node(p, ast::NodeValue::GenericParam(
                ast::GenericParam::Type { name, bounds }
            ));
        }
        params.append(param, p.allocator);
        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
        if check(p, scanner::TokenKind::RAngle) {
            throw failParsing(p, "expected generic parameter after `,`");
        }
    }
    try expect(p, scanner::TokenKind::RAngle, "expected right angle after generic parameters");
    return params;
}

/// Parse an optional derives list (`: Trait + Trait`).
fn parseDerives(p: *mut Parser) -> *mut [*ast::Node] throws (ParseError) {
    let mut derives = ast::nodeSlice(p.arena, 4);

    if not consume(p, scanner::TokenKind::Colon) {
        return derives;
    }
    loop {
        let t = try parseIdent(p, "expected trait name in derive list");
        let t = try parseTypePath(p);
        derives.append(t, p.allocator);

        if not consume(p, scanner::TokenKind::Plus) {
            break;
        }

    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Record, "expected `record`");

    let name = try parseIdent(p, "expected record name");
    let params = try parseGenericParams(p);
    let derives = try parseDerives(p);

    if consume(p, scanner::TokenKind::LParen) {
        let fields = try parseRecordFields(p, RecordFieldMode::Unlabeled);
        try expect(p, scanner::TokenKind::Semicolon, "expected `;` after record");
        return node(p, ast::NodeValue::RecordDecl(
            ast::RecordDecl { name, fields, attrs, derives, labeled: false }
            ast::RecordDecl { name, params, fields, attrs, derives, labeled: false }
        ));
    } else {
        try expect(p, scanner::TokenKind::LBrace, "expected `{` before record body");
        let fields = try parseRecordFields(p, RecordFieldMode::Labeled);
        return node(p, ast::NodeValue::RecordDecl(
            ast::RecordDecl { name, fields, attrs, derives, labeled: true }
            ast::RecordDecl { name, params, fields, attrs, derives, labeled: true }
        ));
    }
}

/// Parse a union declaration.

    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Union, "expected `union`");

    let name = try parseIdent(p, "expected union name");
    let params = try parseGenericParams(p);
    let derives = try parseDerives(p);

    try expect(p, scanner::TokenKind::LBrace, "expected `{` before union body");

    let mut variants = ast::nodeSlice(p.arena, 128);

            let fields = try parseRecordFields(p, RecordFieldMode::Labeled);
            set payloadType = node(p, ast::NodeValue::TypeSig(
                ast::TypeSig::Record { fields, labeled: true }
            ));
        } else if consume(p, scanner::TokenKind::Equal) {
            // TODO: Support constant expressions.
            try expect(p, scanner::TokenKind::Number, "expected integer literal after `=`");
            let literal = try parseIntLiteral(p, p.previous.source);
            set explicitValue = nodeNumber(p, literal);
            set explicitValue = try parseNormalExpr(p);
        }

        let variant = node(p, ast::NodeValue::UnionDeclVariant(
            ast::UnionDeclVariant {
                name: variantName, index: variants.len as u32, value: explicitValue, type: payloadType,

        }
    }
    try expect(p, scanner::TokenKind::RBrace, "expected `}`");

    return node(p, ast::NodeValue::UnionDecl(
        ast::UnionDecl { name, variants, attrs, derives }
        ast::UnionDecl { name, params, variants, attrs, derives }
    ));
}

/// Parse a function parameter.
fn parseFnParam(p: *mut Parser) -> *ast::Node

    // Method syntax: `fn (recv: *Type) name(params) { body }`.
    if check(p, scanner::TokenKind::LParen) {
        return try parseMethodDecl(p, attrs);
    }
    let name = try parseIdent(p, "expected function name");
    let params = try parseGenericParams(p);
    let sig = try parseFnTypeSig(p);
    let mut body: ?*ast::Node = nil;
    let mut fnAttrs = attrs;

    if consume(p, scanner::TokenKind::Semicolon) {

        }
    } else {
        set body = try parseBlock(p);
    }
    return node(p, ast::NodeValue::FnDecl(
        ast::FnDecl { name, sig, body, attrs: fnAttrs }
        ast::FnDecl { name, params, sig, body, attrs: fnAttrs }
    ));
}

/// Parse a pointer-like type after its ownership prefix.
fn parsePointerLikeType(

        }
        case scanner::TokenKind::LBracket => {
            return try parseArrayType(p);
        }
        case scanner::TokenKind::Super, scanner::TokenKind::Ident => {
            let path = try parseTypePath(p);

            let mut name = try parseTypePath(p);
            if check(p, scanner::TokenKind::LAngle) {
                set name = try parseGenericApply(p, name);
            }
            return node(p, ast::NodeValue::TypeSig(
                ast::TypeSig::Nominal(path)
                ast::TypeSig::Nominal(name)
            ));
        }
        case scanner::TokenKind::U8 => {
            advance(p);
            return nodeTypeInt(p, 1, ast::Signedness::Unsigned);

        case scanner::TokenKind::RBrace => return "expected `}`",
        else => return "expected delimiter",
    }
}

/// Parse one or more explicit specialization roots.
fn parseInstantiate(p: *mut Parser) -> *ast::Node throws (ParseError) {
    try expect(p, scanner::TokenKind::Instantiate, "expected `instantiate`");
    let mut applications = ast::nodeSlice(p.arena, 4);
    loop {
        let target = try parseTypePath(p);
        if not check(p, scanner::TokenKind::LAngle) {
            throw failParsing(p, "`instantiate` requires a generic application");
        }
        applications.append(try parseGenericApply(p, target), p.allocator);
        if not consume(p, scanner::TokenKind::Comma) {
            break;
        }
    }
    return node(p, ast::NodeValue::Instantiate(applications));
}

/// Parse a trait declaration.
/// Syntax: `trait Name { fn (*Trait) method(...) -> T; ... }`
fn parseTraitDecl(p: *mut Parser, attrs: ?ast::Attributes) -> *ast::Node
    throws (ParseError)
{

    throws (ParseError)
{
    try expect(p, scanner::TokenKind::Instance, "expected `instance`");
    let traitName = try parseTypePath(p);
    try expect(p, scanner::TokenKind::For, "expected `for` after trait name");
    let targetType = try parseTypePath(p);
    let targetType = try parseType(p);
    try expect(p, scanner::TokenKind::LBrace, "expected `{` after target type");

    let mut methods = ast::nodeSlice(p.arena, ast::MAX_TRAIT_METHODS);

    while not check(p, scanner::TokenKind::RBrace) and

lib/std/lang/parser/tests.rad +194 -5

    try super::expect(&mut parser, scanner::TokenKind::Eof, "expected end of statement");

    return root;
}

/// Require a statement to fail with one focused parser diagnostic.
fn expectStmtParseError(input: *[u8], message: *[u8])
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);
    let mut parser = super::mkParser(
        scanner::SourceLoc::String, input, &mut arena, &mut STRING_POOL
    );
    super::advance(&mut parser);
    try super::parseStmt(&mut parser) catch {
        assert parser.errors.count == 1;
        assert mem::eq(parser.errors.list[0].message, message);
        return;
    };
    throw testing::TestError::Failed;
}

/// Parse an expression expected to be a number literal and return its payload.
fn parseNumberLiteral(text: *[u8]) -> fmt::IntLiteral
    throws (testing::TestError)
{
    let mut arena = ast::nodeArena(&mut ARENA_STORAGE[..]);

    let case ast::NodeValue::FnDecl(decl) = node.value
        else throw testing::TestError::Failed;
    let attrs = decl.attrs
        else throw testing::TestError::Failed;

    try testing::expect(attrs.list.len == 1);
    try testing::expect(ast::attributesContains(&attrs, ast::Attribute::Unsafe));
    assert attrs.list.len == 1;
    assert ast::attributesContains(&attrs, ast::Attribute::Unsafe);
}

/// Test rejecting `unsafe` on declarations where it has no semantics.
@test fn testParseUnsafeUnsupportedDecl() throws (testing::TestError) {
    let recordDecl: ?*ast::Node = try? parseStmtStr("unsafe record R {}");
    try testing::expect(recordDecl == nil);
    assert recordDecl == nil;
    let constDecl: ?*ast::Node = try? parseStmtStr("unsafe constant X = 1;");
    try testing::expect(constDecl == nil);
    assert constDecl == nil;
}

/// Test `unsafe` on the other declaration forms that support it.
@test fn testParseUnsafeMethodAndModule() throws (testing::TestError) {
    let moduleNode = try! parseStmtStr("unsafe mod io;");

    let instanceNode = try! parseStmtStr(
        "instance Read for Value { unsafe fn (value: &Value) get() {} }"
    );
    let case ast::NodeValue::InstanceDecl { methods, .. } = instanceNode.value
        else throw testing::TestError::Failed;
    try testing::expect(methods.len == 1);
    assert methods.len == 1;
    let case ast::NodeValue::MethodDecl { attrs, .. } = methods[0].value
        else throw testing::TestError::Failed;
    let methodAttrs = attrs else throw testing::TestError::Failed;
    assert ast::attributesContains(&methodAttrs, ast::Attribute::Unsafe);


    // Throws lists.
    let throwsNode = try! parseStmtStr("fn handle() throws (Error, Other,) {}");
    let case ast::NodeValue::FnDecl(throwsDecl) = throwsNode.value else throw testing::TestError::Failed;
    try testing::expect(throwsDecl.sig.throwList.len == 2);
}

/// Generic declarations retain ordered type, bound, and constant parameters.
@test fn testParseGenericDeclarations() throws (testing::TestError) {
    let recordNode = try! parseStmtStr(
        "record Pair⟨T: Reader + Writer, U⟩ { first: T, second: U }"
    );
    let case ast::NodeValue::RecordDecl(recordDecl) = recordNode.value
        else throw testing::TestError::Failed;
    assert recordDecl.params.len == 2;
    let case ast::NodeValue::GenericParam(ast::GenericParam::Type {
        name: firstName, bounds
    }) = recordDecl.params[0].value else throw testing::TestError::Failed;
    try expectIdent(firstName, "T");
    assert bounds.len == 2;
    try expectIdent(bounds[0], "Reader");
    try expectIdent(bounds[1], "Writer");

    let unionNode = try! parseStmtStr("union Maybe⟨T⟩ { None, Some(T) }");
    let case ast::NodeValue::UnionDecl(unionDecl) = unionNode.value
        else throw testing::TestError::Failed;
    assert unionDecl.params.len == 1;

    let fnNode = try! parseStmtStr("fn first⟨T⟩(value: T) -> T { return value; }");
    let case ast::NodeValue::FnDecl(fnDecl) = fnNode.value
        else throw testing::TestError::Failed;
    assert fnDecl.params.len == 1;

    let constNode = try! parseStmtStr(
        "record InlineVec⟨T, constant N: u32⟩ { data: [T; 4] }"
    );
    let case ast::NodeValue::RecordDecl(constDecl) = constNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericParam(ast::GenericParam::Const {
        name: constName, type: constType
    }) = constDecl.params[1].value else throw testing::TestError::Failed;
    try expectIdent(constName, "N");
    try expectIntType(constType, 4, ast::Signedness::Unsigned);
}

/// Generic applications nest in nominal types and preserve qualified targets.
@test fn testParseGenericTypeApplications() throws (testing::TestError) {
    let node = try! parseTypeStr("Result⟨collections::Vec⟨T⟩, E⟩");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(outerNode)) = node.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(outer) = outerNode.value
        else throw testing::TestError::Failed;
    try expectIdent(outer.target, "Result");
    assert outer.args.len == 2;

    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(innerNode)) =
        outer.args[0].value else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(inner) = innerNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::ScopeAccess(path) = inner.target.value
        else throw testing::TestError::Failed;
    try expectIdent(path.parent, "collections");
    try expectIdent(path.child, "Vec");
    assert inner.args.len == 1;
    try expectTypeIdent(inner.args[0], "T");
    try expectTypeIdent(outer.args[1], "E");

    let constNode = try! parseTypeStr("InlineVec⟨T, N + 1⟩");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(constAppNode)) =
        constNode.value else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(constApp) = constAppNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::BinOp(constExpr) = constApp.args[1].value
        else throw testing::TestError::Failed;
    assert constExpr.op == ast::BinaryOp::Add;
    try expectIdent(constExpr.left, "N");
    try expectNumber(constExpr.right, "1");

    let rangeNode = try! parseTypeStr("Window⟨0..⟩");
    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(rangeAppNode)) =
        rangeNode.value else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(rangeApp) = rangeAppNode.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Range(range) = rangeApp.args[0].value
        else throw testing::TestError::Failed;
    assert range.start <> nil;
    assert range.end == nil;
}

/// Function applications use generic syntax without changing array subscripts.
@test fn testParseGenericFunctionApplications() throws (testing::TestError) {
    let explicit = try! parseExprStr("first⟨i32⟩(value)");
    let case ast::NodeValue::Call(call) = explicit.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(app) = call.callee.value
        else throw testing::TestError::Failed;
    try expectIdent(app.target, "first");
    assert app.args.len == 1;
    try expectIntType(app.args[0], 4, ast::Signedness::Signed);

    let singleSymbolic = try! parseExprStr("first⟨T⟩(value)");
    let case ast::NodeValue::Call(singleCall) = singleSymbolic.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(singleApp) = singleCall.callee.value
        else throw testing::TestError::Failed;
    assert singleApp.args.len == 1;
    try expectTypeIdent(singleApp.args[0], "T");

    let recordExpr = try! parseExprStr("Pair⟨T⟩ { first: value }");
    let case ast::NodeValue::RecordLit(recordLit) = recordExpr.value
        else throw testing::TestError::Failed;
    let recordType = recordLit.typeName else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(recordApp) = recordType.value
        else throw testing::TestError::Failed;
    assert recordApp.args.len == 1;

    let indexedCall = try! parseExprStr("callbacks[*index](value)");
    let case ast::NodeValue::Call(indexed) = indexedCall.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Subscript { index, .. } = indexed.callee.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Deref(indexTarget) = index.value
        else throw testing::TestError::Failed;
    try expectIdent(indexTarget, "index");

    let symbolic = try! parseExprStr("map⟨T, U⟩(value)");
    let case ast::NodeValue::Call(symbolicCall) = symbolic.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::GenericApply(symbolicApp) = symbolicCall.callee.value
        else throw testing::TestError::Failed;
    assert symbolicApp.args.len == 2;

    let functionValue = try! parseExprStr("first⟨i32⟩");
    let case ast::NodeValue::GenericApply(valueApp) = functionValue.value
        else throw testing::TestError::Failed;
    try expectIntType(valueApp.args[0], 4, ast::Signedness::Signed);

    let subscript = try! parseExprStr("values[index]");
    let case ast::NodeValue::Subscript { .. } = subscript.value
        else throw testing::TestError::Failed;
}

/// Instantiation roots retain every applied path in a grouped declaration.
@test fn testParseInstantiateDeclaration() throws (testing::TestError) {
    let node = try! parseStmtStr(
        "instantiate collections::Pair⟨i32, bool⟩, Maybe⟨i32⟩;"
    );
    let case ast::NodeValue::Instantiate(applications) = node.value
        else throw testing::TestError::Failed;
    assert applications.len == 2;
    let case ast::NodeValue::GenericApply(app) = applications[0].value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::ScopeAccess(path) = app.target.value
        else throw testing::TestError::Failed;
    try expectIdent(path.parent, "collections");
    try expectIdent(path.child, "Pair");
    assert app.args.len == 2;
    let case ast::NodeValue::GenericApply(second) = applications[1].value
        else throw testing::TestError::Failed;
    try expectIdent(second.target, "Maybe");
    assert second.args.len == 1;
}

/// Generic syntax reports focused malformed-list diagnostics.
@test fn testParseGenericDiagnostics() throws (testing::TestError) {
    try expectStmtParseError(
        "record Empty⟨⟩ {}", "generic parameter list cannot be empty"
    );
    try expectStmtParseError(
        "record Bad⟨constant constant N: u32⟩ {}", "duplicate `constant` in generic parameter"
    );
    try expectStmtParseError(
        "instantiate Pair⟨i32,⟩;", "expected generic argument after `,`"
    );
    try expectStmtParseError(
        "instantiate Pair;", "`instantiate` requires a generic application"
    );
}

lib/std/lang/resolver.rad +3554 -611

export constant ANALYZE_EXPR_FN_NAME: *[u8] = "__expr__";
/// Synthetic function name used when wrapping a block for analysis.
export constant ANALYZE_BLOCK_FN_NAME: *[u8] = "__block__";

/// Maximum number of symbols stored within a module scope.
export constant MAX_MODULE_SYMBOLS: u32 = 512;
export constant MAX_MODULE_SYMBOLS: u32 = 768;
/// Maximum number of symbols stored within a local scope.
export constant MAX_LOCAL_SYMBOLS: u32 = 32;
/// Maximum function parameters.
export constant MAX_FN_PARAMS: u32 = 8;
/// Maximum function thrown types.

export constant MAX_LOOP_DEPTH: u32 = 16;
/// Maximum trait instances.
export constant MAX_INSTANCES: u32 = 128;
/// Maximum standalone methods (across all types).
export constant MAX_METHODS: u32 = 256;
/// Maximum generic parameters on one declaration.
export constant MAX_GENERIC_PARAMS: u32 = 8;
/// Maximum explicit specialization roots in one package.
export constant MAX_GENERIC_ROOTS: u32 = 256;
/// Maximum canonical data and function specializations in one package.
export constant MAX_GENERIC_SPECIALIZATIONS: u32 = 512;
/// Maximum expanding generic function dependency depth.
export constant MAX_GENERIC_SPECIALIZATION_DEPTH: u16 = 32;
/// Maximum number of linear bindings active in one function.
constant MAX_LINEAR_BINDINGS: u32 = 32;
/// Maximum nesting depth tracked for loops.
constant MAX_LINEAR_LOOP_DEPTH: u32 = 16;

/// Resolution state for a trait signature table.
export union TraitState {
    /// Signature resolution has not started.
    Queued,
    /// Signature resolution is in progress.
    Resolving,
    /// Signature resolution is complete.
    Complete,
}

/// Trait definition stored in the resolver.
export record TraitType {
    /// Trait name.
    name: *[u8],
    /// Module-local identity used by semantic tables.
    moduleId: u16,
    nodeId: u32,
    /// Method signatures, including from supertraits.
    methods: *mut [TraitMethod],
    /// Supertraits that must also be implemented.
    supertraits: *mut [*TraitType],
    /// Rigid `Self` type used by static signatures.
    selfType: *GenericParamType,
    /// Whether signature resolution has started or completed.
    state: TraitState,
    /// Whether every vtable-exposed method is object-safe.
    objectSafe: bool,
}

/// A single method signature within a trait.
export record TraitMethod {
    /// Method name.

    fnType: *FnType,
    /// Whether the receiver is mutable.
    mutable: bool,
    /// Pointer-like class used by the receiver.
    receiverClass: types::PointerClass,
    /// Trait that originally declared this method.
    owner: *TraitType,
    /// V-table slot index.
    index: u32,
}

/// An entry in the trait instance registry.
export record InstanceEntry {
    /// Trait type descriptor.
    traitType: *TraitType,
    /// Concrete type that implements the trait.
    concreteType: Type,
    /// Name of the concrete type.
    concreteTypeName: *[u8],
    /// Module where this instance was declared.
    moduleId: u16,
    /// Method symbols for each trait method, in declaration order.
    methods: *mut [*mut Symbol],
}

/// An entry in the method registry.
export record MethodEntry {
    /// Concrete type that owns the method.
    concreteType: Type,
    /// Name of the concrete type.
    concreteTypeName: *[u8],
    /// Method name.
    name: *[u8],
    /// Function type excluding the receiver.
    fnType: *FnType,
    /// Whether the receiver is mutable.

export record ArrayType {
    item: *Type,
    length: u32,
}

/// Anonymous record whose field layout depends on rigid parameters.
export record GenericRecordType {
    /// Fields in declaration order.
    fields: *[RecordField],
    /// Whether the fields have labels.
    labeled: bool,
}

/// Record nominal type.
export record RecordType {
    fields: *[RecordField],
    labeled: bool,
    /// Cached layout.

        bindingName: ?*[u8],
        indexName: ?*[u8]
    },
}

/// A rigid type parameter belonging to one generic declaration.
export record GenericParamType {
    /// Declaration that owns the parameter.
    owner: *ast::Node,
    /// Parameter declaration node.
    node: *ast::Node,
    /// Parameter name.
    name: *[u8],
    /// Position in the declaration's ordered parameter list.
    index: u32,
    /// Resolved trait bounds.
    bounds: *[*TraitType],
    /// Shared usage flag, mutable through symbol references.
    used: *mut bool,
    /// Declared integer type for a constant parameter, or `nil` for a type parameter.
    constType: ?*Type,
}

/// Resolved function signature details.
export record FnType {
    paramTypes: *[*Type],
    returnType: *Type,
    throwList: *[*Type],
    /// Whether calling this function requires an unsafe context.
    isUnsafe: bool,
    localCount: u32,
}

/// Resolved, declaration-scoped generic metadata.
export record GenericTemplate {
    /// Template symbol.
    symbol: *mut Symbol,
    /// Ordered rigid type parameters.
    params: *[*GenericParamType],
    /// Symbolic function signature, for function templates.
    signature: ?*FnType,
    /// Symbolic field or variant types, in declaration order.
    members: *[*Type],
    /// Whether the declaration explicitly carries the `Linear` marker.
    declaredLinear: bool,
    /// Whether a generic function body has already been checked.
    bodyResolved: bool,
    /// Symbolic body types consumed by lowering, recorded during body analysis.
    typeUses: *mut [GenericTypeUse],
    /// Next generic template.
    next: ?*mut GenericTemplate,
}

/// Canonical concrete specialization of a generic record or union.
export record GenericDataSpecialization {
    /// Template symbol whose declaration is specialized.
    template: *mut Symbol,
    /// Ordered, interned concrete type arguments.
    args: *[*Type],
    /// Ordinary nominal type produced for this application.
    nominal: *mut NominalType,
    /// Whether an explicit `instantiate` declaration requested this type.
    rooted: bool,
    /// First concrete application site, used for root diagnostics.
    site: *ast::Node,
    /// Next data specialization.
    next: ?*mut GenericDataSpecialization,
}

/// Worklist state for a concrete generic function body.
export union GenericFnState {
    /// Specialization is waiting for dependency processing.
    Queued,
    /// Specialization dependencies are being processed.
    Lowering,
    /// Specialization dependency processing is complete.
    Complete,
}

/// Canonical concrete specialization of a generic free function.
export record GenericFnSpecialization {
    /// Template symbol whose body is lowered.
    template: *mut Symbol,
    /// Ordered, interned concrete type arguments.
    args: *[*Type],
    /// Substituted concrete function signature.
    fnType: *FnType,
    /// First explicit instantiation site.
    site: *ast::Node,
    /// Dependency-closure state.
    state: GenericFnState,
    /// Distance from an explicit root, used to bound expanding recursion.
    depth: u16,
    /// Whether all lowering-consumed body types have been materialized.
    typesMaterialized: bool,
    /// Next function specialization.
    next: ?*mut GenericFnSpecialization,
}

/// A generic call retained in a checked symbolic function body.
export record GenericFnDependency {
    /// Generic function that contains the call, or `nil` for a root call.
    caller: ?*mut Symbol,
    /// Generic function called by this dependency.
    callee: *mut Symbol,
    /// Symbolic arguments supplied by the caller.
    args: *[*Type],
    /// Source node for the call.
    site: *ast::Node,
    /// Next dependency for the same template.
    next: ?*GenericFnDependency,
}

/// Concrete call selected for one symbolic edge in one caller specialization.
export record GenericFnDependencyResolution {
    /// Symbolic dependency that selected this call.
    dependency: *GenericFnDependency,
    /// Concrete caller specialization.
    caller: *GenericFnSpecialization,
    /// Concrete callee specialization.
    callee: *GenericFnSpecialization,
    /// Next resolved dependency for the caller.
    next: ?*GenericFnDependencyResolution,
}

/// One symbolic type use that must be materialized for each reachable generic
/// function specialization before lowering begins.
record GenericTypeUse {
    /// AST node whose lowering metadata contains the type.
    site: *ast::Node,
    /// Symbolic type consumed by lowering.
    ty: Type,
}

/// Type-syntax resolution context.
union TypeSyntaxContext {
    /// Resolve fully concrete types and require ordinary aggregate layout.
    Concrete,
    /// Retain rigid parameters and defer generic aggregate layout.
    Symbolic,
}

/// Ordered replacement types for rigid parameters.
export record Substitution {
    /// Rigid parameters to replace.
    params: *[*GenericParamType],
    /// Concrete arguments matched by position with `params`.
    args: *[*Type],
}

/// Source of member types for aggregate construction.
union AggregateMemberSource {
    /// Resolve ordinary declaration member types.
    Ordinary,
    /// Substitute symbolic member types from a generic template.
    Generic {
        members: *[*Type],
        substitution: *Substitution,
    },
}

/// Symbolic application of a generic data template inside another template.
export record GenericDataApplyType {
    /// Generic data template being applied.
    template: *mut Symbol,
    /// Symbolic arguments supplied to the template.
    args: *[*Type],
    /// Source node for the application.
    site: *ast::Node,
}

/// Pointer-like address payload.
export record PointerType {
    /// Ownership and safety class.
    class: types::PointerClass,
    /// Pointer target type.
    target: *Type,
    /// Whether the pointer is mutable.
    mutable: bool,
}

/// Pointer-like slice payload.
export record SliceType {
    /// Ownership and safety class.
    class: types::PointerClass,
    /// Slice element type.
    item: *Type,
    /// Whether the slice is mutable.
    mutable: bool,
}

/// Erased pointer-like type payload.
export record TraitObjectType {
    /// Ownership and safety class.
    class: types::PointerClass,
    /// Trait definition.
    traitInfo: *TraitType,
    /// Whether the pointer is mutable.
    mutable: bool,
}

/// Describes a type computed during semantic analysis.
export union Type {
    /// A type that couldn't be decided.
    Unknown,
    /// Types only used during inference.

    /// Range types, eg. `start..end`.
    Range {
        start: ?*Type,
        end: ?*Type,
    },
    /// Owning pointer-like address.
    Pointer {
        class: types::PointerClass,
        target: *Type,
        mutable: bool,
    },
    /// Owning slice.
    Slice {
        class: types::PointerClass,
        item: *Type,
        mutable: bool,
    },
    /// Pointer-like address.
    Pointer(PointerType),
    /// Pointer-like slice.
    Slice(SliceType),
    /// Eg. `[i32; 32]`.
    Array(ArrayType),
    /// Array type whose length depends on a rigid constant parameter.
    GenericArray {
        item: *Type,
        length: *ast::Node,
    },
    /// Rigid integer constant parameter within a generic declaration.
    ConstParameter(*GenericParamType),
    /// Canonical typed integer generic argument.
    ConstArgument {
        type: *Type,
        value: ConstInt,
    },
    /// Symbolic integer expression awaiting constant-parameter substitution.
    GenericConstExpr {
        type: *Type,
        expr: *ast::Node,
    },
    /// Eg. `?T`.
    Optional(*Type),
    /// Eg. `fn id(i32) -> i32`.
    Fn(*FnType),
    /// Named, ie. user-defined types, includes union variants.
    Nominal(*NominalType),
    /// Owning trait object. An erased type with v-table.
    TraitObject {
        /// Ownership and safety class.
        class: types::PointerClass,
        /// Trait definition.
        traitInfo: *TraitType,
        /// Whether the pointer is mutable.
        mutable: bool,
    },
    /// Rigid type parameter within a generic declaration.
    Parameter(*GenericParamType),
    /// Anonymous record awaiting substitution before layout.
    GenericRecord(*GenericRecordType),
    /// Generic data application awaiting substitution of its arguments.
    GenericDataApply(*GenericDataApplyType),
    /// An erased pointer-like type with a v-table.
    TraitObject(TraitObjectType),
}

/// Structured diagnostic payload for type mismatches.
export record TypeMismatch {
    expected: Type,

        /// Module scope.
        scope: *mut Scope,
    },
    /// Payload describing type symbols with their resolved type.
    Type(*mut NominalType),
    /// Rigid generic type parameter.
    TypeParameter(*GenericParamType),
    /// Rigid generic integer constant parameter.
    ConstParameter(*GenericParamType),
    /// Trait symbol.
    Trait(*mut TraitType),
}

/// Resolved symbol allocated during semantic analysis.

    ReceiverMutabilityMismatch,
    /// Duplicate instance declaration for the same (trait, type) pair.
    DuplicateInstance,
    /// Instance declaration is missing a required trait method.
    MissingTraitMethod(*[u8]),
    /// Subtrait instance attempts to override an inherited method.
    InheritedTraitMethod(*[u8]),
    /// Trait name used as a value expression.
    UnexpectedTraitName,
    /// Trait method receiver does not point to the declaring trait.
    TraitReceiverMismatch,
    /// A trait mentioning `Self` outside its receiver cannot form an object.
    TraitNotObjectSafe,
    /// Supertrait declarations form a cycle.
    TraitInheritanceCycle,
    /// An instance target is not a supported concrete type.
    InvalidInstanceTarget,
    /// Trait declaration and instance disagree about unsafe call requirements.
    TraitMethodSafetyMismatch,
    /// Function declaration has too many parameters.
    FnParamOverflow(CountMismatch),
    /// Function declaration has too many throws.

    BorrowConflict(*[u8]),
    /// Unsafe pointer operation outside an `unsafe` declaration.
    UnsafeOperation,
    /// Safe code cannot call an `unsafe` function.
    UnsafeCall,
    /// A syntax node is not valid in a generic context.
    GenericUnsupported,
    /// A generic bound did not name a trait.
    GenericBoundNotTrait,
    /// A constant parameter type is not a concrete integer type.
    GenericConstUnsupported,
    /// An attribute cannot be applied to a generic function.
    GenericFnAttribute,
    /// Generic function declarations must be at module scope.
    GenericFnNested,
    /// A type parameter does not affect its function.
    GenericFnUnusedParameter(*[u8]),
    /// More than one bound exposes the selected method name.
    GenericBoundAmbiguous(*[u8]),
    /// A rigid parameter was used where a concrete layout is required.
    GenericLayoutRequired,
    /// A concrete generic specialization has infinitely recursive layout.
    GenericRecursiveLayout,
    /// A function specialization targeted a non-function declaration.
    GenericFunctionExpected,
    /// A concrete type argument does not satisfy a declared trait bound.
    GenericBoundUnsatisfied(*[u8]),
    /// A generic function application has no explicit instantiation root.
    GenericFunctionInstantiationRequired,
    /// A generic call graph expands beyond the specialization bound.
    GenericSpecializationChain,
    /// Generic argument inference did not determine every parameter.
    GenericInferenceIncomplete,
    /// Generic argument inference found incompatible evidence.
    GenericInferenceConflict,
    /// A generic declaration was named without required arguments.
    GenericArgumentsRequired,
    /// A concrete application is not covered by an explicit instantiation root.
    GenericInstantiationRequired,
    /// Internal error.
    Internal,
    /// A generic application supplied the wrong number of arguments.
    GenericArgumentCount(CountMismatch),
    /// A data specialization targeted a non-data generic declaration.
    GenericDataExpected,
    /// A data specialization argument still contains a rigid parameter.
    GenericConcreteArgumentsRequired,
    /// A declaration exceeds the generic parameter limit.
    GenericParameterLimit,
    /// A package exceeds the explicit generic root limit.
    GenericRootLimit,
    /// A package exceeds the canonical specialization limit.
    GenericSpecializationLimit,
}

/// Diagnostics returned by the analyzer.
export record Diagnostics {
    errors: *mut [Error],

        /// Trait definition.
        traitInfo: *TraitType,
        /// Method index in the v-table.
        methodIndex: u32,
    },
    /// Static method call through a bounded generic parameter.
    GenericBoundMethodCall {
        param: *GenericParamType,
        traitInfo: *TraitType,
        methodIndex: u32,
        /// Whether the receiver is the first explicit call argument.
        explicitReceiver: bool,
    },
    /// Standalone method call metadata.
    MethodCall { method: *MethodEntry },
    /// Slice `.append(val, allocator)` method call.
    SliceAppend { elemType: *Type },
    /// Slice `.delete(index)` method call.
    SliceDelete { elemType: *Type },
    /// Concrete specialization selected by an explicit generic function value.
    GenericFnCall(*GenericFnSpecialization),
    /// Symbolic generic call resolved under the caller's specialization.
    GenericFnDependency(*GenericFnDependency),
}

/// Combined resolver metadata for a single AST node.
export record NodeData {
    /// Resolved type for this node.

    effectiveTy: Type,
    /// How bindings should be created.
    by: MatchBy,
}

/// Stack node used to stop cycles while walking ordinary nominal containers.
record GenericRootVisit {
    /// Nominal type visited at this stack entry.
    nominal: *NominalType,
    /// Previous stack entry.
    parent: ?*GenericRootVisit,
}

/// A uniquely selected method exposed by a generic parameter bound.
record GenericBoundMethod {
    /// Trait that exposes the selected method.
    traitInfo: *TraitType,
    /// Selected trait method.
    method: *TraitMethod,
}

/// How an expression uses a linear result.
union LinearUse {
    /// Consume the value and end its availability.
    Consume,
    /// Read the value without consuming it.

    loopDepth: u32,
}

/// Unwrap a pointer type for pattern matching.
export fn unwrapMatchSubject(ty: Type) -> MatchSubject {
    if let case Type::Pointer { target, mutable, .. } = ty {
        let by = MatchBy::MutRef if mutable else MatchBy::Ref;
        return MatchSubject { effectiveTy: *target, by };
    if let case Type::Pointer(pointer) = ty {
        let by = MatchBy::MutRef if pointer.mutable else MatchBy::Ref;
        return MatchSubject { effectiveTy: *pointer.target, by };
    }
    return MatchSubject { effectiveTy: ty, by: MatchBy::Value };
}

/// Global resolver state.

    loopStack: [LoopCtx; MAX_LOOP_DEPTH],
    /// Current loop depth, indexes into loop stack.
    loopDepth: u32,
    /// Signature of the function currently being analyzed.
    currentFn: ?*FnType,
    /// Generic function template whose body is currently being analyzed.
    currentGenericTemplate: ?*mut GenericTemplate,
    /// Rigid `Self` type while resolving a trait signature.
    currentTraitSelf: ?*GenericParamType,
    /// Current module being analyzed.
    currentMod: u16,
    /// Nesting depth of unsafe modules and function bodies.
    unsafeDepth: u32,
    /// Configuration for semantic analysis.

    instancesLen: u32,
    /// Standalone method registry.
    methods: [MethodEntry; MAX_METHODS],
    /// Number of registered standalone methods.
    methodsLen: u32,
    /// Sparse metadata for generic declarations.
    genericTemplates: ?*mut GenericTemplate,
    /// Canonical generic function specializations.
    genericFnSpecializations: ?*mut GenericFnSpecialization,
    /// Symbolic and deferred generic call edges.
    genericFnDependencies: ?*GenericFnDependency,
    /// Concrete resolutions of symbolic generic call edges.
    genericFnDependencyResolutions: ?*GenericFnDependencyResolution,
    /// Package-wide canonical generic data specializations.
    genericDataSpecializations: ?*mut GenericDataSpecialization,
    /// Number of explicit generic roots requested by the package.
    genericRoots: u32,
    /// Number of canonical data and function specializations.
    genericSpecializationCount: u32,
}

/// Internal error sentinel thrown when analysis cannot proceed.
export union ResolveError {
    Failure,

    set self.types = node;

    return &node.ty;
}

/// Return whether a type contains a rigid generic parameter.
export fn containsGenericParameter(ty: Type) -> bool {
    match ty {
        case Type::Pointer(pointer) =>
            return containsGenericParameter(*pointer.target),
        case Type::Slice(slice) =>
            return containsGenericParameter(*slice.item),
        case Type::Parameter(_), Type::ConstParameter(_),
             Type::GenericConstExpr { .. } => return true,
        case Type::Array(array) => return containsGenericParameter(*array.item),
        case Type::GenericArray { .. } => return true,
        case Type::Optional(inner) => return containsGenericParameter(*inner),
        // Symbolic anonymous records require materialization even when their
        // own fields happen not to mention a rigid parameter.
        case Type::GenericRecord(_) => return true,
        case Type::GenericDataApply(_) => return true,
        case Type::Fn(info) => {
            for param in info.paramTypes {
                if containsGenericParameter(*param) {
                    return true;
                }
            }
            if containsGenericParameter(*info.returnType) {
                return true;
            }
            for thrown in info.throwList {
                if containsGenericParameter(*thrown) {
                    return true;
                }
            }
            return false;
        }
        case Type::Range { start, end } => {
            if let ty = start {
                if containsGenericParameter(*ty) {
                    return true;
                }
            }
            if let ty = end {
                if containsGenericParameter(*ty) {
                    return true;
                }
            }
            return false;
        }
        else => return false,
    }
}

/// Return whether a by-value type reaches an in-progress nominal placeholder.
fn hasUnresolvedNominalLayout(ty: Type) -> bool {
    match ty {
        case Type::Pointer(_), Type::Slice(_) => return false,
        case Type::Array(array) => return hasUnresolvedNominalLayout(*array.item),
        case Type::Optional(inner) => return hasUnresolvedNominalLayout(*inner),
        case Type::Nominal(info) => {
            if let case NominalType::Placeholder(_) = *info {
                return true;
            }
            return false;
        }
        case Type::GenericRecord(rec) => {
            for field in rec.fields {
                if hasUnresolvedNominalLayout(field.fieldType) {
                    return true;
                }
            }
            return false;
        }
        else => return false,
    }
}

/// Materialize concrete generic data applications within a type while
/// preserving rigid parameters and constant-dependent constructors.
fn materializeConcreteGenericData(
    self: *mut Resolver,
    ty: Type,
    site: *ast::Node,
) -> Type throws (ResolveError) {
    match ty {
        case Type::Pointer(pointer) => {
            let inner = try materializeConcreteGenericData(self, *pointer.target, site);
            return Type::Pointer(PointerType {
                class: pointer.class,
                target: allocType(self, inner),
                mutable: pointer.mutable,
            });
        }
        case Type::Slice(slice) => {
            let inner = try materializeConcreteGenericData(self, *slice.item, site);
            return Type::Slice(SliceType {
                class: slice.class,
                item: allocType(self, inner),
                mutable: slice.mutable,
            });
        }
        case Type::Array(array) => {
            let item = try materializeConcreteGenericData(self, *array.item, site);
            return Type::Array(ArrayType {
                item: allocType(self, item),
                length: array.length,
            });
        }
        case Type::GenericArray { item, length } => {
            let inner = try materializeConcreteGenericData(self, *item, site);
            return Type::GenericArray { item: allocType(self, inner), length };
        }
        case Type::Optional(inner) => {
            let value = try materializeConcreteGenericData(self, *inner, site);
            return Type::Optional(allocType(self, value));
        }
        case Type::GenericDataApply(app) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut args: *mut [*Type] = &mut [];
            let mut concrete = true;
            for arg in app.args {
                let value = try materializeConcreteGenericData(self, *arg, site);
                set concrete = concrete and not containsGenericParameter(value);
                args.append(allocType(self, value), a);
            }
            if concrete {
                let nominal = try specializeGenericData(
                    self, app.site, app.template, &args[..], false
                );
                return Type::Nominal(nominal);
            }
            let application = try! alloc::alloc(
                &mut self.arena,
                @sizeOf(GenericDataApplyType),
                @alignOf(GenericDataApplyType),
            ) as *mut GenericDataApplyType;
            set *application = GenericDataApplyType {
                template: app.template,
                args: &args[..],
                site: app.site,
            };
            return Type::GenericDataApply(application);
        }
        case Type::Fn(info) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut params: *mut [*Type] = &mut [];
            let mut throwTypes: *mut [*Type] = &mut [];
            for param in info.paramTypes {
                let value = try materializeConcreteGenericData(self, *param, site);
                params.append(allocType(self, value), a);
            }
            for thrown in info.throwList {
                let value = try materializeConcreteGenericData(self, *thrown, site);
                throwTypes.append(allocType(self, value), a);
            }
            let result = try materializeConcreteGenericData(
                self, *info.returnType, site
            );
            return Type::Fn(allocFnType(self, FnType {
                paramTypes: &params[..],
                returnType: allocType(self, result),
                throwList: &throwTypes[..],
                isUnsafe: info.isUnsafe,
                localCount: info.localCount,
            }));
        }
        case Type::GenericRecord(rec) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut fields: *mut [RecordField] = &mut [];
            let mut symbolic = false;
            for field in rec.fields {
                let fieldType = try materializeConcreteGenericData(
                    self, field.fieldType, site
                );
                set symbolic = symbolic or containsGenericParameter(fieldType);
                fields.append(RecordField {
                    name: field.name,
                    fieldType,
                    offset: field.offset,
                }, a);
            }
            let updatedRec = try! alloc::alloc(
                &mut self.arena,
                @sizeOf(GenericRecordType),
                @alignOf(GenericRecordType),
            ) as *mut GenericRecordType;
            set *updatedRec = GenericRecordType {
                fields: &fields[..],
                labeled: rec.labeled,
            };
            let updated = Type::GenericRecord(updatedRec);
            if symbolic {
                return updated;
            }
            let empty = Substitution { params: &[], args: &[] };
            return try substituteType(self, updated, &empty, site);
        }
        else => return ty,
    }
}

/// Look up the concrete replacement for a rigid parameter.
export fn substitutionArg(sub: *Substitution, param: *GenericParamType) -> Type {
    assert sub.params.len == sub.args.len, "substitution length mismatch";
    for candidate, i in sub.params {
        if candidate == param {
            return *sub.args[i];
        }
    }
    if param.constType <> nil {
        return Type::ConstParameter(param);
    }
    return Type::Parameter(param);
}

/// Recursively replace rigid parameters in a resolved type.
export fn substituteType(
    self: *mut Resolver,
    ty: Type,
    sub: *Substitution,
    site: *ast::Node,
) -> Type throws (ResolveError) {
    if not containsGenericParameter(ty) {
        return ty;
    }
    match ty {
        case Type::Parameter(param) => return substitutionArg(sub, param),
        case Type::ConstParameter(param) => return substitutionArg(sub, param),
        case Type::GenericConstExpr { type, expr } => {
            let value = constValueWithSubstitution(self, expr, sub)
                else throw emitError(self, expr, ErrorKind::ConstExprRequired);
            let case ConstValue::Int(int) = value
                else throw emitError(self, expr, ErrorKind::ConstExprRequired);
            if not validateConstIntRange(value, *type) {
                throw emitError(self, expr, ErrorKind::NumericLiteralOverflow);
            }
            let case ConstValue::Int(canonical) = castConstInt(int, *type)
                else throw emitError(self, expr, ErrorKind::Internal);
            return Type::ConstArgument { type, value: canonical };
        }
        case Type::Pointer(pointer) => {
            let inner = try substituteType(self, *pointer.target, sub, site);
            return Type::Pointer(PointerType {
                class: pointer.class,
                target: allocType(self, inner),
                mutable: pointer.mutable,
            });
        }
        case Type::Slice(slice) => {
            let inner = try substituteType(self, *slice.item, sub, site);
            return Type::Slice(SliceType {
                class: slice.class,
                item: allocType(self, inner),
                mutable: slice.mutable,
            });
        }
        case Type::Array(array) => {
            let item = try substituteType(self, *array.item, sub, site);
            return Type::Array(ArrayType {
                item: allocType(self, item),
                length: array.length,
            });
        }
        case Type::GenericArray { item, length } => {
            let concreteItem = try substituteType(self, *item, sub, site);
            let value = constValueWithSubstitution(self, length, sub)
                else throw emitError(self, length, ErrorKind::ConstExprRequired);
            if not validateConstIntRange(value, Type::U32) {
                throw emitError(self, length, ErrorKind::NumericLiteralOverflow);
            }
            let case ConstValue::Int(int) = value
                else throw emitError(self, length, ErrorKind::ConstExprRequired);
            return Type::Array(ArrayType {
                item: allocType(self, concreteItem),
                length: int.magnitude as u32,
            });
        }
        case Type::Optional(inner) => {
            let value = try substituteType(self, *inner, sub, site);
            return Type::Optional(allocType(self, value));
        }
        case Type::GenericDataApply(app) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut args: *mut [*Type] = &mut [];
            let mut symbolic = false;
            for arg in app.args {
                let replacement = try substituteType(self, *arg, sub, site);
                set symbolic = symbolic or containsGenericParameter(replacement);
                args.append(allocType(self, replacement), a);
            }
            if symbolic {
                let application = try! alloc::alloc(
                    &mut self.arena,
                    @sizeOf(GenericDataApplyType),
                    @alignOf(GenericDataApplyType),
                ) as *mut GenericDataApplyType;
                set *application = GenericDataApplyType {
                    template: app.template,
                    args: &args[..],
                    site: app.site,
                };
                return Type::GenericDataApply(application);
            }
            let nominal = try specializeGenericData(
                self, app.site, app.template, &args[..], false
            );
            return Type::Nominal(nominal);
        }
        case Type::GenericRecord(rec) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut fields: *mut [RecordField] = &mut [];
            let mut offset: u32 = 0;
            let mut alignment: u32 = 1;
            for field in rec.fields {
                let fieldType = try substituteType(self, field.fieldType, sub, site);
                if hasUnresolvedNominalLayout(fieldType) {
                    throw emitError(self, site, ErrorKind::GenericRecursiveLayout);
                }
                try ensureStorableType(self, site, fieldType);
                try ensureTypeResolved(self, fieldType, site);
                let fieldLayout = getTypeLayout(fieldType);
                set offset = mem::alignUp(offset, fieldLayout.alignment);
                fields.append(RecordField {
                    name: field.name,
                    fieldType,
                    offset: offset as i32,
                }, a);
                set offset += fieldLayout.size;
                set alignment = max(alignment, fieldLayout.alignment);
            }
            let layout = Layout {
                size: mem::alignUp(offset, alignment),
                alignment,
            };
            return Type::Nominal(allocNominalType(self, NominalType::Record(RecordType {
                fields: &fields[..],
                labeled: rec.labeled,
                layout,
                declaredLinear: false,
            })));
        }
        case Type::Fn(info) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut params: *mut [*Type] = &mut [];
            let mut throwTypes: *mut [*Type] = &mut [];
            for param in info.paramTypes {
                let concrete = try substituteType(self, *param, sub, site);
                params.append(allocType(self, concrete), a);
            }
            for thrown in info.throwList {
                let concrete = try substituteType(self, *thrown, sub, site);
                throwTypes.append(allocType(self, concrete), a);
            }
            let result = try substituteType(self, *info.returnType, sub, site);
            return Type::Fn(allocFnType(self, FnType {
                paramTypes: &params[..],
                returnType: allocType(self, result),
                throwList: &throwTypes[..],
                isUnsafe: info.isUnsafe,
                localCount: info.localCount,
            }));
        }
        case Type::Range { start, end } => {
            let mut newStart: ?*Type = nil;
            let mut newEnd: ?*Type = nil;
            if let value = start {
                let concrete = try substituteType(self, *value, sub, site);
                set newStart = allocType(self, concrete);
            }
            if let value = end {
                let concrete = try substituteType(self, *value, sub, site);
                set newEnd = allocType(self, concrete);
            }
            return Type::Range { start: newStart, end: newEnd };
        }
        else => return ty,
    }
}

/// Allocate a nominal type descriptor and return a pointer to it.
fn allocNominalType(self: *mut Resolver, info: NominalType) -> *mut NominalType {
    // Nb. We don't attempt to de-duplicate nominal type entries,
    // since they don't carry node information and we create
    // placeholder entries when binding symbols.

        scope: storage.pkgScope,
        pkgScope: storage.pkgScope,
        loopStack: undefined,
        loopDepth: 0,
        currentFn: nil,
        currentGenericTemplate: nil,
        currentTraitSelf: nil,
        currentMod: 0,
        unsafeDepth: 0,
        config,
        arena,
        nodeData: NodeDataTable { entries: storage.nodeData },

        moduleScopes,
        instances: undefined,
        instancesLen: 0,
        methods: undefined,
        methodsLen: 0,
        genericTemplates: nil,
        genericFnSpecializations: nil,
        genericFnDependencies: nil,
        genericFnDependencyResolutions: nil,
        genericDataSpecializations: nil,
        genericRoots: 0,
        genericSpecializationCount: 0,
    };
}

/// Return `true` if there are no errors in the diagnostics.
export fn success(diag: *Diagnostics) -> bool {

    let case ast::NodeValue::Ident(name) = node.value
        else throw emitError(self, node, ErrorKind::ExpectedIdentifier);
    return name;
}

/// Record a symbolic type that lowering will consume from a generic body.
fn recordGenericTypeUse(self: *mut Resolver, site: *ast::Node, ty: Type) {
    if not containsGenericParameter(ty) {
        return;
    }
    let current = self.currentGenericTemplate else return;
    current.typeUses.append(
        GenericTypeUse { site, ty },
        alloc::arenaAllocator(&mut self.arena),
    );
}

/// Associate a resolved symbol with an AST node.
fn setNodeSymbol(self: *mut Resolver, node: *ast::Node, symbol: *mut Symbol) {
    if let existingSym = self.nodeData.entries[node.id].sym {
        panic "setNodeSymbol: a symbol is already associated with this node";
    }

fn setNodeType(self: *mut Resolver, node: *ast::Node, ty: Type) -> Type {
    if ty == Type::Unknown {
        // In this case, we simply don't associate a type.
        return ty;
    }
    recordGenericTypeUse(self, node, ty);
    set self.nodeData.entries[node.id].ty = ty;

    return ty;
}


/// Associate a coercion plan with an AST node.
fn setNodeCoercion(self: *mut Resolver, node: *ast::Node, coercion: Coercion) -> Coercion {
    if coercion == Coercion::Identity {
        return coercion;
    }
    match coercion {
        case Coercion::NumericCast { from, to } => {
            recordGenericTypeUse(self, node, from);
            recordGenericTypeUse(self, node, to);
        }
        case Coercion::OptionalLift(ty) =>
            recordGenericTypeUse(self, node, ty),
        else => {}
    }
    set self.nodeData.entries[node.id].coercion = coercion;

    return coercion;
}


    set self.nodeData.entries[node.id].extra = NodeExtra::RecordField { index };
}

/// Associate slice range metadata with a subscript expression.
fn setSliceRangeInfo(self: *mut Resolver, node: *ast::Node, info: SliceRangeInfo) {
    recordGenericTypeUse(self, node, *info.itemType);
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceRange(info);
}

/// Associate union variant metadata with a pattern or constructor node.
fn setVariantInfo(self: *mut Resolver, node: *ast::Node, ordinal: u32, tag: u32) {

/// Associate trait method call metadata with a call node.
fn setTraitMethodCall(self: *mut Resolver, node: *ast::Node, traitInfo: *TraitType, methodIndex: u32) {
    set self.nodeData.entries[node.id].extra = NodeExtra::TraitMethodCall { traitInfo, methodIndex };
}

/// Associate static generic-bound dispatch metadata with a call node.
fn setGenericBoundMethodCall(
    self: *mut Resolver,
    node: *ast::Node,
    param: *GenericParamType,
    traitInfo: *TraitType,
    methodIndex: u32,
    explicitReceiver: bool,
) {
    set self.nodeData.entries[node.id].extra = NodeExtra::GenericBoundMethodCall {
        param, traitInfo, methodIndex, explicitReceiver,
    };
}

/// Associate for-loop metadata with a for-loop node.
fn setForLoopInfo(self: *mut Resolver, node: *ast::Node, info: ForLoopInfo) {
    set self.nodeData.entries[node.id].extra = NodeExtra::ForLoop(info);
    match info {
        case ForLoopInfo::Range { valType, .. } =>
            recordGenericTypeUse(self, node, *valType),
        case ForLoopInfo::Collection { elemType, .. } =>
            recordGenericTypeUse(self, node, *elemType),
    }
}

/// Retrieve the constant value associated with a node, if any.
export fn constValueEntry(self: *Resolver, node: *ast::Node) -> ?ConstValue {
    return self.nodeData.entries[node.id].constValue;

}

/// Get the layout of a type.
export fn getTypeLayout(ty: Type) -> Layout {
    match ty {
        case Type::Pointer { .. } => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::Slice { .. }, Type::TraitObject { .. } =>
        case Type::Pointer(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::Slice(_), Type::TraitObject(_) =>
            return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
        case Type::Void, Type::Never => return Layout { size: 0, alignment: 0 },
        case Type::Bool, Type::U8, Type::I8 => return Layout { size: 1, alignment: 1 },
        case Type::U16, Type::I16 => return Layout { size: 2, alignment: 2 },
        case Type::U32, Type::I32 => return Layout { size: 4, alignment: 4 },


/// Check if a type can use null to represent `nil`.
/// Pointers and slices have a data pointer that is never null when valid.
export fn isNullableType(ty: Type) -> bool {
    match ty {
        case Type::Pointer { .. }, Type::Slice { .. } => return true,
        case Type::Pointer(_), Type::Slice(_) => return true,
        else => return false,
    }
}

/// Get the layout of a nominal type.

    };
    return UnionLayoutInfo { layout: unionLayout, valOffset: unionValOffset, isAllVoid };
}

/// Compute the discriminant tag for a variant, advancing the iota counter.
/// If the variant has an explicit `= N` value, uses that; otherwise uses iota.
fn variantTag(variantDecl: ast::UnionDeclVariant, iota: *mut u32) -> u32 {
fn variantTag(
    self: *mut Resolver,
    variantDecl: ast::UnionDeclVariant,
    iota: *mut u32,
    sub: ?*Substitution,
) -> u32 throws (ResolveError) {
    let mut tag: u32 = *iota;
    if let valueNode = variantDecl.value {
        let case ast::NodeValue::Number(lit) = valueNode.value
            else panic "variantTag: expected number literal";
        set tag = lit.magnitude as u32;
        let mut value: ?ConstValue = nil;
        if let substitution = sub {
            set value = constValueWithSubstitution(self, valueNode, substitution);
        } else {
            set value = constValueEntry(self, valueNode);
        }
        let resolved = value
            else throw emitError(self, valueNode, ErrorKind::ConstExprRequired);
        if not validateConstIntRange(resolved, Type::U32) {
            throw emitError(self, valueNode, ErrorKind::NumericLiteralOverflow);
        }
        let case ConstValue::Int(int) = resolved
            else throw emitError(self, valueNode, ErrorKind::ConstExprRequired);
        set tag = int.magnitude as u32;
    }
    set *iota = tag + 1;
    return tag;
}


    return unionType.isAllVoid;
}

/// Check if a type should be treated as an address-like value.
fn isAddressType(ty: Type) -> bool {
    if isNullableType(ty) {
        return true;
    }
    match ty {
        case Type::Fn(_) => return true,
        case Type::Pointer(_), Type::Slice(_), Type::Fn(_) => return true,
        else => return false,
    }
}

/// Return the representable range for an integer type.


/// Ensure all nested nominal types in a type are resolved.
fn ensureTypeResolved(self: *mut Resolver, ty: Type, site: *ast::Node) throws (ResolveError) {
    match ty {
        case Type::Nominal(info) => try ensureNominalResolved(self, info, site),
        case Type::Slice { item, .. } => try ensureTypeResolved(self, *item, site),
        case Type::Pointer { .. } => {}, // Pointers have fixed layout, don't recurse.
        case Type::Slice(slice) => try ensureTypeResolved(self, *slice.item, site),
        case Type::Pointer(_) => {}, // Pointers have fixed layout, don't recurse.
        case Type::Array(arr) => try ensureTypeResolved(self, *arr.item, site),
        case Type::Optional(inner) => try ensureTypeResolved(self, *inner, site),
        else => {},
    }
}

    // The "never" type can always be assigned, since the code path is never
    // executed.
    if from == Type::Never {
        return Coercion::Identity;
    }
    if to == from {
    if typesEqual(to, from) {
        return Coercion::Identity;
    }
    if let case Type::Pointer { class: lhsClass, target: lhsTarget, mutable: lhsMutable } = to {
        let case Type::Pointer { class: rhsClass, target: rhsTarget, mutable: rhsMutable } = from
            else return nil;
        if not pointerClassesAssignable(lhsClass, rhsClass) {
    if let case Type::Pointer(lhs) = to {
        let case Type::Pointer(rhs) = from else return nil;
        if not pointerClassesAssignable(lhs.class, rhs.class) {
            return nil;
        }
        // Allow coercion from `*T` to `*opaque`, and mutable counterparts.
        if *lhsTarget == Type::Opaque {
            if lhsMutable and not rhsMutable {
        if *lhs.target == Type::Opaque {
            if lhs.mutable and not rhs.mutable {
                return nil;
            }
            return Coercion::Identity;
        }
        if lhsMutable and not rhsMutable {
        if lhs.mutable and not rhs.mutable {
            return nil;
        }
        return isAssignable(self, *lhsTarget, *rhsTarget, rval);
        return isAssignable(self, *lhs.target, *rhs.target, rval);
    }
    if let case Type::TraitObject { class: lhsClass, traitInfo: lhsTraitInfo, mutable: lhsMutable } = to {
        if let case Type::Pointer { class: rhsClass, target: rhsTarget, mutable: rhsMutable } = from {
            if not pointerClassesAssignable(lhsClass, rhsClass)
                or (lhsMutable and not rhsMutable)
    if let case Type::TraitObject(lhs) = to {
        if let case Type::Pointer(rhs) = from {
            if not pointerClassesAssignable(lhs.class, rhs.class)
                or (lhs.mutable and not rhs.mutable)
            {
                return nil;
            }
            if let inst = findInstance(self, lhsTraitInfo, *rhsTarget) {
                return Coercion::TraitObject { traitInfo: lhsTraitInfo, inst };
            if let inst = findInstance(self, lhs.traitInfo, *rhs.target) {
                return Coercion::TraitObject { traitInfo: lhs.traitInfo, inst };
            }
        }
        if let case Type::TraitObject { class: rhsClass, traitInfo: rhsTraitInfo, mutable: rhsMutable } = from {
            if not pointerClassesAssignable(lhsClass, rhsClass)
                or lhsTraitInfo <> rhsTraitInfo
        if let case Type::TraitObject(rhs) = from {
            if not pointerClassesAssignable(lhs.class, rhs.class)
                or lhs.traitInfo <> rhs.traitInfo
            {
                return nil;
            }
            if lhsMutable and not rhsMutable {
            if lhs.mutable and not rhs.mutable {
                return nil;
            }
            return Coercion::Identity;
        }
        return nil;
    }
    if let case Type::Slice { class: lhsClass, item: lhsItem, mutable: lhsMutable } = to {
        let case Type::Slice { class: rhsClass, item: rhsItem, mutable: rhsMutable } = from
            else return nil;
        if not pointerClassesAssignable(lhsClass, rhsClass)
            or (lhsMutable and not rhsMutable)
    if let case Type::Slice(lhs) = to {
        let case Type::Slice(rhs) = from else return nil;
        if not pointerClassesAssignable(lhs.class, rhs.class)
            or (lhs.mutable and not rhs.mutable)
        {
            return nil;
        }
        // Allow coercion from `*[T]` to `*[opaque]`, and mutable counterparts.
        if *lhsItem == Type::Opaque {
        if *lhs.item == Type::Opaque {
            return Coercion::Identity;
        }
        return isAssignable(self, *lhsItem, *rhsItem, rval);
        return isAssignable(self, *lhs.item, *rhs.item, rval);
    }
    match to {
        case Type::Array(lhs) => {
            let case Type::Array(rhs) = from
                else return nil;

/// Check if two types are structurally equal.
export fn typesEqual(a: Type, b: Type) -> bool {
    if a == b {
        return true;
    }
    if let case Type::Pointer { class: aClass, target: aTarget, mutable: aMutable } = a {
        let case Type::Pointer { class: bClass, target: bTarget, mutable: bMutable } = b
            else return false;
        return aClass == bClass and aMutable == bMutable
            and typesEqual(*aTarget, *bTarget);
    if let case Type::Pointer(av) = a {
        let case Type::Pointer(bv) = b else return false;
        return av.class == bv.class and av.mutable == bv.mutable
            and typesEqual(*av.target, *bv.target);
    }
    if let case Type::Slice { class: aClass, item: aItem, mutable: aMutable } = a {
        let case Type::Slice { class: bClass, item: bItem, mutable: bMutable } = b
            else return false;
        return aClass == bClass and aMutable == bMutable
            and typesEqual(*aItem, *bItem);
    if let case Type::Slice(av) = a {
        let case Type::Slice(bv) = b else return false;
        return av.class == bv.class and av.mutable == bv.mutable
            and typesEqual(*av.item, *bv.item);
    }
    if let case Type::TraitObject { class: aClass, traitInfo: aTraitInfo, mutable: aMutable } = a {
        let case Type::TraitObject { class: bClass, traitInfo: bTraitInfo, mutable: bMutable } = b
            else return false;
        return aClass == bClass and aMutable == bMutable
            and aTraitInfo == bTraitInfo;
    if let case Type::TraitObject(av) = a {
        let case Type::TraitObject(bv) = b else return false;
        return av.class == bv.class and av.mutable == bv.mutable
            and av.traitInfo == bv.traitInfo;
    }
    match a {
        case Type::Range { start: aStart, end: aEnd } => {
            let case Type::Range { start: bStart, end: bEnd } = b
                else return false;
            if let aValue = aStart {
                let bValue = bStart else return false;
                if not typesEqual(*aValue, *bValue) {
                    return false;
                }
            } else if bStart <> nil {
                return false;
            }
            if let aValue = aEnd {
                let bValue = bEnd else return false;
                return typesEqual(*aValue, *bValue);
            }
            return bEnd == nil;
        }
        case Type::Array(aa) => {
            let case Type::Array(ab) = b else return false;
            return aa.length == ab.length and typesEqual(*aa.item, *ab.item);
        }
        case Type::Optional(oa) => {

        }
        case Type::Fn(fa) => {
            let case Type::Fn(fb) = b else return false;
            return fnTypeEqual(fa, fb);
        }
        case Type::GenericDataApply(aa) => {
            let case Type::GenericDataApply(ab) = b else return false;
            if aa.template <> ab.template or aa.args.len <> ab.args.len {
                return false;
            }
            for i in 0..aa.args.len {
                if not typesEqual(*aa.args[i], *ab.args[i]) {
                    return false;
                }
            }
            return true;
        }
        else => return false,
    }
}

/// Return whether `ty` is a direct reference.
export fn isRefType(ty: Type) -> bool {
    match ty {
        case Type::Pointer { class: types::PointerClass::Ref, .. },
             Type::Slice { class: types::PointerClass::Ref, .. },
             Type::TraitObject { class: types::PointerClass::Ref, .. } => return true,
        case Type::Pointer(PointerType { class: types::PointerClass::Ref, .. }),
             Type::Slice(SliceType { class: types::PointerClass::Ref, .. }),
             Type::TraitObject(TraitObjectType { class: types::PointerClass::Ref, .. }) => return true,
        else => return false,
    }
}

/// Return whether a type contains a reference.
fn containsRef(ty: Type) -> bool {
    if isRefType(ty) {
        return true;
    }
    if let case Type::Pointer { target, .. } = ty {
        return containsRef(*target);
    if let case Type::Pointer(pointer) = ty {
        return containsRef(*pointer.target);
    }
    if let case Type::Slice { item, .. } = ty {
        return containsRef(*item);
    if let case Type::Slice(slice) = ty {
        return containsRef(*slice.item);
    }
    match ty {
        case Type::Array(array) => return containsRef(*array.item),
        case Type::Optional(inner) => return containsRef(*inner),
        case Type::GenericRecord(rec) => {
            for field in rec.fields {
                if containsRef(field.fieldType) {
                    return true;
                }
            }
            return false;
        }
        // Nominal declarations validate their own fields and variants.
        // Treating them as leaves also terminates recursive pointer types.
        case Type::Nominal(_) => return false,
        else => return false,
    }
}

/// Return whether a type is exact-linear.
export fn isLinear(ty: Type) -> bool {
    match ty {
        case Type::Pointer { class: types::PointerClass::Owned, .. },
             Type::Slice { class: types::PointerClass::Owned, .. },
             Type::TraitObject { class: types::PointerClass::Owned, .. } => return true,
        case Type::Pointer { class: types::PointerClass::Ref, .. },
             Type::Pointer { class: types::PointerClass::Unsafe, .. },
             Type::Slice { class: types::PointerClass::Ref, .. },
             Type::Slice { class: types::PointerClass::Unsafe, .. },
             Type::TraitObject { class: types::PointerClass::Ref, .. },
             Type::TraitObject { class: types::PointerClass::Unsafe, .. } => return false,
        case Type::Pointer(PointerType { class: types::PointerClass::Owned, .. }),
             Type::Slice(SliceType { class: types::PointerClass::Owned, .. }),
             Type::TraitObject(TraitObjectType { class: types::PointerClass::Owned, .. }) => return true,
        case Type::Pointer(PointerType { class: types::PointerClass::Ref, .. }),
             Type::Pointer(PointerType { class: types::PointerClass::Unsafe, .. }),
             Type::Slice(SliceType { class: types::PointerClass::Ref, .. }),
             Type::Slice(SliceType { class: types::PointerClass::Unsafe, .. }),
             Type::TraitObject(TraitObjectType { class: types::PointerClass::Ref, .. }),
             Type::TraitObject(TraitObjectType { class: types::PointerClass::Unsafe, .. }) => return false,

        case Type::Array(array) => return isLinear(*array.item),
        case Type::Optional(inner) => return isLinear(*inner),
        case Type::Nominal(NominalType::Record(recInfo)) => {
            if recInfo.declaredLinear {

}

/// Return whether `ty` is a direct unsafe pointer-like value.
fn isUnsafePointerType(ty: Type) -> bool {
    match ty {
        case Type::Pointer { class: types::PointerClass::Unsafe, .. },
             Type::Slice { class: types::PointerClass::Unsafe, .. },
             Type::TraitObject { class: types::PointerClass::Unsafe, .. } => return true,
        case Type::Pointer(PointerType { class: types::PointerClass::Unsafe, .. }),
             Type::Slice(SliceType { class: types::PointerClass::Unsafe, .. }),
             Type::TraitObject(TraitObjectType { class: types::PointerClass::Unsafe, .. }) => return true,
        else => return false,
    }
}

/// Get the record info from a record type.

    return recInfo;
}

/// Auto-dereference a type: if it's a pointer, return the target type.
export fn autoDeref(ty: Type) -> Type {
    if let case Type::Pointer { target, .. } = ty {
        return *target;
    if let case Type::Pointer(view) = ty {
        return *view.target;
    }
    return ty;
}

/// Get field info for a record-like type (records, slices) by field index.
export fn getRecordField(ty: Type, index: u32) -> ?RecordField {
    if let case Type::Slice { class, item, mutable } = ty {
    if let case Type::Slice(slice) = ty {
        match index {
            case 0 => return RecordField {
                name: PTR_FIELD,
                fieldType: Type::Pointer { class, target: item, mutable },
                fieldType: Type::Pointer(PointerType {
                    class: slice.class,
                    target: slice.item,
                    mutable: slice.mutable,
                }),
                offset: 0,
            },
            case 1 => return RecordField {
                name: LEN_FIELD,
                fieldType: Type::U32,

        return isComparable(*l, right);
    } else if let case Type::Optional(_) = right {
        return isComparable(right, left); // Flip order.
    }
    // Pointer comparisons ignore mutability.
    if let case Type::Pointer { target: lTarget, .. } = left {
        if let case Type::Pointer { target: rTarget, .. } = right {
            return typesEqual(*lTarget, *rTarget);
    if let case Type::Pointer(l) = left {
        if let case Type::Pointer(r) = right {
            return typesEqual(*l.target, *r.target);
        }
    }
    // Numeric types.
    if isNumericType(left) and isNumericType(right) {
        return true;

    return false;
}

/// Predicate that matches type symbols.
fn isTypeSymbol(sym: *mut Symbol) -> bool {
    if let case SymbolData::Type(_) = sym.data {
        return true;
    match sym.data {
        case SymbolData::Type(_), SymbolData::TypeParameter(_) => return true,
        else => return false,
    }
    return false;
}

/// Find a symbol by name in a specific scope, filtered by a predicate.
fn findInScope(scope: *Scope, name: *[u8], predicate: fn(*mut Symbol) -> bool) -> ?*mut Symbol {
    for i in 0..scope.symbolsLen {

    self: *mut Resolver,
    node: *ast::Node,
    access: ast::Access,
    scope: *Scope
) -> *mut Symbol throws (ResolveError) {
    // Handle `super` access by adjusting scope and node.
    // A specialized union application introduces the variant namespace.
    if let case ast::NodeValue::GenericApply(app) = access.parent.value {
        let nominal = try resolveGenericDataApply(self, access.parent, app, false);
        let case NominalType::Union(unionType) = *nominal
            else throw emitError(self, node, ErrorKind::InvalidScopeAccess);
        let variantName = try nodeName(self, access.child);
        let variant = try resolveUnionVariantAccess(
            self, node, access, unionType, variantName
        );
        setNodeType(self, node, Type::Nominal(nominal));
        return variant;
    }
    let mut startScope = scope;
    let mut pathNode = node;
    if let superAccess = try checkSuperAccess(self, node) {
        set startScope = superAccess.scope;
        set pathNode = superAccess.child;

        &path[1..],
        childSym
    );
}

/// Resolve a type name, which could be an identifier or scoped path.
fn resolveTypeName(self: *mut Resolver, node: *ast::Node) -> *NominalType throws (ResolveError) {
/// Return whether a declaration requires generic arguments.
fn isGenericDeclaration(node: *ast::Node) -> bool {
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findTypeSymbol(self.scope, name)
                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
            let case SymbolData::Type(ty) = sym.data
                else throw emitError(self, node, ErrorKind::Internal);

            setNodeSymbol(self, node, sym);
        case ast::NodeValue::RecordDecl(decl) => return decl.params.len > 0,
        case ast::NodeValue::UnionDecl(decl) => return decl.params.len > 0,
        case ast::NodeValue::FnDecl(decl) => return decl.params.len > 0,
        else => return false,
    }
}

            return ty;
/// Return whether a nominal type is present in the visit stack.
fn genericRootVisited(visit: ?*GenericRootVisit, nominal: *NominalType) -> bool {
    let mut cursor = visit;
    while let entry = cursor {
        if entry.nominal == nominal {
            return true;
        }
        case ast::NodeValue::ScopeAccess(access) => {
            let sym = try resolveAccess(self, node, access, self.scope);
            let case SymbolData::Type(ty) = sym.data
                else throw emitError(self, node, ErrorKind::Internal);

            setNodeSymbol(self, node, sym);

            return ty;
        }
        else => panic "resolveTypeName: unsupported node value",
        set cursor = entry.parent;
    }
    return false;
}

/// Visit a top-level declaration in the declaration phase.
/// This binds all names and analyzes signatures, types, and initializers.
/// Function bodies are deferred to the definition phase.
///
/// Nb. User-defined types are already handled by this point.
fn visitDecl(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
    match node.value {
        case ast::NodeValue::FnDecl(_),
             ast::NodeValue::ConstDecl(_),
             ast::NodeValue::Mod(_),
             ast::NodeValue::Use(_) => {
            // Handled in previous passes.
        }
        case ast::NodeValue::StaticDecl(_) => {
            try infer(self, node);
        }
/// Mark generic specializations reached through one concrete type.
fn markGenericDataTypeRootedInner(
    self: *mut Resolver,
    ty: Type,
    visited: ?*GenericRootVisit,
) -> bool {
    match ty {
        case Type::Pointer(pointer) =>
            return markGenericDataTypeRootedInner(self, *pointer.target, visited),
        case Type::Slice(slice) =>
            return markGenericDataTypeRootedInner(self, *slice.item, visited),
        case Type::Array(array) =>
            return markGenericDataTypeRootedInner(self, *array.item, visited),
        case Type::Optional(inner) =>
            return markGenericDataTypeRootedInner(self, *inner, visited),
        case Type::Fn(info) => {
            let mut changed = markGenericDataTypeRootedInner(
                self, *info.returnType, visited
            );
            for param in info.paramTypes {
                set changed = markGenericDataTypeRootedInner(
                    self, *param, visited
                ) or changed;
            }
            for thrown in info.throwList {
                set changed = markGenericDataTypeRootedInner(
                    self, *thrown, visited
                ) or changed;
            }
            return changed;
        }
        case Type::Range { start, end } => {
            let mut changed = false;
            if let value = start {
                set changed = markGenericDataTypeRootedInner(
                    self, *value, visited
                ) or changed;
            }
            if let value = end {
                set changed = markGenericDataTypeRootedInner(
                    self, *value, visited
                ) or changed;
            }
            return changed;
        }
        case Type::Nominal(nominal) => {
            let mut cursor = self.genericDataSpecializations;
            while let specialization = cursor {
                if specialization.nominal == nominal {
                    if not specialization.rooted {
                        set specialization.rooted = true;
                        return true;
                    }
                    return false;
                }
                set cursor = specialization.next;
            }
            if genericRootVisited(visited, nominal) {
                return false;
            }
            let visit = GenericRootVisit { nominal, parent: visited };
            let mut changed = false;
            match *nominal {
                case NominalType::Record(recordType) => {
                    for field in recordType.fields {
                        set changed = markGenericDataTypeRootedInner(
                            self, field.fieldType, &visit
                        ) or changed;
                    }
                }
                case NominalType::Union(unionType) => {
                    for variant in unionType.variants {
                        set changed = markGenericDataTypeRootedInner(
                            self, variant.valueType, &visit
                        ) or changed;
                    }
                }
                case NominalType::Placeholder(_) => {}
            }
            return changed;
        }
        else => return false,
    }
}

/// Mark generic data specializations reachable from a concrete type.
fn markGenericDataTypeRooted(self: *mut Resolver, ty: Type) -> bool {
    return markGenericDataTypeRootedInner(self, ty, nil);
}

/// Propagate explicit roots through arguments and specialized data members.
fn validateGenericDataRoots(self: *mut Resolver) throws (ResolveError) {
    loop {
        let mut changed = false;
        let mut cursor = self.genericDataSpecializations;
        while let specialization = cursor {
            if specialization.rooted {
                for arg in specialization.args {
                    set changed = markGenericDataTypeRooted(self, *arg) or changed;
                }
                match *specialization.nominal {
                    case NominalType::Record(recordType) => {
                        for field in recordType.fields {
                            set changed = markGenericDataTypeRooted(
                                self, field.fieldType
                            ) or changed;
                        }
                    }
                    case NominalType::Union(unionType) => {
                        for variant in unionType.variants {
                            set changed = markGenericDataTypeRooted(
                                self, variant.valueType
                            ) or changed;
                        }
                    }
                    case NominalType::Placeholder(_) => {}
                }
            }
            set cursor = specialization.next;
        }
        if not changed {
            break;
        }
    }
    let mut cursor = self.genericDataSpecializations;
    while let specialization = cursor {
        if not specialization.rooted {
            throw emitError(
                self, specialization.site, ErrorKind::GenericInstantiationRequired
            );
        }
        set cursor = specialization.next;
    }
}

/// Return whether two ordered generic argument lists are equivalent.
fn genericArgumentsEqual(left: *[*Type], right: *[*Type]) -> bool {
    if left.len <> right.len {
        return false;
    }
    for arg, i in right {
        if not typesEqual(*left[i], *arg) {
            return false;
        }
    }
    return true;
}

/// Look up mutable data specialization storage.
fn findGenericDataSpecializationMut(
    self: *Resolver,
    template: *Symbol,
    args: *[*Type],
) -> ?*mut GenericDataSpecialization {
    let mut cursor = self.genericDataSpecializations;
    while let entry = cursor {
        if entry.template == template and genericArgumentsEqual(entry.args, args) {
            return entry;
        }
        set cursor = entry.next;
    }
    return nil;
}

/// Look up a cached specialization by template and ordered arguments.
export fn findGenericDataSpecialization(
    self: *Resolver,
    template: *Symbol,
    args: *[*Type],
) -> ?*GenericDataSpecialization {
    return findGenericDataSpecializationMut(self, template, args);
}

/// Look up a generic data specialization by its concrete nominal identity.
export fn genericDataSpecializationForNominal(
    self: *Resolver,
    nominal: *NominalType,
) -> ?*GenericDataSpecialization {
    let mut cursor = self.genericDataSpecializations;
    while let specialization = cursor {
        if specialization.nominal == nominal {
            return specialization;
        }
        set cursor = specialization.next;
    }
    return nil;
}

/// Find the declaration symbol that owns an ordinary nominal type.
export fn symbolForNominal(
    self: *Resolver,
    nominal: *NominalType,
) -> ?*Symbol {
    for data in self.nodeData.entries {
        if let sym = data.sym {
            if let case SymbolData::Type(candidate) = sym.data; candidate == nominal {
                return sym;
            }
        }
    }
    return nil;
}

/// Resolve generic metadata lazily so applications are source-order independent.
fn ensureGenericDataTemplate(self: *mut Resolver, sym: *mut Symbol)
    throws (ResolveError)
{
    if genericTemplateFor(self, sym) <> nil {
        return;
    }
    let prevScope = self.scope;
    let prevMod = self.currentMod;
    if let mid = moduleIdForSymbol(self, sym) {
        if let moduleScope = self.moduleScopes[mid as u32] {
            set self.scope = moduleScope;
            set self.currentMod = mid;
        }
    }
    match sym.node.value {
        case ast::NodeValue::RecordDecl(decl) => {
            try resolveGenericDataTemplate(
                self, sym.node, decl.params, decl.fields, decl.derives
            ) catch e {
                set self.scope = prevScope;
                set self.currentMod = prevMod;
                throw e;
            };
        }
        case ast::NodeValue::UnionDecl(decl) => {
            try resolveGenericDataTemplate(
                self, sym.node, decl.params, decl.variants, decl.derives
            ) catch e {
                set self.scope = prevScope;
                set self.currentMod = prevMod;
                throw e;
            };
        }
        else => {
            set self.scope = prevScope;
            set self.currentMod = prevMod;
            throw emitError(self, sym.node, ErrorKind::GenericDataExpected);
        }
    }
    set self.scope = prevScope;
    set self.currentMod = prevMod;
}

/// Look up a possible inferred generic call target without emitting diagnostics.
fn findGenericCandidateSymbol(
    self: *Resolver,
    node: *ast::Node,
) -> ?*mut Symbol {
    if let sym = symbolFor(self, node) {
        return sym;
    }
    match node.value {
        case ast::NodeValue::Ident(name) =>
            return findAnySymbol(self.scope, name),
        case ast::NodeValue::ScopeAccess(access) => {
            let case ast::NodeValue::Ident(childName) = access.child.value
                else return nil;
            if let case ast::NodeValue::Super = access.parent.value {
                let current = module::get(self.moduleGraph, self.currentMod) else return nil;
                let parentId = current.parent else return nil;
                let parentScope = self.moduleScopes[parentId as u32] else return nil;
                return findSymbolInScope(parentScope, childName);
            }
            let sym = findGenericCandidateSymbol(self, access.parent) else return nil;
            let case SymbolData::Module { scope, .. } = sym.data else return nil;
            return findSymbolInScope(scope, childName);
        }
        else => return nil,
    }
}

/// Resolve a generic application's declaration symbol without requiring arguments.
fn resolveGenericTarget(
    self: *mut Resolver,
    node: *ast::Node,
) -> *mut Symbol throws (ResolveError) {
    if let existing = symbolFor(self, node) {
        return existing;
    }
    let mut sym: *mut Symbol = undefined;
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let found = findAnySymbol(self.scope, name) else {
                throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
            };
            set sym = found;
        }
        case ast::NodeValue::ScopeAccess(access) => {
            set sym = try resolveAccess(self, node, access, self.scope);
        }
        else => throw emitError(self, node, ErrorKind::GenericUnsupported),
    }
    if not isGenericDeclaration(sym.node) {
        throw emitError(self, node, ErrorKind::GenericUnsupported);
    }
    setNodeSymbol(self, node, sym);
    return sym;
}

/// Resolve a generic record or union target.
fn resolveGenericDataTarget(
    self: *mut Resolver,
    node: *ast::Node,
) -> *mut Symbol throws (ResolveError) {
    let sym = try resolveGenericTarget(self, node);
    let case SymbolData::Type(_) = sym.data
        else throw emitError(self, node, ErrorKind::GenericDataExpected);
    match sym.node.value {
        case ast::NodeValue::RecordDecl(_), ast::NodeValue::UnionDecl(_) => {}
        else => throw emitError(self, node, ErrorKind::GenericDataExpected),
    }
    return sym;
}

/// Build record fields and layout from ordinary or substituted member types.
fn buildRecordType(
    self: *mut Resolver,
    node: *ast::Node,
    fields: *mut [*ast::Node],
    labeled: bool,
    declaredLinear: bool,
    source: AggregateMemberSource,
) -> RecordType throws (ResolveError) {
    if fields.len > parser::MAX_RECORD_FIELDS {
        throw emitError(self, node, ErrorKind::Internal);
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut result: *mut [RecordField] = &mut [];
    let mut offset: u32 = 0;
    let mut alignment: u32 = 1;
    for fieldNode, i in fields {
        let case ast::NodeValue::RecordField {
            field: nameNode,
            type: typeNode,
            value,
        } = fieldNode.value else {
            panic "buildRecordType: invalid record field";
        };
        let mut fieldType: Type = undefined;
        match source {
            case AggregateMemberSource::Ordinary => {
                set fieldType = try resolveValueType(self, typeNode);
                try ensureStorableType(self, typeNode, fieldType);
                if let initializer = value {
                    let _ = try checkAssignable(self, initializer, fieldType);
                }
            }
            case AggregateMemberSource::Generic {
                members, substitution
            } => {
                set fieldType = try substituteType(
                    self, *members[i], substitution, typeNode
                );
                if hasUnresolvedNominalLayout(fieldType) {
                    throw emitError(
                        self, typeNode, ErrorKind::GenericRecursiveLayout
                    );
                }
                try ensureStorableType(self, typeNode, fieldType);
            }
        }
        try ensureTypeResolved(self, fieldType, typeNode);
        let layout = getTypeLayout(fieldType);
        set offset = mem::alignUp(offset, layout.alignment);
        let mut name: ?*[u8] = nil;
        if labeled {
            let requiredName = nameNode
                else panic "buildRecordType: labeled record field missing name";
            set name = try nodeName(self, requiredName);
        }
        result.append(RecordField {
            name,
            fieldType,
            offset: offset as i32,
        }, a);
        set offset += layout.size;
        set alignment = max(alignment, layout.alignment);
    }
    return RecordType {
        fields: &result[..],
        labeled,
        layout: Layout {
            size: mem::alignUp(offset, alignment),
            alignment,
        },
        declaredLinear,
    };
}

/// Build union variants and layout from ordinary or substituted member types.
fn buildUnionType(
    self: *mut Resolver,
    owner: *mut Symbol,
    decl: ast::UnionDecl,
    declaredLinear: bool,
    source: AggregateMemberSource,
) -> UnionType throws (ResolveError) {
    assert decl.variants.len <= MAX_UNION_VARIANTS,
        "buildUnionType: maximum union variants exceeded";
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut variants: *mut [UnionVariant] = &mut [];
    let mut iota: u32 = 0;
    let mut tagSubstitution: ?*Substitution = nil;
    if let case AggregateMemberSource::Generic {
        substitution, ..
    } = source {
        set tagSubstitution = substitution;
    }
    for variantNode, i in decl.variants {
        let case ast::NodeValue::UnionDeclVariant(variantDecl) = variantNode.value
            else panic "buildUnionType: invalid union variant";
        let mut valueType = Type::Void;
        match source {
            case AggregateMemberSource::Ordinary => {
                if let typeNode = variantDecl.type {
                    set valueType = try infer(self, typeNode);
                    try ensureStorableType(self, typeNode, valueType);
                }
                if let value = variantDecl.value {
                    let _ = try checkSizeInt(self, value);
                }
            }
            case AggregateMemberSource::Generic {
                members, substitution
            } => {
                set valueType = try substituteType(
                    self, *members[i], substitution, variantNode
                );
                if hasUnresolvedNominalLayout(valueType) {
                    throw emitError(
                        self, variantNode, ErrorKind::GenericRecursiveLayout
                    );
                }
                if let typeNode = variantDecl.type {
                    try ensureStorableType(self, typeNode, valueType);
                    try ensureTypeResolved(self, valueType, typeNode);
                }
            }
        }
        let name = try nodeName(self, variantDecl.name);
        let tag = try variantTag(
            self, variantDecl, &mut iota, tagSubstitution
        );
        let symbol = allocSymbol(
            self,
            SymbolData::Variant {
                type: valueType,
                decl: owner.node,
                ordinal: i,
                index: tag,
            },
            name,
            variantNode,
            0,
        );
        set symbol.moduleId = owner.moduleId;
        variants.append(UnionVariant { name, valueType, symbol }, a);
    }
    let info = computeUnionLayout(&variants[..]);
    return UnionType {
        variants: &variants[..],
        layout: info.layout,
        valOffset: info.valOffset,
        isAllVoid: info.isAllVoid,
        declaredLinear,
    };
}

/// Return one canonical concrete specialization for a generic data application.
fn specializeGenericData(
    self: *mut Resolver,
    site: *ast::Node,
    templateSym: *mut Symbol,
    args: *[*Type],
    rooted: bool,
) -> *mut NominalType throws (ResolveError) {
    if let existing = findGenericDataSpecializationMut(self, templateSym, args) {
        if rooted {
            set existing.rooted = true;
        }
        return existing.nominal;
    }
    if self.genericSpecializationCount >= MAX_GENERIC_SPECIALIZATIONS {
        throw emitError(self, site, ErrorKind::GenericSpecializationLimit);
    }
    set self.genericSpecializationCount += 1;
    let template = genericTemplateFor(self, templateSym)
        else throw emitError(self, site, ErrorKind::Internal);
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut storedArgs: *mut [*Type] = &mut [];
    for arg in args {
        storedArgs.append(arg, a);
    }
    let nominal = allocNominalType(
        self, NominalType::Placeholder(templateSym.node)
    );
    let specialization = try! alloc::alloc(
        &mut self.arena,
        @sizeOf(GenericDataSpecialization),
        @alignOf(GenericDataSpecialization),
    ) as *mut GenericDataSpecialization;
    set *specialization = GenericDataSpecialization {
        template: templateSym,
        args: &storedArgs[..],
        nominal,
        rooted,
        site,
        next: self.genericDataSpecializations,
    };
    set self.genericDataSpecializations = specialization;
    let sub = Substitution { params: template.params, args: &storedArgs[..] };
    let source = AggregateMemberSource::Generic {
        members: template.members,
        substitution: &sub,
    };
    match templateSym.node.value {
        case ast::NodeValue::RecordDecl(decl) => {
            let recordType = try buildRecordType(
                self,
                templateSym.node,
                decl.fields,
                decl.labeled,
                template.declaredLinear,
                source,
            );
            set *nominal = NominalType::Record(recordType);
        }
        case ast::NodeValue::UnionDecl(decl) => {
            let unionType = try buildUnionType(
                self, templateSym, decl, template.declaredLinear, source
            );
            set *nominal = NominalType::Union(unionType);
        }
        else => throw emitError(self, site, ErrorKind::GenericDataExpected),
    }
    return nominal;
}

/// Resolve one generic argument according to its declaration kind.
fn resolveGenericArgument(
    self: *mut Resolver,
    argNode: *ast::Node,
    param: *GenericParamType,
) -> Type throws (ResolveError) {
    if let constType = param.constType {
        let mut expr = argNode;
        if let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(name)) = argNode.value {
            set expr = name;
        }
        let actual = try visit(self, expr, *constType);
        if let value = constValueEntry(self, expr) {
            let case ConstValue::Int(int) = value
                else throw emitError(self, expr, ErrorKind::ConstExprRequired);
            if not validateConstIntRange(value, *constType) {
                throw emitError(self, expr, ErrorKind::NumericLiteralOverflow);
            }
            let _ = try expectAssignable(self, *constType, actual, expr);
            let case ConstValue::Int(canonical) = castConstInt(int, *constType)
                else throw emitError(self, expr, ErrorKind::Internal);
            return Type::ConstArgument { type: constType, value: canonical };
        }
        let _ = try expectAssignable(self, *constType, actual, expr);
        if isConstExpr(self, expr) and containsGenericConstExpr(self, expr) {
            return Type::GenericConstExpr { type: constType, expr };
        }
        throw emitError(self, expr, ErrorKind::ConstExprRequired);
    }
    if let case ast::NodeValue::TypeSig(_) = argNode.value {
        let arg = try resolveTypeSyntax(
            self, argNode, TypeSyntaxContext::Symbolic
        );
        return try materializeConcreteGenericData(self, arg, argNode);
    }
    throw emitError(self, argNode, ErrorKind::GenericUnsupported);
}

/// Resolve and canonicalize one generic data type application.
fn resolveGenericDataApply(
    self: *mut Resolver,
    node: *ast::Node,
    app: ast::GenericApply,
    rooted: bool,
) -> *mut NominalType throws (ResolveError) {
    let templateSym = try resolveGenericDataTarget(self, app.target);
    try ensureGenericDataTemplate(self, templateSym);
    let template = genericTemplateFor(self, templateSym)
        else throw emitError(self, node, ErrorKind::Internal);
    if app.args.len <> template.params.len {
        throw emitError(self, node, ErrorKind::GenericArgumentCount(CountMismatch {
            expected: template.params.len,
            actual: app.args.len,
        }));
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut args: *mut [*Type] = &mut [];
    for argNode, i in app.args {
        let argType = try resolveGenericArgument(self, argNode, template.params[i]);
        if containsGenericParameter(argType) {
            throw emitError(self, argNode, ErrorKind::GenericConcreteArgumentsRequired);
        }
        args.append(allocType(self, argType), a);
    }
    let nominal = try specializeGenericData(
        self, node, templateSym, &args[..], rooted
    );

    setNodeSymbol(self, node, templateSym);
    setNodeType(self, node, Type::Nominal(nominal));
    return nominal;
}

/// Return the function specialization list for lowering.
export fn genericFnSpecializations(
    self: *Resolver,
) -> ?*GenericFnSpecialization {
    return self.genericFnSpecializations;
}

/// Look up a canonical function specialization.
export fn findGenericFnSpecialization(
    self: *Resolver,
    template: *Symbol,
    args: *[*Type],
) -> ?*GenericFnSpecialization {
    let mut cursor = self.genericFnSpecializations;
    while let entry = cursor {
        if entry.template == template and genericArgumentsEqual(entry.args, args) {
            return entry;
        }
        set cursor = entry.next;
    }
    return nil;
}

/// Create or retrieve one concrete generic function specialization.
fn internGenericFnSpecialization(
    self: *mut Resolver,
    templateSym: *mut Symbol,
    args: *[*Type],
    site: *ast::Node,
    depth: u16,
) -> *GenericFnSpecialization throws (ResolveError) {
    if let existing = findGenericFnSpecialization(self, templateSym, args) {
        return existing;
    }
    if self.genericSpecializationCount >= MAX_GENERIC_SPECIALIZATIONS {
        throw emitError(self, site, ErrorKind::GenericSpecializationLimit);
    }
    set self.genericSpecializationCount += 1;
    let template = genericTemplateFor(self, templateSym)
        else throw emitError(self, site, ErrorKind::Internal);
    let signature = template.signature
        else throw emitError(self, site, ErrorKind::GenericFunctionExpected);
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut storedArgs: *mut [*Type] = &mut [];
    for arg in args {
        storedArgs.append(allocType(self, *arg), a);
    }
    let sub = Substitution { params: template.params, args: &storedArgs[..] };
    let concrete = try substituteType(self, Type::Fn(signature), &sub, site);
    let case Type::Fn(fnType) = concrete
        else throw emitError(self, site, ErrorKind::Internal);
    let _ = markGenericDataTypeRooted(self, concrete);
    let specialization = try! alloc::alloc(
        &mut self.arena,
        @sizeOf(GenericFnSpecialization),
        @alignOf(GenericFnSpecialization),
    ) as *mut GenericFnSpecialization;
    set *specialization = GenericFnSpecialization {
        template: templateSym,
        args: &storedArgs[..],
        fnType,
        site,
        state: GenericFnState::Queued,
        depth,
        typesMaterialized: false,
        next: self.genericFnSpecializations,
    };
    set self.genericFnSpecializations = specialization;
    return specialization;
}

/// Retain a generic call edge for package-wide specialization closure.
fn recordGenericFnDependency(
    self: *mut Resolver,
    node: *ast::Node,
    caller: ?*mut Symbol,
    callee: *mut Symbol,
    args: *[*Type],
    fnType: *FnType,
) {
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut storedArgs: *mut [*Type] = &mut [];
    for arg in args {
        storedArgs.append(allocType(self, *arg), a);
    }
    let dependency = try! alloc::alloc(
        &mut self.arena,
        @sizeOf(GenericFnDependency),
        @alignOf(GenericFnDependency),
    ) as *mut GenericFnDependency;
    set *dependency = GenericFnDependency {
        caller,
        callee,
        args: &storedArgs[..],
        site: node,
        next: self.genericFnDependencies,
    };
    set self.genericFnDependencies = dependency;
    setNodeSymbol(self, node, callee);
    setNodeType(self, node, Type::Fn(fnType));
    set self.nodeData.entries[node.id].extra =
        NodeExtra::GenericFnDependency(dependency);
}

/// Resolve a generic function application as a root, concrete call, or symbolic edge.
fn resolveGenericFnApply(
    self: *mut Resolver,
    node: *ast::Node,
    app: ast::GenericApply,
    rooted: bool,
) -> *FnType throws (ResolveError) {
    let templateSym = try resolveGenericTarget(self, app.target);
    let case SymbolData::Value { type: Type::Fn(_), .. } = templateSym.data
        else throw emitError(self, app.target, ErrorKind::GenericFunctionExpected);
    let template = genericTemplateFor(self, templateSym)
        else throw emitError(self, node, ErrorKind::Internal);
    let signature = template.signature
        else throw emitError(self, app.target, ErrorKind::GenericFunctionExpected);
    if app.args.len <> template.params.len {
        throw emitError(self, node, ErrorKind::GenericArgumentCount(CountMismatch {
            expected: template.params.len,
            actual: app.args.len,
        }));
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut args: *mut [*Type] = &mut [];
    let caller = currentGenericTemplateSymbol(self);
    for argNode, i in app.args {
        let argType = try resolveGenericArgument(self, argNode, template.params[i]);
        let symbolic = containsGenericParameter(argType);
        if symbolic and caller == nil {
            throw emitError(
                self, argNode, ErrorKind::GenericConcreteArgumentsRequired
            );
        }
        if not symbolic {
            for bound in template.params[i].bounds {
                if findInstance(self, bound, argType) == nil {
                    throw emitError(
                        self, argNode, ErrorKind::GenericBoundUnsatisfied(bound.name)
                    );
                }
            }
        }
        args.append(allocType(self, argType), a);
    }
    let sub = Substitution { params: template.params, args: &args[..] };
    let applied = try substituteType(self, Type::Fn(signature), &sub, node);
    let case Type::Fn(appliedFn) = applied
        else throw emitError(self, node, ErrorKind::Internal);
    if rooted {
        if caller <> nil {
            throw emitError(self, node, ErrorKind::GenericConcreteArgumentsRequired);
        }
        let specialization = try internGenericFnSpecialization(
            self, templateSym, &args[..], node, 0
        );
        setNodeSymbol(self, node, templateSym);
        setNodeType(self, node, Type::Fn(specialization.fnType));
        set self.nodeData.entries[node.id].extra =
            NodeExtra::GenericFnCall(specialization);
        return specialization.fnType;
    }
    if caller == nil {
        if let existing = findGenericFnSpecialization(self, templateSym, &args[..]) {
            setNodeSymbol(self, node, templateSym);
            setNodeType(self, node, Type::Fn(existing.fnType));
            set self.nodeData.entries[node.id].extra =
                NodeExtra::GenericFnCall(existing);
            return existing.fnType;
        }
    }
    recordGenericFnDependency(
        self, node, caller, templateSym, &args[..], appliedFn
    );
    return appliedFn;
}

/// Expand explicit roots through symbolic generic calls to a fixed point.
fn closeGenericFnSpecializations(self: *mut Resolver) throws (ResolveError) {
    loop {
        let mut queued: ?*mut GenericFnSpecialization = nil;
        let mut cursor = self.genericFnSpecializations;
        while let specialization = cursor {
            if let case GenericFnState::Queued = specialization.state {
                set queued = specialization;
                break;
            }
            set cursor = specialization.next;
        }
        let specialization = queued else break;
        set specialization.state = GenericFnState::Lowering;
        let callerTemplate = genericTemplateFor(self, specialization.template)
            else throw emitError(self, specialization.site, ErrorKind::Internal);
        let callerSub = Substitution {
            params: callerTemplate.params,
            args: specialization.args,
        };
        let mut edge = self.genericFnDependencies;
        while let dependency = edge {
            if dependency.caller == specialization.template {
                let a = alloc::arenaAllocator(&mut self.arena);
                let mut concreteArgs: *mut [*Type] = &mut [];
                for arg in dependency.args {
                    let concrete = try substituteType(
                        self, *arg, &callerSub, dependency.site
                    );
                    if containsGenericParameter(concrete) {
                        throw emitError(
                            self,
                            dependency.site,
                            ErrorKind::GenericConcreteArgumentsRequired,
                        );
                    }
                    concreteArgs.append(allocType(self, concrete), a);
                }
                let calleeTemplate = genericTemplateFor(self, dependency.callee)
                    else throw emitError(
                        self, dependency.site, ErrorKind::Internal
                    );
                for arg, i in concreteArgs {
                    for bound in calleeTemplate.params[i].bounds {
                        if findInstance(self, bound, *arg) == nil {
                            throw emitError(
                                self,
                                dependency.site,
                                ErrorKind::GenericBoundUnsatisfied(bound.name),
                            );
                        }
                    }
                }
                let mut callee = findGenericFnSpecialization(
                    self, dependency.callee, &concreteArgs[..]
                );
                if callee == nil {
                    if specialization.depth >= MAX_GENERIC_SPECIALIZATION_DEPTH {
                        throw emitError(
                            self,
                            dependency.site,
                            ErrorKind::GenericSpecializationChain,
                        );
                    }
                    set callee = try internGenericFnSpecialization(
                        self,
                        dependency.callee,
                        &concreteArgs[..],
                        dependency.site,
                        specialization.depth + 1,
                    );
                }
                let concreteCallee = callee
                    else throw emitError(
                        self, dependency.site, ErrorKind::Internal
                    );
                let resolution = try! alloc::alloc(
                    &mut self.arena,
                    @sizeOf(GenericFnDependencyResolution),
                    @alignOf(GenericFnDependencyResolution),
                ) as *mut GenericFnDependencyResolution;
                set *resolution = GenericFnDependencyResolution {
                    dependency,
                    caller: specialization,
                    callee: concreteCallee,
                    next: self.genericFnDependencyResolutions,
                };
                set self.genericFnDependencyResolutions = resolution;
            }
            set edge = dependency.next;
        }
        set specialization.state = GenericFnState::Complete;
    }

    // Non-generic calls may only select entries made reachable by the closure.
    let mut edge = self.genericFnDependencies;
    while let dependency = edge {
        if dependency.caller == nil {
            let specialization = findGenericFnSpecialization(
                self, dependency.callee, dependency.args
            ) else {
                throw emitError(
                    self,
                    dependency.site,
                    ErrorKind::GenericFunctionInstantiationRequired,
                );
            };
            set self.nodeData.entries[dependency.site.id].extra =
                NodeExtra::GenericFnCall(specialization);
            set self.nodeData.entries[dependency.site.id].ty =
                Type::Fn(specialization.fnType);
        }
        set edge = dependency.next;
    }
}

/// Materialize symbolic body types for newly closed generic functions.
///
/// Each specialization is processed once, while its package's specialization
/// limit is active. This closes resolver-owned generic data caches before
/// lowering receives an immutable resolver.
fn materializeGenericFnTypeUses(self: *mut Resolver) throws (ResolveError) {
    let mut cursor = self.genericFnSpecializations;
    while let specialization = cursor {
        if specialization.typesMaterialized {
            set cursor = specialization.next;
            continue;
        }
        let template = genericTemplateForMut(
            self, specialization.template
        ) else throw emitError(
            self, specialization.site, ErrorKind::Internal
        );
        let sub = Substitution {
            params: template.params,
            args: specialization.args,
        };
        for typeUse in template.typeUses {
            let concrete = try substituteType(
                self, typeUse.ty, &sub, typeUse.site
            );
            if containsGenericParameter(concrete) {
                throw emitError(
                    self,
                    typeUse.site,
                    ErrorKind::GenericConcreteArgumentsRequired,
                );
            }
            let _ = markGenericDataTypeRooted(self, concrete);
        }
        set specialization.typesMaterialized = true;
        set cursor = specialization.next;
    }
}

/// Select the concrete callee for a symbolic edge while lowering a specialization.
export fn genericFnSpecializationForDependency(
    self: *Resolver,
    dependency: *GenericFnDependency,
    caller: *GenericFnSpecialization,
) -> ?*GenericFnSpecialization {
    let mut resolution = self.genericFnDependencyResolutions;
    while let entry = resolution {
        if entry.dependency == dependency and entry.caller == caller {
            return entry.callee;
        }
        set resolution = entry.next;
    }
    return nil;
}

/// Resolve a type name, which could be an identifier or scoped path.
fn resolveTypeName(self: *mut Resolver, node: *ast::Node) -> *NominalType throws (ResolveError) {
    match node.value {
        case ast::NodeValue::Ident(name) => {
            let sym = findTypeSymbol(self.scope, name)
                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
            let case SymbolData::Type(ty) = sym.data
                else throw emitError(self, node, ErrorKind::Internal);
            if isGenericDeclaration(sym.node) {
                throw emitError(self, node, ErrorKind::GenericArgumentsRequired);
            }

            setNodeSymbol(self, node, sym);

            return ty;
        }
        case ast::NodeValue::ScopeAccess(access) => {
            let sym = try resolveAccess(self, node, access, self.scope);
            let case SymbolData::Type(ty) = sym.data
                else throw emitError(self, node, ErrorKind::Internal);
            if isGenericDeclaration(sym.node) {
                throw emitError(self, node, ErrorKind::GenericArgumentsRequired);
            }

            setNodeSymbol(self, node, sym);

            return ty;
        }
        case ast::NodeValue::GenericApply(app) =>
            return try resolveGenericDataApply(self, node, app, false),
        else => panic "resolveTypeName: unsupported node value",
    }
}

/// Visit a top-level declaration in the declaration phase.
/// This binds all names and analyzes signatures, types, and initializers.
/// Function bodies are deferred to the definition phase.
///
/// Nb. User-defined types are already handled by this point.
fn visitDecl(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
    match node.value {
        case ast::NodeValue::FnDecl(_),
             ast::NodeValue::ConstDecl(_),
             ast::NodeValue::Mod(_),
             ast::NodeValue::Use(_) => {
            // Handled in previous passes.
        }
        case ast::NodeValue::StaticDecl(_) => {
            try infer(self, node);
        }
        case ast::NodeValue::InstanceDecl { traitName, targetType, methods } => {
            try resolveInstanceDecl(self, node, traitName, targetType, methods);
        }
        case ast::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, attrs } => {
            try resolveMethodDecl(self, node, name, receiverName, receiverType, sig, attrs);
        }
        case ast::NodeValue::Instantiate(applications) => {
            for application in applications {
                let case ast::NodeValue::GenericApply(app) = application.value
                    else throw emitError(self, application, ErrorKind::GenericUnsupported);
                if self.genericRoots >= MAX_GENERIC_ROOTS {
                    throw emitError(self, application, ErrorKind::GenericRootLimit);
                }
                set self.genericRoots += 1;
                let target = try resolveGenericTarget(self, app.target);
                match target.data {
                    case SymbolData::Type(_) => {
                        let _ = try resolveGenericDataApply(self, application, app, true);
                    }
                    case SymbolData::Value { type: Type::Fn(_), .. } => {
                        let _ = try resolveGenericFnApply(self, application, app, true);
                    }
                    else => {
                        throw emitError(self, app.target, ErrorKind::GenericUnsupported);
                    }
                }
            }
            setNodeType(self, node, Type::Void);
        }
        else => {
            // Ignore non-declaration nodes.
        }
    }
}

/// Reject nested references while allowing a direct parameter reference.
fn validateValueTypeReferences(self: *mut Resolver, node: *ast::Node, ty: Type)
    throws (ResolveError)
{
    if isRefType(ty) {
        if let case Type::Pointer { target, .. } = ty {
            if containsRef(*target) {
        if let case Type::Pointer(pointer) = ty {
            if containsRef(*pointer.target) {
                throw emitError(self, node, ErrorKind::InvalidRefPosition);
            }
        } else if let case Type::Slice { item, .. } = ty {
            if containsRef(*item) {
        } else if let case Type::Slice(slice) = ty {
            if containsRef(*slice.item) {
                throw emitError(self, node, ErrorKind::InvalidRefPosition);
            }
        }
    } else if containsRef(ty) {
        throw emitError(self, node, ErrorKind::InvalidRefPosition);

    }
    try validateValueTypeReferences(self, node, ty);
    return ty;
}

/// Resolve a nested value type according to its syntax context.
fn resolveContextualValueType(
    self: *mut Resolver,
    node: *ast::Node,
    context: TypeSyntaxContext,
) -> Type throws (ResolveError) {
    if let case TypeSyntaxContext::Symbolic = context {
        return try resolveTypeSyntax(self, node, context);
    }
    return try resolveValueType(self, node);
}

/// Analyze a node's type and check that it can be assigned to the expected type.
fn checkAssignable(self: *mut Resolver, node: *ast::Node, expected: Type) -> Type throws (ResolveError) {
    let actual = try visit(self, node, expected);
    let _ = try expectAssignable(self, expected, actual, node);
    return actual;

        case ast::NodeValue::Ident(name) => {
            let sym = findAnySymbol(self.scope, name)
                else throw emitError(self, node, ErrorKind::UnresolvedSymbol(name));
            setNodeSymbol(self, node, sym);
            match sym.data {
                case SymbolData::Value { type, .. } =>
                    return setNodeType(self, node, type),
                case SymbolData::Value { type, .. } => {
                    if isGenericDeclaration(sym.node) {
                        throw emitError(self, node, ErrorKind::GenericArgumentsRequired);
                    }
                    return setNodeType(self, node, type);
                }
                case SymbolData::Constant { type, value } => {
                    if let val = value {
                        setNodeConstValue(self, node, val);
                    }
                    return setNodeType(self, node, type);
                },
                case SymbolData::Type(t) =>
                    return setNodeType(self, node, Type::Nominal(t)),
                case SymbolData::Type(t) => {
                    if isGenericDeclaration(sym.node) {
                        throw emitError(self, node, ErrorKind::GenericArgumentsRequired);
                    }
                    return setNodeType(self, node, Type::Nominal(t));
                }
                case SymbolData::TypeParameter(param) => {
                    set *param.used = true;
                    return setNodeType(self, node, Type::Parameter(param));
                }
                case SymbolData::ConstParameter(param) => {
                    set *param.used = true;
                    let ty = param.constType else {
                        throw emitError(self, node, ErrorKind::Internal);
                    };
                    return setNodeType(self, node, *ty);
                }
                case SymbolData::Variant { .. } =>
                    return Type::Void,
                case SymbolData::Module { .. } =>
                    throw emitError(self, node, ErrorKind::UnexpectedModuleName),
                case SymbolData::Trait(_) =>
                    throw emitError(self, node, ErrorKind::UnexpectedTraitName),
            }
        },
        case ast::NodeValue::Call(call) => return try resolveCall(self, node, call, CallCtx::Normal),
        case ast::NodeValue::Call(call) =>
            return try resolveCall(self, node, call, CallCtx::Normal, hint),
        case ast::NodeValue::FieldAccess(access) => return try resolveFieldAccess(self, node, access),
        case ast::NodeValue::BinOp(binop) => return try resolveBinOp(self, node, binop),
        case ast::NodeValue::Block(block) => return try resolveBlock(self, node, block),
        case ast::NodeValue::FnDecl(decl) => {
            if decl.params.len > 0 {
                throw emitError(self, node, ErrorKind::GenericFnNested);
            }
            throw emitError(self, node, ErrorKind::UnexpectedNode(node));
        }
        case ast::NodeValue::Let(decl) => return try resolveLet(self, node, decl),
        case ast::NodeValue::ConstDecl(decl) => return try resolveConstOrStatic(
            self, node, decl.ident, decl.type, decl.value, decl.attrs, true
        ),
        case ast::NodeValue::StaticDecl(decl) => return try resolveConstOrStatic(

        case ast::NodeValue::Assign(assign) => return try resolveAssign(self, node, assign),
        case ast::NodeValue::RecordLit(lit) => return try resolveRecordLit(self, node, lit, hint),
        case ast::NodeValue::ArrayLit(items) => return try resolveArrayLit(self, node, items, hint),
        case ast::NodeValue::ArrayRepeatLit(lit) => return try resolveArrayRepeat(self, node, lit, hint),
        case ast::NodeValue::Subscript { container, index } => return try resolveSubscript(self, node, container, index),
        case ast::NodeValue::GenericApply(app) => {
            let fnType = try resolveGenericFnApply(self, node, app, false);
            return setNodeType(self, node, Type::Fn(fnType));
        }
        case ast::NodeValue::Instantiate(_) =>
            throw emitError(self, node, ErrorKind::GenericUnsupported),
        case ast::NodeValue::ScopeAccess(access) => return try resolveScopeAccess(self, node, access),
        case ast::NodeValue::AddressOf(addr) => return try resolveAddressOf(self, node, addr, hint),
        case ast::NodeValue::Deref(target) => return try resolveDeref(self, node, target, hint),
        case ast::NodeValue::As(expr) => return try resolveAs(self, node, expr),
        case ast::NodeValue::Range(range) => return try resolveRange(self, node, range),
        case ast::NodeValue::Try(expr) => return try resolveTry(self, node, expr, hint),
        case ast::NodeValue::Return { value } => return try resolveReturn(self, node, value),
        case ast::NodeValue::Throw { expr } => return try resolveThrow(self, node, expr),
        case ast::NodeValue::Panic { message } => {
            try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.
            // TODO: Have easy access to string type.
            try visitOptional(self, message, Type::Slice(SliceType {
                class: types::PointerClass::Owned,
                item: allocType(self, Type::U8),
                mutable: false,
            });
            }));
            return setNodeType(self, node, Type::Never);
        },
        case ast::NodeValue::Assert { condition, message } => {
            try visit(self, condition, Type::Bool);
            try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.
            // TODO: Have easy access to string type.
            try visitOptional(self, message, Type::Slice(SliceType {
                class: types::PointerClass::Owned,
                item: allocType(self, Type::U8),
                mutable: false,
            });
            }));
            return setNodeType(self, node, Type::Void);
        },
        case ast::NodeValue::UnOp(unop) => return try resolveUnOp(self, node, unop),
        case ast::NodeValue::ExprStmt(expr) => {
            // Pass `Void` as expected type to indicate value is discarded.
            let exprTy = try visit(self, expr, Type::Void);
            return setNodeType(self, node, unifyBranches(exprTy, Type::Void));
        },
        case ast::NodeValue::TypeSig(sig) => return try inferTypeSig(self, node, sig),
        case ast::NodeValue::TypeSig(_) =>
            return try resolveTypeSyntax(self, node, TypeSyntaxContext::Concrete),
        case ast::NodeValue::Super => {
            // `super` by itself is invalid, must be used in scope access.
            throw emitError(self, node, ErrorKind::InvalidModulePath);
        },
        case ast::NodeValue::Nil => {

            return setNodeType(self, node, Type::U8);
        }
        case ast::NodeValue::String(text) => {
            setNodeConstValue(self, node, ConstValue::String(text));
            let byteTy = allocType(self, Type::U8);
            let sliceTy = allocType(self, Type::Slice {
            let sliceTy = allocType(self, Type::Slice(SliceType {
                class: types::PointerClass::Owned,
                item: byteTy,
                mutable: false,
            });
            }));
            return setNodeType(self, node, *sliceTy);
        },
        case ast::NodeValue::Number(lit) => {
            setNodeConstValue(self, node, ConstValue::Int(ConstInt {
                magnitude: lit.magnitude,

        },
        case ast::NodeValue::AddressOf(addr) => {
            let ty = typeFor(self, node) else {
                return false;
            };
            if let case Type::Slice { .. } = ty {
            if let case Type::Slice(_) = ty {
                return isConstExpr(self, addr.target);
            }
            return false;
        },
        case ast::NodeValue::RecordLit(lit) => {

            // Identifiers and scope accesses referencing constants, union
            // variants, or function values are constant expressions.
            if let sym = symbolFor(self, node) {
                match sym.data {
                    case SymbolData::Variant { .. },
                         SymbolData::Constant { .. } => return true,
                         SymbolData::Constant { .. },
                         SymbolData::ConstParameter(_) => return true,
                    case SymbolData::Value { type, .. } => {
                        if let case Type::Fn(_) = type {
                            return true;
                        }
                    }

        case IntegerRange::Signed { bits, .. } =>
            return ConstValue::Int(constIntFromBits(raw, bits, true)),
    }
}

/// Return whether a constant expression depends on a rigid constant parameter.
fn containsGenericConstExpr(self: *Resolver, node: *ast::Node) -> bool {
    match node.value {
        case ast::NodeValue::Ident(_), ast::NodeValue::ScopeAccess(_) => {
            let sym = symbolFor(self, node) else return false;
            if let case SymbolData::ConstParameter(_) = sym.data {
                return true;
            }
            return false;
        }
        case ast::NodeValue::BinOp(binop) =>
            return containsGenericConstExpr(self, binop.left) or
                   containsGenericConstExpr(self, binop.right),
        case ast::NodeValue::UnOp(unop) =>
            return containsGenericConstExpr(self, unop.value),
        case ast::NodeValue::As(expr) =>
            return containsGenericConstExpr(self, expr.value),
        else => return false,
    }
}

/// Evaluate an integer constant expression after replacing rigid parameters.
fn constValueWithSubstitution(
    self: *Resolver,
    node: *ast::Node,
    sub: *Substitution,
) -> ?ConstValue {
    if let value = constValueEntry(self, node) {
        return value;
    }
    match node.value {
        case ast::NodeValue::Ident(_), ast::NodeValue::ScopeAccess(_) => {
            let sym = symbolFor(self, node) else return nil;
            let case SymbolData::ConstParameter(param) = sym.data else return nil;
            let arg = substitutionArg(sub, param);
            let case Type::ConstArgument { value, .. } = arg else return nil;
            return ConstValue::Int(value);
        }
        case ast::NodeValue::BinOp(binop) => {
            let left = constValueWithSubstitution(self, binop.left, sub)
                else return nil;
            let right = constValueWithSubstitution(self, binop.right, sub)
                else return nil;
            let case ConstValue::Int(leftInt) = left else return nil;
            let case ConstValue::Int(rightInt) = right else return nil;
            return foldIntBinOp(binop.op, leftInt, rightInt);
        }
        case ast::NodeValue::UnOp(unop) => {
            let value = constValueWithSubstitution(self, unop.value, sub)
                else return nil;
            match unop.op {
                case ast::UnaryOp::Not => {
                    let case ConstValue::Bool(v) = value else return nil;
                    return ConstValue::Bool(not v);
                }
                case ast::UnaryOp::Neg => {
                    let case ConstValue::Int(v) = value else return nil;
                    return constInt(v.magnitude, v.bits, true, not v.negative);
                }
                case ast::UnaryOp::BitNot => {
                    let case ConstValue::Int(v) = value else return nil;
                    return ConstValue::Int(
                        constIntFromSigned(
                            -(constIntToSigned(v) + 1), v.bits, v.signed
                        )
                    );
                }
            }
        }
        case ast::NodeValue::As(expr) => {
            let value = constValueWithSubstitution(self, expr.value, sub)
                else return nil;
            let case ConstValue::Int(v) = value else return nil;
            let target = typeFor(self, node) else return nil;
            if integerRange(target) == nil {
                return nil;
            }
            return castConstInt(v, target);
        }
        else => return nil,
    }
}

/// Evaluate and canonicalize an integer constant under a generic substitution.
///
/// This read-only query is used by lowering to reconstruct concrete structural
/// types in its own arena after resolution has validated every specialization.
export fn constIntWithSubstitution(
    self: *Resolver,
    node: *ast::Node,
    target: Type,
    sub: *Substitution,
) -> ?ConstInt {
    let value = constValueWithSubstitution(self, node, sub) else return nil;
    let case ConstValue::Int(int) = value else return nil;
    if not validateConstIntRange(value, target) {
        return nil;
    }
    let case ConstValue::Int(canonical) = castConstInt(int, target)
        else return nil;
    return canonical;
}

/// Return the constant `u32` value for a slice bound when known.
fn constSliceIndex(self: *mut Resolver, node: *ast::Node) -> ?u32 {
    let value = constValueEntry(self, node)
        else return nil;
    let case ConstValue::Int(int) = value

        if not isConstExpr(self, valueNode) {
            throw emitError(self, valueNode, ErrorKind::ConstExprRequired);
        }
        try bindValueIdent(self, ident, node, bindingTy, true, 0, attrs);
    }
    setNodeType(self, valueNode, bindingTy);
    setNodeType(self, valueNode, bindingTy);

    return Type::Void;
}

/// Bind one declaration's rigid generic parameters in its child scope.
fn resolveGenericParams(
    self: *mut Resolver,
    owner: *ast::Node,
    nodes: *mut [*ast::Node],
) -> *[*GenericParamType] throws (ResolveError) {
    if nodes.len > MAX_GENERIC_PARAMS {
        throw emitError(self, owner, ErrorKind::GenericParameterLimit);
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut result: *mut [*GenericParamType] = &mut [];
    for paramNode, index in nodes {
        let case ast::NodeValue::GenericParam(param) = paramNode.value
            else throw emitError(self, paramNode, ErrorKind::Internal);
        let mut paramName: *[u8] = undefined;
        let mut nameNode: *ast::Node = undefined;
        let mut traitBounds: *mut [*TraitType] = &mut [];
        let mut constType: ?*Type = nil;
        match param {
            case ast::GenericParam::Const { name, type } => {
                set nameNode = name;
                set paramName = try nodeName(self, name);
                let ty = try resolveValueType(self, type);
                if integerRange(ty) == nil or ty == Type::Int {
                    throw emitError(self, type, ErrorKind::GenericConstUnsupported);
                }
                set constType = allocType(self, ty);
            }
            case ast::GenericParam::Type { name, bounds } => {
                set nameNode = name;
                set paramName = try nodeName(self, name);
                for bound in bounds {
                    let boundSym = try resolveNamePath(self, bound);
                    let case SymbolData::Trait(traitInfo) = boundSym.data else {
                        throw emitError(self, bound, ErrorKind::GenericBoundNotTrait);
                    };
                    setNodeSymbol(self, bound, boundSym);
                    traitBounds.append(traitInfo, a);
                }
            }
        }
        let used = try! alloc::alloc(
            &mut self.arena, @sizeOf(bool), @alignOf(bool)
        ) as *mut bool;
        set *used = false;
        let p = try! alloc::alloc(
            &mut self.arena,
            @sizeOf(GenericParamType),
            @alignOf(GenericParamType),
        ) as *mut GenericParamType;
        set *p = GenericParamType {
            owner,
            node: paramNode,
            name: paramName,
            index,
            bounds: &traitBounds[..],
            used,
            constType,
        };
        let data = SymbolData::ConstParameter(p) if constType <> nil
            else SymbolData::TypeParameter(p);
        let sym = try bindIdent(
            self, paramName, paramNode, data, 0, self.scope
        );
        setNodeSymbol(self, nameNode, sym);
        if let ty = constType {
            setNodeType(self, nameNode, *ty);
            setNodeType(self, paramNode, *ty);
        } else {
            setNodeType(self, nameNode, Type::Parameter(p));
            setNodeType(self, paramNode, Type::Parameter(p));
        }
        result.append(p, a);
    }
    return &result[..];
}

/// Retrieve sparse metadata for a generic declaration symbol.
export fn genericTemplateFor(self: *Resolver, symbol: *Symbol) -> ?*GenericTemplate {
    let mut cursor = self.genericTemplates;
    while let template = cursor {
        if template.symbol == symbol {
            return template;
        }
        set cursor = template.next;
    }
    return nil;
}

/// Retrieve mutable sparse metadata for resolver-owned bookkeeping.
fn genericTemplateForMut(
    self: *mut Resolver,
    symbol: *Symbol,
) -> ?*mut GenericTemplate {
    let mut cursor = self.genericTemplates;
    while let template = cursor {
        if template.symbol == symbol {
            return template;
        }
        set cursor = template.next;
    }
    return nil;
}

/// Return the generic template whose symbolic body is currently being checked.
fn currentGenericTemplateSymbol(self: *Resolver) -> ?*mut Symbol {
    let current = self.currentGenericTemplate else return nil;
    return current.symbol;
}

/// Attach generic metadata without increasing every symbol's allocation.
fn registerGenericTemplate(
    self: *mut Resolver,
    template: GenericTemplate,
) -> *mut GenericTemplate {
    let entry = try! alloc::alloc(
        &mut self.arena,
        @sizeOf(GenericTemplate),
        @alignOf(GenericTemplate),
    ) as *mut GenericTemplate;
    set *entry = template;
    set entry.next = self.genericTemplates;
    set self.genericTemplates = entry;
    return entry;
}

/// Resolve a function signature type without laying out generic aggregates.
fn resolveFnSignatureType(
    self: *mut Resolver,
    node: *ast::Node,
    context: TypeSyntaxContext,
) -> Type throws (ResolveError) {
    if let case TypeSyntaxContext::Symbolic = context {
        return try resolveTypeSyntax(self, node, context);
    }
    return try infer(self, node);
}

    return Type::Void;
/// Resolve and bind a function parameter using its signature mode.
fn resolveFnSignatureParam(
    self: *mut Resolver,
    node: *ast::Node,
    context: TypeSyntaxContext,
) -> Type throws (ResolveError) {
    if let case TypeSyntaxContext::Concrete = context {
        return try infer(self, node);
    }
    let case ast::NodeValue::FnParam(param) = node.value
        else throw emitError(self, node, ErrorKind::Internal);
    let ty = try resolveTypeSyntax(self, param.type, context);
    let _ = try bindValueIdent(self, param.name, node, ty, false, 0, 0);
    return setNodeType(self, node, ty);
}

/// Analyze a function declaration signature and bind the function name.
fn resolveFnDecl(self: *mut Resolver, node: *ast::Node, decl: ast::FnDecl) -> Type
    throws (ResolveError)
{
    let attrMask = resolveAttributes(self, decl.attrs);
    let mut retTy = Type::Void;
    if let retNode = decl.sig.returnType {
        set retTy = try infer(self, retNode);
        try ensureStorableType(self, retNode, retTy);
    if decl.params.len > 0 {
        if self.currentFn <> nil {
            throw emitError(self, node, ErrorKind::GenericFnNested);
        }
        if ast::hasAttribute(attrMask, ast::Attribute::Extern)
            or ast::hasAttribute(attrMask, ast::Attribute::Default)
            or ast::hasAttribute(attrMask, ast::Attribute::Intrinsic)
        {
            throw emitError(self, node, ErrorKind::GenericFnAttribute);
        }
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];
    let mut throwList: *mut [*Type] = &mut [];
    let mut fnType = FnType {
        paramTypes: &[],
        returnType: allocType(self, retTy),
        returnType: allocType(self, Type::Void),
        throwList: &[],
        isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
        localCount: 0,
    };
    // Enter the function scope to process parameters.
    enterFn(self, node, &fnType);

    let genericParams = try resolveGenericParams(self, node, decl.params) catch e {
        exitFn(self);
        throw e;
    };
    let typeContext = TypeSyntaxContext::Symbolic if genericParams.len > 0
        else TypeSyntaxContext::Concrete;
    if let retNode = decl.sig.returnType {
        let retTy = try resolveFnSignatureType(
            self, retNode, typeContext
        ) catch e {
            exitFn(self);
            throw e;
        };
        try ensureStorableType(self, retNode, retTy) catch e {
            exitFn(self);
            throw e;
        };
        set fnType.returnType = allocType(self, retTy);
    }
    if decl.sig.params.len > MAX_FN_PARAMS {
        exitFn(self);
        throw emitError(self, node, ErrorKind::FnParamOverflow(CountMismatch {
            expected: MAX_FN_PARAMS,
            actual: decl.sig.params.len,
        }));
    }
    for paramNode in decl.sig.params {
        let paramTy = try infer(self, paramNode) catch e {
        let paramTy = try resolveFnSignatureParam(
            self, paramNode, typeContext
        ) catch e {
            exitFn(self);
            throw e;
        };
        paramTypes.append(allocType(self, paramTy), a);
    }

            expected: MAX_FN_THROWS,
            actual: decl.sig.throwList.len,
        }));
    }
    for throwNode in decl.sig.throwList {
        let throwTy = try infer(self, throwNode) catch e {
        let throwTy = try resolveFnSignatureType(
            self, throwNode, typeContext
        ) catch e {
            exitFn(self);
            throw e;
        };
        try ensureStorableType(self, throwNode, throwTy) catch e {
            exitFn(self);
            throw e;
        };
        throwList.append(allocType(self, throwTy), a);
        try ensureStorableType(self, throwNode, throwTy);
    }
    exitFn(self);
    set fnType.paramTypes = &paramTypes[..];
    set fnType.throwList = &throwList[..];

    // Bind the function name.
    let ty = Type::Fn(allocFnType(self, fnType));
    let fnInfo = allocFnType(self, fnType);
    let ty = Type::Fn(fnInfo);
    let sym = try bindValueIdent(self, decl.name, node, ty, false, 0, attrMask)
        else throw emitError(self, node, ErrorKind::ExpectedIdentifier);

    if genericParams.len > 0 {
        registerGenericTemplate(self, GenericTemplate {
            symbol: sym,
            params: genericParams,
            signature: fnInfo,
            members: &[],
            declaredLinear: false,
            bodyResolved: false,
            typeUses: &mut [],
            next: nil,
        });
    }
    return ty;
}

/// Analyze a function body.
fn resolveFnDeclBody(self: *mut Resolver, node: *ast::Node, decl: ast::FnDecl) throws (ResolveError) {
    let sym = symbolFor(self, node) else {
        // The function declaration failed to type check, therefore
        // no symbol was associated with it.
        return;
    };
    let generic = genericTemplateForMut(self, sym);
    if let template = generic {
        if template.bodyResolved {
            return;
        }
        set template.bodyResolved = true;
    }
    let case SymbolData::Value { type: Type::Fn(fnType), .. } = sym.data else {
        panic "resolveFnDeclBody: unexpected symbol data for function";
    };
    let retTy = *fnType.returnType;
    let isExtern = ast::hasAttribute(sym.attrs, ast::Attribute::Extern);

        }
        if isUnsafe {
            set self.unsafeDepth += 1;
        }
        enterFn(self, node, fnType); // Enter function scope for body analysis.
        set self.currentGenericTemplate = generic;

        let bodyTy = try checkAssignable(self, body, Type::Void) catch e {
            set self.currentGenericTemplate = nil;
            exitFn(self);
            if isUnsafe { set self.unsafeDepth -= 1; }
            throw e;
        };
        if retTy <> Type::Void and bodyTy <> Type::Never {
            set self.currentGenericTemplate = nil;
            exitFn(self);
            if isUnsafe { set self.unsafeDepth -= 1; }
            throw emitError(self, body, ErrorKind::FnMissingReturn);
        }
        set self.currentGenericTemplate = nil;
        exitFn(self);
        if isUnsafe {
            set self.unsafeDepth -= 1;
        }

        if let entry = generic {
            for param in entry.params {
                if not *param.used {
                    throw emitError(
                        self,
                        param.node,
                        ErrorKind::GenericFnUnusedParameter(param.name),
                    );
                }
            }
        }
    } else if not isExtern {
        throw emitError(self, node, ErrorKind::FnMissingBody);
    }
}


        }
    }
    return linear;
}

/// Resolve record fields from a node list.
fn resolveRecordFields(self: *mut Resolver, node: *ast::Node, fields: *mut [*ast::Node], labeled: bool) -> RecordType
    throws (ResolveError)
{
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut result: *mut [RecordField] = &mut [];
    let mut currentOffset: u32 = 0;
    let mut maxAlignment: u32 = 1;

    if fields.len > parser::MAX_RECORD_FIELDS {
        throw emitError(self, node, ErrorKind::Internal);
    }
    // TODO: Add cycle detection to catch invalid recursive types like `record A { a: A }`.
    for field in fields {
        let case ast::NodeValue::RecordField {
            field: fieldNode,
            type: typeNode,
            value: valueNode
        } = field.value else panic "resolveRecordFields: invalid record field";
        let fieldTy = try resolveValueType(self, typeNode);
        try ensureStorableType(self, typeNode, fieldTy);

        if let v = valueNode {
            let _valTy = try checkAssignable(self, v, fieldTy);
/// Resolve one symbolic generic data member.
fn resolveGenericDataMember(
    self: *mut Resolver,
    member: *ast::Node,
) -> Type throws (ResolveError) {
    match member.value {
        case ast::NodeValue::RecordField { type, value, .. } => {
            let ty = try resolveTypeSyntax(
                self, type, TypeSyntaxContext::Symbolic
            );
            try ensureStorableType(self, type, ty);
            if let initializer = value {
                let _ = try checkAssignable(self, initializer, ty);
            }
            return ty;
        }
        // Get field name for labeled records.
        let mut fieldName: ?*[u8] = nil;
        if labeled {
            let n = fieldNode
                else panic "resolveRecordFields: labeled record field missing name";
            set fieldName = try nodeName(self, n);
        case ast::NodeValue::UnionDeclVariant(variant) => {
            let mut ty = Type::Void;
            if let type = variant.type {
                set ty = try resolveTypeSyntax(
                    self, type, TypeSyntaxContext::Symbolic
                );
                try ensureStorableType(self, type, ty);
            }
            if let value = variant.value {
                let _ = try checkNumeric(self, value);
                if constValueEntry(self, value) == nil and
                   (not isConstExpr(self, value) or
                    not containsGenericConstExpr(self, value))
                {
                    throw emitError(
                        self, value, ErrorKind::ConstExprRequired
                    );
                }
            }
            return ty;
        }
        let fieldType = typeFor(self, typeNode)
            else throw emitError(self, typeNode, ErrorKind::CannotInferType);

        // Ensure field type is fully resolved before computing layout.
        try ensureTypeResolved(self, fieldType, typeNode);

        // Compute field offset by aligning to field's alignment.
        let fieldLayout = getTypeLayout(fieldType);
        set currentOffset = mem::alignUp(currentOffset, fieldLayout.alignment);

        result.append(RecordField { name: fieldName, fieldType, offset: currentOffset as i32 }, a);

        // Advance offset past this field.
        set currentOffset += fieldLayout.size;
        else => panic "resolveGenericDataMember: invalid member",
    }
}

        // Track max alignment for record layout.
        set maxAlignment = max(maxAlignment, fieldLayout.alignment);
/// Resolve symbolic field or variant types for a generic data template.
fn resolveGenericDataTemplate(
    self: *mut Resolver,
    node: *ast::Node,
    params: *mut [*ast::Node],
    members: *mut [*ast::Node],
    derives: *mut [*ast::Node],
) throws (ResolveError) {
    let sym = symbolFor(self, node) else return;
    if genericTemplateFor(self, sym) <> nil {
        return;
    }
    // Compute cached layout.
    let recordLayout = Layout {
        size: mem::alignUp(currentOffset, maxAlignment),
        alignment: maxAlignment
    enterScope(self, node);
    let genericParams = try resolveGenericParams(self, node, params) catch e {
        exitScope(self);
        throw e;
    };
    return RecordType {
        fields: &result[..],
        labeled,
        layout: recordLayout,
        declaredLinear: false,
    let declaredLinear = try resolveLinearDerive(self, derives) catch e {
        exitScope(self);
        throw e;
    };
    // Publish the rigid parameters before resolving members so recursive and
    // mutually recursive applications can observe the in-progress template.
    let metadata = registerGenericTemplate(self, GenericTemplate {
        symbol: sym,
        params: genericParams,
        signature: nil,
        members: &[],
        declaredLinear,
        bodyResolved: true,
        typeUses: &mut [],
        next: nil,
    });
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut memberTypes: *mut [*Type] = &mut [];
    for member in members {
        let memberTy = try resolveGenericDataMember(self, member) catch e {
            exitScope(self);
            throw e;
        };
        memberTypes.append(allocType(self, memberTy), a);
    }
    exitScope(self);
    set metadata.members = &memberTypes[..];
}

/// Resolve record field types for a named record declaration.
fn resolveRecordBody(self: *mut Resolver, node: *ast::Node, decl: ast::RecordDecl)
    throws (ResolveError)

    // Skip if already resolved.
    if let case NominalType::Record(_) = *nominalTy {
        return;
    }
    let declaredLinear = try resolveLinearDerive(self, decl.derives);
    let mut recordType = try resolveRecordFields(self, node, decl.fields, decl.labeled);
    set recordType.declaredLinear = declaredLinear;
    let recordType = try buildRecordType(
        self,
        node,
        decl.fields,
        decl.labeled,
        declaredLinear,
        AggregateMemberSource::Ordinary,
    );

    set *nominalTy = NominalType::Record(recordType);
}

/// Bind a type name.


    return try bindTypeIdent(self, name, node, nominalTy, attrMask);
}

/// Allocate a trait type descriptor and return a pointer to it.
fn allocTraitType(self: *mut Resolver, name: *[u8]) -> *mut TraitType {
fn allocTraitType(
    self: *mut Resolver,
    name: *[u8],
    node: *ast::Node,
) -> *mut TraitType {
    let p = try! alloc::alloc(&mut self.arena, @sizeOf(TraitType), @alignOf(TraitType));
    let entry = p as *mut TraitType;
    set *entry = TraitType { name, methods: &mut [], supertraits: &mut [] };

    let used = try! alloc::alloc(
        &mut self.arena, @sizeOf(bool), @alignOf(bool)
    ) as *mut bool;
    set *used = false;
    let selfType = try! alloc::alloc(
        &mut self.arena, @sizeOf(GenericParamType), @alignOf(GenericParamType)
    ) as *mut GenericParamType;
    set *selfType = GenericParamType {
        owner: node,
        node,
        name: "Self",
        index: 0,
        bounds: &[],
        used,
        constType: nil,
    };
    set *entry = TraitType {
        name,
        moduleId: self.currentMod,
        nodeId: node.id,
        methods: &mut [],
        supertraits: &mut [],
        selfType,
        state: TraitState::Queued,
        objectSafe: true,
    };
    return entry;
}

/// Bind a trait name in the current scope.
fn bindTraitName(self: *mut Resolver, node: *ast::Node, name: *ast::Node, attrs: ?ast::Attributes) -> *mut Symbol
    throws (ResolveError)
{
fn bindTraitName(
    self: *mut Resolver,
    node: *ast::Node,
    name: *ast::Node,
    attrs: ?ast::Attributes,
) -> *mut Symbol throws (ResolveError) {
    let attrMask = resolveAttributes(self, attrs);
    try ensureDefaultAttrNotAllowed(self, node, attrMask);

    let traitName = try nodeName(self, name);
    let traitType = allocTraitType(self, traitName);
    let traitType = allocTraitType(self, traitName, node);
    let data = SymbolData::Trait(traitType);
    let sym = try bindIdent(self, traitName, node, data, attrMask, self.scope);

    setNodeType(self, node, Type::Void);
    setNodeType(self, name, Type::Void);

        }
    }
    return nil;
}

/// Resolve one trait signature type with the declaring trait's rigid `Self`.
fn resolveTraitSignatureType(
    self: *mut Resolver,
    traitType: *TraitType,
    node: *ast::Node,
) -> Type throws (ResolveError) {
    let previous = self.currentTraitSelf;
    set self.currentTraitSelf = traitType.selfType;
    let resolved = try resolveValueType(self, node) catch {
        set self.currentTraitSelf = previous;
        throw ResolveError::Failure;
    };
    set self.currentTraitSelf = previous;
    return resolved;
}

/// Resolve a trait declaration body: supertrait methods, then own methods.
fn resolveTraitBody(self: *mut Resolver, node: *ast::Node, supertraits: *mut [*ast::Node], methods: *mut [*ast::Node])
    throws (ResolveError)
{
    let sym = symbolFor(self, node)
        else return;
    let case SymbolData::Trait(traitType) = sym.data
        else return;
    if traitType.methods.len > 0 {
        return;
    match traitType.state {
        case TraitState::Complete, TraitState::Resolving => return,
        case TraitState::Queued => set traitType.state = TraitState::Resolving,
    }

    // Resolve supertrait bounds and copy their methods into this trait.
    for superNode in supertraits {
        let superSym = try resolveNamePath(self, superNode);
        let case SymbolData::Trait(superTrait) = superSym.data
            else throw emitError(self, superNode, ErrorKind::Internal);
        // Trait bodies are otherwise resolved in source order. Recursively
        // resolve a supertrait only when it is declared later.
        if superSym.node.id > node.id {
            let case ast::NodeValue::TraitDecl {
                supertraits: inheritedTraits, methods: inheritedMethods, ..
            } = superSym.node.value else throw emitError(self, superNode, ErrorKind::Internal);
            try resolveTraitBody(self, superSym.node, inheritedTraits, inheritedMethods);
        // Resolve queued supertraits before consuming their method tables.
        match superTrait.state {
            case TraitState::Queued => {
                let case ast::NodeValue::TraitDecl {
                    supertraits: inheritedTraits, methods: inheritedMethods, ..
                } = superSym.node.value
                    else throw emitError(self, superNode, ErrorKind::Internal);
                try resolveTraitBody(
                    self, superSym.node, inheritedTraits, inheritedMethods
                );
            }
            case TraitState::Resolving => {
                throw emitError(self, superNode, ErrorKind::TraitInheritanceCycle);
            }
            case TraitState::Complete => {}
        }

        setNodeSymbol(self, superNode, superSym);

        let a = alloc::arenaAllocator(&mut self.arena);

            traitType.methods.append(TraitMethod {
                name: inherited.name,
                fnType: inherited.fnType,
                mutable: inherited.mutable,
                receiverClass: inherited.receiverClass,
                owner: inherited.owner,
                index: traitType.methods.len as u32,
            }, a);
        }
        traitType.supertraits.append(superTrait, a);
        if not superTrait.objectSafe {
            set traitType.objectSafe = false;
        }
    }

    if traitType.methods.len + methods.len > ast::MAX_TRAIT_METHODS {
        throw emitError(self, node, ErrorKind::TraitMethodOverflow(CountMismatch {
            expected: ast::MAX_TRAIT_METHODS,

                expected: MAX_FN_PARAMS,
                actual: sig.params.len,
            }));
        }
        for paramNode in sig.params {
            let paramTy = try infer(self, paramNode);
            let case ast::NodeValue::FnParam(param) = paramNode.value
                else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);
            let paramTy = try resolveTraitSignatureType(self, traitType, param.type);
            paramTypes.append(allocType(self, paramTy), a);
        }
        if let ret = sig.returnType {
            set retType = allocType(self, try infer(self, ret));
            set retType = allocType(
                self, try resolveTraitSignatureType(self, traitType, ret)
            );
        }
        // Resolve throws list.
        if sig.throwList.len > MAX_FN_THROWS {
            throw emitError(self, methodNode, ErrorKind::FnThrowOverflow(CountMismatch {
                expected: MAX_FN_THROWS,
                actual: sig.throwList.len,
            }));
        }
        for throwNode in sig.throwList {
            let throwTy = try infer(self, throwNode);
            let throwTy = try resolveTraitSignatureType(self, traitType, throwNode);
            throwList.append(allocType(self, throwTy), a);
        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: retType,
            throwList: &throwList[..],
            isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
            localCount: 0,
        };
        if containsGenericParameter(Type::Fn(&fnType)) {
            set traitType.objectSafe = false;
        }
        traitType.methods.append(TraitMethod {
            name: methodName,
            fnType: allocFnType(self, fnType),
            mutable,
            receiverClass,
            owner: traitType,
            index: traitType.methods.len as u32,
        }, a);

        setNodeType(self, methodNode, Type::Void);
    }
    set traitType.state = TraitState::Complete;
}

/// Resolve a name path node to a symbol.
/// Used for trait and type references in instance declarations and trait objects.
fn resolveNamePath(self: *mut Resolver, node: *ast::Node) -> *mut Symbol

    let case SymbolData::Trait(traitInfo) = traitSym.data
        else throw emitError(self, traitName, ErrorKind::Internal);

    setNodeSymbol(self, traitName, traitSym);

    // Look up the target type.
    let typeSym = try resolveNamePath(self, targetType);
    let case SymbolData::Type(nominalTy) = typeSym.data
        else throw emitError(self, targetType, ErrorKind::Internal);
    setNodeSymbol(self, targetType, typeSym);
    // Ensure the concrete type body is resolved.
    try ensureNominalResolved(self, nominalTy, targetType);

    // Reject duplicate instance for the same (trait, type) pair.
    let concreteType = Type::Nominal(nominalTy);
    // Resolve a concrete target type, including built-in scalar types.
    let concreteType = try resolveValueType(self, targetType);
    if containsGenericParameter(concreteType) {
        throw emitError(self, targetType, ErrorKind::InvalidInstanceTarget);
    }
    if let case Type::Nominal(nominalTy) = concreteType {
        try ensureNominalResolved(self, nominalTy, targetType);
    }
    if let _ = findInstance(self, traitInfo, concreteType) {
        throw emitError(self, node, ErrorKind::DuplicateInstance);
    }

    // Build the instance entry.

        &mut self.arena, @sizeOf(*mut Symbol), @alignOf(*mut Symbol), traitInfo.methods.len as u32
    ) as *mut [*mut Symbol];
    let mut entry = InstanceEntry {
        traitType: traitInfo,
        concreteType,
        concreteTypeName: typeSym.name,
        moduleId: self.currentMod,
        methods: methodSlice,
    };
    // Track which trait methods are covered by the instance.
    let mut covered: [bool; ast::MAX_TRAIT_METHODS] = [false; ast::MAX_TRAIT_METHODS];

        let attrMask = resolveAttributes(self, attrs);

        // Find the matching trait method.
        let tm = findTraitMethod(traitInfo, methodName)
            else throw emitError(self, name, ErrorKind::UnresolvedSymbol(methodName));
        if tm.owner <> traitInfo {
            throw emitError(self, name, ErrorKind::InheritedTraitMethod(methodName));
        }
        let selfArg = allocType(self, concreteType);
        let selfParams: [*GenericParamType; 1] = [tm.owner.selfType];
        let selfArgs: [*Type; 1] = [selfArg];
        let selfSub = Substitution {
            params: &selfParams[..],
            args: &selfArgs[..],
        };
        let concreteMethodType = try substituteType(
            self, Type::Fn(tm.fnType), &selfSub, methodNode
        );
        let case Type::Fn(expectedFn) = concreteMethodType
            else throw emitError(self, methodNode, ErrorKind::Internal);
        let instanceUnsafe = ast::hasAttribute(attrMask, ast::Attribute::Unsafe);
        if instanceUnsafe <> tm.fnType.isUnsafe {
            throw emitError(self, methodNode, ErrorKind::TraitMethodSafetyMismatch);
        }


            throw emitError(self, receiverType, ErrorKind::ReceiverMutabilityMismatch);
        }

        // Build the function type for the instance method.
        // The receiver becomes the first parameter.
        let receiverPtrType = Type::Pointer {
        let receiverPtrType = Type::Pointer(PointerType {
            class: receiverClass,
            target: allocType(self, concreteType),
            mutable: receiverMut,
        };
        });

        // Validate that the instance method's signature matches the
        // trait method's signature exactly (params, return type, throws).
        if sig.params.len <> tm.fnType.paramTypes.len {
        if sig.params.len <> expectedFn.paramTypes.len {
            throw emitError(self, methodNode, ErrorKind::FnArgCountMismatch(CountMismatch {
                expected: tm.fnType.paramTypes.len as u32,
                expected: expectedFn.paramTypes.len as u32,
                actual: sig.params.len,
            }));
        }
        for paramNode, j in sig.params {
            let case ast::NodeValue::FnParam(param) = paramNode.value
                else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);
            let instanceParamTy = try resolveValueType(self, param.type);
            if not typesEqual(instanceParamTy, *tm.fnType.paramTypes[j]) {
            if not typesEqual(instanceParamTy, *expectedFn.paramTypes[j]) {
                throw emitTypeMismatch(self, paramNode, TypeMismatch {
                    expected: *tm.fnType.paramTypes[j],
                    expected: *expectedFn.paramTypes[j],
                    actual: instanceParamTy,
                });
            }
        }
        let mut instanceRetTy = Type::Void;
        if let retNode = sig.returnType {
            set instanceRetTy = try resolveValueType(self, retNode);
        }
        if not typesEqual(instanceRetTy, *tm.fnType.returnType) {
        if not typesEqual(instanceRetTy, *expectedFn.returnType) {
            throw emitTypeMismatch(self, methodNode, TypeMismatch {
                expected: *tm.fnType.returnType,
                expected: *expectedFn.returnType,
                actual: instanceRetTy,
            });
        }
        if sig.throwList.len <> tm.fnType.throwList.len {
        if sig.throwList.len <> expectedFn.throwList.len {
            throw emitError(self, methodNode, ErrorKind::FnThrowCountMismatch(CountMismatch {
                expected: tm.fnType.throwList.len as u32,
                expected: expectedFn.throwList.len as u32,
                actual: sig.throwList.len,
            }));
        }
        for throwNode, j in sig.throwList {
            let instanceThrowTy = try resolveValueType(self, throwNode);
            if not typesEqual(instanceThrowTy, *tm.fnType.throwList[j]) {
            if not typesEqual(instanceThrowTy, *expectedFn.throwList[j]) {
                throw emitTypeMismatch(self, throwNode, TypeMismatch {
                    expected: *tm.fnType.throwList[j],
                    expected: *expectedFn.throwList[j],
                    actual: instanceThrowTy,
                });
            }
        }


        let a = alloc::arenaAllocator(&mut self.arena);
        // TODO: Improve this pattern, maybe via something like `(&[]).append(..)`?
        let mut paramTypes: *mut [*Type] = &mut [];
        paramTypes.append(allocType(self, receiverPtrType), a);

        for ty in tm.fnType.paramTypes {
        for ty in expectedFn.paramTypes {
            paramTypes.append(ty, a);
        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: tm.fnType.returnType,
            throwList: tm.fnType.throwList,
            isUnsafe: tm.fnType.isUnsafe,
            returnType: expectedFn.returnType,
            throwList: expectedFn.throwList,
            isUnsafe: expectedFn.isUnsafe,
            localCount: 0,
        };

        // Create a symbol for the instance method without binding it into the
        // module scope. Instance methods are dispatched via v-table, so they

    }
}

/// Resolve a standalone method declaration (signature only).
/// Validates the receiver type and registers the method in the method table.

/// Extract the type name from a resolved receiver type node.
fn receiverTypeName(
    self: *mut Resolver,
    receiverType: *ast::Node,
) -> *[u8] throws (ResolveError) {
    let case ast::NodeValue::TypeSig(ast::TypeSig::Pointer { valueType, .. }) =
        receiverType.value
        else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
    let case ast::NodeValue::TypeSig(ast::TypeSig::Nominal(nameNode)) = valueType.value
        else throw emitError(self, receiverType, ErrorKind::Internal);
    let sym = symbolFor(self, nameNode)
        else throw emitError(self, receiverType, ErrorKind::Internal);

    return sym.name;
}

/// Resolve and register a standalone method declaration.
fn resolveMethodDecl(
    self: *mut Resolver,
    node: *ast::Node,
    name: *ast::Node,

    attrs: ?ast::Attributes,
) throws (ResolveError) {
    // Resolve the receiver type: must be `*Type` or `*mut Type` pointing to a
    // nominal type.
    let fullReceiverTy = try infer(self, receiverType);
    let case Type::Pointer {
        class: receiverClass, target: receiverTarget, mutable: receiverMut,
    } = fullReceiverTy
    let case Type::Pointer(receiver) = fullReceiverTy
        else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
    let concreteType = *receiverTarget;
    let concreteType = *receiver.target;
    let case Type::Nominal(nominalTy) = concreteType
        else throw emitError(self, receiverType, ErrorKind::ExpectedRecord);
    try ensureNominalResolved(self, nominalTy, receiverType);

    // Get the type name from the inner type node's symbol.
    let typeName = try receiverTypeName(self, receiverType);
    let methodName = try nodeName(self, name);
    let attrMask = resolveAttributes(self, attrs);

    // Reject duplicate method for the same (type, name).
    if let _ = findMethod(self, concreteType, methodName) {

    // Resolve parameter types.
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut paramTypes: *mut [*Type] = &mut [];

    // Receiver is the first parameter.
    let receiverPtrType = Type::Pointer {
        class: receiverClass,
    let receiverPtrType = Type::Pointer(PointerType {
        class: receiver.class,
        target: allocType(self, concreteType),
        mutable: receiverMut,
    };
        mutable: receiver.mutable,
    });
    paramTypes.append(allocType(self, receiverPtrType), a);

    for paramNode in sig.params {
        let case ast::NodeValue::FnParam(param) = paramNode.value
            else throw emitError(self, paramNode, ErrorKind::ExpectedIdentifier);

    if self.methodsLen >= MAX_METHODS {
        throw emitError(self, node, ErrorKind::Internal);
    }
    set self.methods[self.methodsLen] = MethodEntry {
        concreteType,
        concreteTypeName: typeName,
        name: methodName,
        fnType: allocFnType(self, checkFnType),
        mutable: receiverMut,
        receiverClass,
        mutable: receiver.mutable,
        receiverClass: receiver.class,
        symbol: sym,
    };
    set self.methodsLen += 1;
}

/// Look up an instance entry by trait and concrete type.
fn findInstance(self: *Resolver, traitInfo: *TraitType, concreteType: Type) -> ?*InstanceEntry {
export fn findInstance(self: *Resolver, traitInfo: *TraitType, concreteType: Type) -> ?*InstanceEntry {
    for i in 0..self.instancesLen {
        let entry = &self.instances[i];
        if entry.traitType == traitInfo and typesEqual(entry.concreteType, concreteType) {
            return entry;
        }

    // Check if already resolved, in which case there's no need to
    // do it again.
    if let case NominalType::Union(_) = *nominalTy {
        return;
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut variants: *mut [UnionVariant] = &mut [];

    // Create a temporary nominal type to replace the placeholder.This prevents infinite recursion
    // when a variant references this union type (e.g. record payloads with `*[Self]`).
    // TODO: It would be best to have a resolving state eg. `Visiting` for this situation.
    let declaredLinear = try resolveLinearDerive(self, decl.derives);
    // Publish a temporary union so pointer-recursive variants can resolve it.
    set *nominalTy = NominalType::Union(UnionType {
        variants: &[],
        layout: Layout { size: 0, alignment: 0 },
        valOffset: 0,
        isAllVoid: true,
        declaredLinear,
    });

    assert decl.variants.len <= MAX_UNION_VARIANTS, "resolveUnionBody: maximum union variants exceeded";
    let mut iota: u32 = 0;
    for variantNode, i in decl.variants {
        let case ast::NodeValue::UnionDeclVariant(variantDecl) = variantNode.value
            else panic "resolveUnionBody: invalid union variant";
        let variantName = try nodeName(self, variantDecl.name);
        // Resolve the variant's payload type if present.
        let mut variantType = Type::Void;
        if let typeNode = variantDecl.type {
            set variantType = try infer(self, typeNode);
            try ensureStorableType(self, typeNode, variantType);
        }
        // Process the variant's explicit discriminant value if present.
        try visitOptional(self, variantDecl.value, variantType);
        let tag = variantTag(variantDecl, &mut iota);
        // Create a symbol for this variant.
        let data = SymbolData::Variant { type: variantType, decl: node, ordinal: i, index: tag };
        let variantSym = allocSymbol(self, data, variantName, variantNode, 0);

        variants.append(UnionVariant {
            name: variantName,
            valueType: variantType,
            symbol: variantSym,
        }, a);
    }
    let info = computeUnionLayout(&variants[..]);

    // Update the nominal type with the resolved variants.
    set *nominalTy = NominalType::Union(UnionType {
        variants: &variants[..],
        layout: info.layout,
        valOffset: info.valOffset,
        isAllVoid: info.isAllVoid,
        declaredLinear,
    });
    let unionType = try buildUnionType(
        self, sym, decl, declaredLinear, AggregateMemberSource::Ordinary
    );
    set *nominalTy = NominalType::Union(unionType);
}

/// Check if a module should be analyzed based on its attributes and build configuration.
fn shouldAnalyzeModule(self: *Resolver, attrs: ?ast::Attributes) -> bool {
    if let attributes = attrs {

    pattern: *ast::Node,
    scrutineeTy: Type,
    mode: IdentMode,
    matchBy: MatchBy
) throws (ResolveError) {
    if let case Type::Pointer { target, .. } = scrutineeTy; isDestructuringPattern(pattern) {
        try resolveCasePattern(self, pattern, *target, mode, matchBy);
    if let case Type::Pointer(pointer) = scrutineeTy; isDestructuringPattern(pattern) {
        try resolveCasePattern(self, pattern, *pointer.target, mode, matchBy);
        return;
    }
    // TODO: Collapse these nested matches.
    match scrutineeTy {
        case Type::Nominal(info) => {

        }
    }
    // Extract item type and store pre-computed loop metadata for the lowerer.
    let mut itemTy: Type = undefined;
    match iterableTy {
        case Type::Slice { item, .. } => {
            set itemTy = *item;
        case Type::Slice(slice) => {
            set itemTy = *slice.item;
            setForLoopInfo(self, node, ForLoopInfo::Collection {
                elemType: item, length: nil, bindingName, indexName
                elemType: slice.item, length: nil, bindingName, indexName
            });
        }
        case Type::Range { start, .. } => {
            // Iterable ranges must have a start, and since we enforce type
            // equality for start and end, that is always the item type.

    throws (ResolveError)
{
    let mut bindTy = ty;
    match matchBy {
        case MatchBy::Value => {}
        case MatchBy::Ref => set bindTy = Type::Pointer {
        case MatchBy::Ref => set bindTy = Type::Pointer(PointerType {
            class: types::PointerClass::Ref,
            target: allocType(self, ty),
            mutable: false,
        },
        case MatchBy::MutRef => set bindTy = Type::Pointer {
        }),
        case MatchBy::MutRef => set bindTy = Type::Pointer(PointerType {
            class: types::PointerClass::Ref,
            target: allocType(self, ty),
            mutable: true,
        },
        }),
    }
    match binding.value {
        case ast::NodeValue::Placeholder => {
            // Nothing to do.
        }

                expected: 2,
                actual: args.len as u32,
            }));
        }
        let ptrType = try visit(self, args[0], Type::Unknown);
        let case Type::Pointer { class, target, mutable } = ptrType else {
        let case Type::Pointer(ptr) = ptrType else {
            throw emitError(self, node, ErrorKind::ExpectedPointer);
        };
        let _ = try checkAssignable(self, args[1], Type::U32);
        if args.len == 3 {
            let _ = try checkAssignable(self, args[2], Type::U32);
        }
        return setNodeType(self, node, Type::Slice { class, item: target, mutable });
        return setNodeType(self, node, Type::Slice(SliceType {
            class: ptr.class,
            item: ptr.target,
            mutable: ptr.mutable,
        }));
    }
    if args.len <> 1 {
        throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
            expected: 1,
            actual: args.len as u32,

    let ty = try resolveValueType(self, args[0]);
    // Ensure the type body is resolved before computing layout.
    // TODO: Somehow, ensuring the type is resolved should just happen all
    // the time, lazily.
    try ensureTypeResolved(self, ty, args[0]);
    if containsGenericParameter(ty) {
        throw emitError(self, args[0], ErrorKind::GenericLayoutRequired);
    }
    // TODO: This should be stored in `symbol` instead of having to recompute it.
    // That way there's a canonical place to look for code gen.
    let layout = getTypeLayout(ty);

    // Evaluate the built-in.

        },
        case ast::Builtin::SliceOf => {
            panic "unreachable: @sliceOf handled above";
        }
    }
    // Record as constant value for constant folding.
    setNodeConstValue(self, node, ConstValue::Int(ConstInt {
        magnitude: value as u64,
        bits: 32,
        signed: false,
        negative: false,
    }));
    return setNodeType(self, node, Type::U32);
    // Record as constant value for constant folding.
    setNodeConstValue(self, node, ConstValue::Int(ConstInt {
        magnitude: value as u64,
        bits: 32,
        signed: false,
        negative: false,
    }));
    return setNodeType(self, node, Type::U32);
}

/// Validate call arguments against a function type: check argument count,
/// type-check each argument, and verify that throwing functions use `try`.
fn checkCallArgs(self: *mut Resolver, node: *ast::Node, call: ast::Call, info: *FnType, ctx: CallCtx)
    throws (ResolveError)
{
    if ctx == CallCtx::Normal and info.throwList.len > 0 {
        throw emitError(self, node, ErrorKind::MissingTry);
    }
    if call.args.len <> info.paramTypes.len as u32 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: info.paramTypes.len as u32,
            actual: call.args.len,
        }));
    }
    for argNode, i in call.args {
        let expectedTy = *info.paramTypes[i];

        try checkAssignable(self, argNode, expectedTy);
    }
}

/// Unify one symbolic parameter type with exact call-site evidence.
fn inferGenericArgument(
    self: *mut Resolver,
    pattern: Type,
    actual: Type,
    params: *[*GenericParamType],
    inferred: *mut [?*Type],
) -> bool {
    if let case Type::Parameter(param) = pattern {
        let mut evidence = actual;
        match actual {
            case Type::Unknown, Type::Nil, Type::Undefined => return true,
            case Type::Int => set evidence = Type::I64,
            else => {},
        }
        for candidate, i in params {
            if candidate == param {
                if let prior = inferred[i] {
                    return typesEqual(*prior, evidence);
                }
                set inferred[i] = allocType(self, evidence);
                return true;
            }
        }
        return typesEqual(pattern, evidence);
    }
    if typesEqual(pattern, actual) {
        return true;
    }
    if not containsGenericParameter(pattern) {
        return true;
    }
    match pattern {
        case Type::Pointer(pointer) => {
            let case Type::Pointer(actualPointer) = actual else return false;
            return pointer.class == actualPointer.class
                and pointer.mutable == actualPointer.mutable
                and inferGenericArgument(
                    self,
                    *pointer.target,
                    *actualPointer.target,
                    params,
                    inferred,
                );
        }
        case Type::Slice(slice) => {
            let case Type::Slice(actualSlice) = actual else return false;
            return slice.class == actualSlice.class
                and slice.mutable == actualSlice.mutable
                and inferGenericArgument(
                    self,
                    *slice.item,
                    *actualSlice.item,
                    params,
                    inferred,
                );
        }
        case Type::Optional(inner) => {
            let case Type::Optional(actualInner) = actual else return false;
            return inferGenericArgument(
                self, *inner, *actualInner, params, inferred
            );
        }
        case Type::Array(array) => {
            let case Type::Array(actualArray) = actual else return false;
            return array.length == actualArray.length and inferGenericArgument(
                self, *array.item, *actualArray.item, params, inferred
            );
        }
        case Type::GenericDataApply(application) => {
            let case Type::Nominal(nominal) = actual else return false;
            let concrete = genericDataSpecializationForNominal(self, nominal)
                else return false;
            if concrete.template <> application.template
                or concrete.args.len <> application.args.len
            {
                return false;
            }
            for arg, i in application.args {
                if not inferGenericArgument(
                    self, *arg, *concrete.args[i], params, inferred
                ) {
                    return false;
                }
            }
            return true;
        }
        else => return false,
    }
}

/// Infer and resolve a direct call to a generic function template.
fn resolveInferredGenericCall(
    self: *mut Resolver,
    callee: *ast::Node,
    call: ast::Call,
    expected: Type,
) -> ?*FnType throws (ResolveError) {
    let templateSym = findGenericCandidateSymbol(self, callee) else return nil;
    let template = genericTemplateFor(self, templateSym) else return nil;
    let signature = template.signature else return nil;
    if call.args.len <> signature.paramTypes.len {
        return nil;
    }
    let mut inferred: [?*Type; MAX_FN_PARAMS] = undefined;
    for i in 0..inferred.len {
        set inferred[i] = nil;
    }
    for argNode, i in call.args {
        let actual = try infer(self, argNode);
        if not inferGenericArgument(
            self,
            *signature.paramTypes[i],
            actual,
            template.params,
            &mut inferred[..],
        ) {
            throw emitError(self, argNode, ErrorKind::GenericInferenceConflict);
        }
    }
    if expected <> Type::Unknown and expected <> Type::Void and not inferGenericArgument(
        self,
        *signature.returnType,
        expected,
        template.params,
        &mut inferred[..],
    ) {
        throw emitError(self, callee, ErrorKind::GenericInferenceConflict);
    }
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut args: *mut [*Type] = &mut [];
    for _, i in template.params {
        let arg = inferred[i] else {
            throw emitError(
                self, callee, ErrorKind::GenericInferenceIncomplete
            );
        };
        args.append(arg, a);
    }
    for arg, i in args {
        if not containsGenericParameter(*arg) {
            for bound in template.params[i].bounds {
                if findInstance(self, bound, *arg) == nil {
                    throw emitError(
                        self,
                        callee,
                        ErrorKind::GenericBoundUnsatisfied(bound.name),
                    );
                }
            }
        }
    }
    let sub = Substitution { params: template.params, args: &args[..] };
    let applied = try substituteType(self, Type::Fn(signature), &sub, callee);
    let case Type::Fn(appliedFn) = applied
        else throw emitError(self, callee, ErrorKind::Internal);
    let caller = currentGenericTemplateSymbol(self);
    if caller == nil {
        if let existing = findGenericFnSpecialization(
            self, templateSym, &args[..]
        ) {
            setNodeSymbol(self, callee, templateSym);
            setNodeType(self, callee, Type::Fn(existing.fnType));
            set self.nodeData.entries[callee.id].extra =
                NodeExtra::GenericFnCall(existing);
            return existing.fnType;
        }
    }
    recordGenericFnDependency(
        self, callee, caller, templateSym, &args[..], appliedFn
    );
    return appliedFn;
}

/// Validate call arguments against a function type: check argument count,
/// type-check each argument, and verify that throwing functions use `try`.
fn checkCallArgs(self: *mut Resolver, node: *ast::Node, call: ast::Call, info: *FnType, ctx: CallCtx)
    throws (ResolveError)
{
    if ctx == CallCtx::Normal and info.throwList.len > 0 {
        throw emitError(self, node, ErrorKind::MissingTry);
/// Resolve `Trait::method(receiver, ...)` for a rigid bounded parameter.
fn resolveQualifiedGenericBoundCall(
    self: *mut Resolver,
    node: *ast::Node,
    call: ast::Call,
    ctx: CallCtx,
) -> ?Type throws (ResolveError) {
    let case ast::NodeValue::ScopeAccess(access) = call.callee.value
        else return nil;
    if currentGenericTemplateSymbol(self) == nil or call.args.len == 0 {
        return nil;
    }
    if call.args.len <> info.paramTypes.len as u32 {
        throw emitError(self, node, ErrorKind::FnArgCountMismatch(CountMismatch {
            expected: info.paramTypes.len as u32,
            actual: call.args.len,
        }));
    let traitSym = try resolveNamePath(self, access.parent);
    let case SymbolData::Trait(traitInfo) = traitSym.data else return nil;
    let receiverTy = try infer(self, call.args[0]);
    let case Type::Pointer(receiver) = receiverTy else return nil;
    let case Type::Parameter(param) = *receiver.target else return nil;
    let mut hasBound = false;
    for bound in param.bounds {
        if bound == traitInfo {
            set hasBound = true;
            break;
        }
    }
    for argNode, i in call.args {
        let expectedTy = *info.paramTypes[i];

        try checkAssignable(self, argNode, expectedTy);
    if not hasBound {
        return nil;
    }
    if isUnsafePointerType(receiverTy) {
        try requireUnsafe(self, call.args[0]);
    }
    let methodName = try nodeName(self, access.child);
    let method = findTraitMethod(traitInfo, methodName)
        else throw emitError(
            self, access.child, ErrorKind::RecordFieldUnknown(methodName)
        );
    if method.mutable and not receiver.mutable {
        throw emitError(self, call.args[0], ErrorKind::ImmutableBinding);
    }
    let selfParam: [*GenericParamType; 1] = [method.owner.selfType];
    let selfArg: [*Type; 1] = [allocType(self, Type::Parameter(param))];
    let sub = Substitution {
        params: &selfParam[..],
        args: &selfArg[..],
    };
    let substituted = try substituteType(
        self, Type::Fn(method.fnType), &sub, node
    );
    let case Type::Fn(methodFn) = substituted
        else throw emitError(self, node, ErrorKind::Internal);
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut params: *mut [*Type] = &mut [];
    params.append(allocType(self, receiverTy), a);
    for methodParam in methodFn.paramTypes {
        params.append(methodParam, a);
    }
    let fullFn = allocFnType(self, FnType {
        paramTypes: &params[..],
        returnType: methodFn.returnType,
        throwList: methodFn.throwList,
        isUnsafe: methodFn.isUnsafe,
        localCount: 0,
    });
    try checkUnsafeCall(self, call.callee, fullFn);
    try checkCallArgs(self, node, call, fullFn, ctx);
    setNodeSymbol(self, access.parent, traitSym);
    setNodeType(self, call.callee, Type::Fn(fullFn));
    setGenericBoundMethodCall(
        self, node, param, traitInfo, method.index, true
    );
    return setNodeType(self, node, *methodFn.returnType);
}

/// Analyze a function call expression.
fn resolveCall(self: *mut Resolver, node: *ast::Node, call: ast::Call, ctx: CallCtx) -> Type
    throws (ResolveError)
fn resolveCall(
    self: *mut Resolver,
    node: *ast::Node,
    call: ast::Call,
    ctx: CallCtx,
    expected: Type,
) -> Type throws (ResolveError)
{
    // Intercept method calls on slices before inferring the callee.
    if let case ast::NodeValue::FieldAccess(access) = call.callee.value {
        let parentTy = try infer(self, access.parent);
        if isUnsafePointerType(parentTy) {
            try requireUnsafe(self, access.parent);
        }

        let subjectTy = autoDeref(parentTy);

        if let case Type::Slice { item, mutable, .. } = subjectTy {
        if let case Type::Slice(slice) = subjectTy {
            let methodName = try nodeName(self, access.child);
            if methodName == "append" {
                return try resolveSliceAppend(
                    self, node, access.parent, parentTy, call.args, item, mutable
                    self, node, access.parent, parentTy, call.args, slice.item, slice.mutable
                );
            }
            if methodName == "delete" {
                return try resolveSliceDelete(
                    self, node, access.parent, call.args, item, mutable
                    self, node, access.parent, call.args, slice.item, slice.mutable
                );
            }
        }
    }
    if let bounded = try resolveQualifiedGenericBoundCall(
        self, node, call, ctx
    ) {
        return bounded;
    }
    if let inferred = try resolveInferredGenericCall(
        self, call.callee, call, expected
    ) {
        try checkUnsafeCall(self, call.callee, inferred);
        try checkCallArgs(self, node, call, inferred, ctx);
        return setNodeType(self, node, *inferred.returnType);
    }
    let calleeTy = try infer(self, call.callee);
    if let case Type::Fn(info) = calleeTy {
        try checkUnsafeCall(self, call.callee, info);
    }

    // Check if callee is a union variant and dispatch to constructor handler.
    // TODO: Move this out. We should decide on this earlier, based on the callee.
    if let calleeSym = symbolFor(self, call.callee) {
        if let case SymbolData::Variant { decl, .. } = calleeSym.data {
            // TODO: Don't pass the callee type, pass the union type by getting it from
            // the symbol.
            let declSym = symbolFor(self, decl) else panic;
            let case SymbolData::Type(ty) = declSym.data else panic;

            return try resolveUnionConstructorCall(self, node, call, ty);
        if let case SymbolData::Variant { .. } = calleeSym.data {
            let case Type::Nominal(unionType) = calleeTy
                else throw emitError(self, call.callee, ErrorKind::Internal);
            return try resolveUnionConstructorCall(self, node, call, unionType);
        }
        // Check if callee is an unlabeled record type for constructor call syntax.
        if let case SymbolData::Type(ty) = calleeSym.data {
            // Ensure the record body is resolved before checking if labeled.
            try ensureNominalResolved(self, ty, call.callee);

        if let t = typeFor(self, access.parent) {
            set parentTy = t;
        }
        let subjectTy = autoDeref(parentTy);

        if let case Type::TraitObject { traitInfo, mutable: objMutable, .. } = subjectTy {
        if let case Type::Parameter(param) = subjectTy; param.bounds.len > 0 {
            let methodName = try nodeName(self, access.child);
            let method = findTraitMethod(traitInfo, methodName)
                else throw emitError(self, access.child, ErrorKind::RecordFieldUnknown(methodName));
            let selected = try findGenericBoundMethod(
                self, access.child, param, methodName
            );
            let case Type::Fn(info) = calleeTy
                else throw emitError(self, call.callee, ErrorKind::Internal);
            if selected.method.mutable {
                let mut isMutPtr = false;
                if let case Type::Pointer(pointer) = parentTy {
                    set isMutPtr = pointer.mutable;
                }
                if not isMutPtr and not (try canBorrowMutFrom(self, access.parent)) {
                    throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
                }
            }
            try checkUnsafeCall(self, call.callee, info);
            try checkCallArgs(self, node, call, info, ctx);
            setGenericBoundMethodCall(
                self,
                node,
                param,
                selected.traitInfo,
                selected.method.index,
                false,
            );
            return setNodeType(self, node, *info.returnType);
        }

        if let case Type::TraitObject(traitObject) = subjectTy {
            let methodName = try nodeName(self, access.child);
            let method = findTraitMethod(traitObject.traitInfo, methodName)
                else throw emitError(self, access.child, ErrorKind::RecordFieldUnknown(methodName));
            // Reject mutable-receiver methods called on immutable trait objects.
            if method.mutable and not objMutable {
            if method.mutable and not traitObject.mutable {
                throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
            }
            try checkCallArgs(self, node, call, method.fnType, ctx);
            setTraitMethodCall(self, node, traitInfo, method.index);

            setTraitMethodCall(self, node, traitObject.traitInfo, method.index);
            return setNodeType(self, node, *method.fnType.returnType);
        }

        // Check for a standalone method call on a concrete type.
        if let case Type::Nominal(_) = subjectTy {

                // Reject mutable-receiver methods on immutable bindings.
                // If the parent is already a mutable pointer, the receiver is fine.
                // Otherwise, check that the parent can yield a mutable borrow.
                if method.mutable {
                    let mut isMutPtr = false;
                    if let case Type::Pointer { mutable, .. } = parentTy {
                        set isMutPtr = mutable;
                    if let case Type::Pointer(pointer) = parentTy {
                        set isMutPtr = pointer.mutable;
                    }
                    if not isMutPtr and not (try canBorrowMutFrom(self, access.parent)) {
                        throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
                    }
                }

    // First argument must be assignable to the element type.
    try checkAssignable(self, args[0], *elemType);
    // Second argument: the allocator. We accept any type -- the lowerer
    // reads `.func` and `.ctx` at fixed offsets.
    try visit(self, args[1], Type::Unknown);
    recordGenericTypeUse(self, node, *elemType);
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceAppend { elemType };

    // Return the parent's type so the caller can rebind:
    return setNodeType(self, node, parentType);
}

            expected: 1,
            actual: args.len as u32,
        }));
    }
    try checkAssignable(self, args[0], Type::U32);
    recordGenericTypeUse(self, node, *elemType);
    set self.nodeData.entries[node.id].extra = NodeExtra::SliceDelete { elemType };

    return setNodeType(self, node, Type::Void);
}


            try checkSliceRangeIndices(self, range);

            let mut item: *Type = undefined;
            let mut capacity: ?u32 = nil;

            if let case Type::Slice { item: sliceItem, mutable: sliceMutable, .. } = subjectTy {
                if not sliceMutable {
            if let case Type::Slice(slice) = subjectTy {
                if not slice.mutable {
                    throw emitError(self, container, ErrorKind::ImmutableBinding);
                }
                set item = sliceItem;
                set item = slice.item;
            } else {
                match subjectTy {
                    case Type::Array(a) => {
                        try validateArraySliceBounds(self, range, a.length, node);
                        set item = a.item;

                    else => throw emitError(self, container, ErrorKind::ExpectedIndexable),
                }
            }
            // RHS is either a fill value or a source slice.
            let rhsTy = try infer(self, assign.right);
            if let case Type::Slice { item: sourceItem, .. } = rhsTy {
                if *sourceItem <> *item {
            if let case Type::Slice(source) = rhsTy {
                if *source.item <> *item {
                    throw emitTypeMismatch(
                        self,
                        assign.right,
                        TypeMismatch { expected: *item, actual: *sourceItem },
                        TypeMismatch { expected: *item, actual: *source.item },
                    );
                }
            } else {
                try checkAssignable(self, assign.right, *item);
            }

    if isUnsafePointerType(containerTy) {
        try requireUnsafe(self, container);
    }
    try checkIndex(self, indexNode);
    let subjectTy = autoDeref(containerTy);
    if let case Type::Slice { item, .. } = subjectTy {
        return setNodeType(self, node, *item);
    if let case Type::Slice(slice) = subjectTy {
        return setNodeType(self, node, *slice.item);
    }

    match subjectTy {
        case Type::Array(arrayInfo) => {
            return setNodeType(self, node, *arrayInfo.item);
        }
        case Type::GenericArray { item, .. } => {
            return setNodeType(self, node, *item);
        }
        else => {
            throw emitError(self, container, ErrorKind::ExpectedIndexable);
        }
    }
}

    // Check if this is a scope access that might be a union variant.
    if let case ast::NodeValue::ScopeAccess(access) = typeIdent.value {
        let sym = try resolveAccess(self, typeIdent, access, self.scope);

        // Check if resolved symbol is a union variant.
        if let case SymbolData::Variant { type, decl, ordinal, index } = sym.data {
            // Get the union type from the variant's declaration.
            let declSym = symbolFor(self, decl)
        if let case SymbolData::Variant { type, ordinal, index, .. } = sym.data {
            let resolved = typeFor(self, typeIdent)
                else throw emitError(self, node, ErrorKind::Internal);
            let case SymbolData::Type(unionNominalType) = declSym.data
            let case Type::Nominal(unionNominalType) = resolved
                else throw emitError(self, node, ErrorKind::Internal);

            // Get the variant's payload type.
            let case Type::Nominal(payloadInfo) = type
                else throw emitError(self, node, ErrorKind::ExpectedRecord);

    throws (ResolveError)
{
    let mut itemHint = hint;
    if let case Type::Array(ary) = hint {
        set itemHint = *ary.item;
    } else if let case Type::GenericArray { item, .. } = hint {
        set itemHint = *item;
    } else if let case Type::Optional(inner) = hint {
        if let case Type::Array(ary) = *inner {
            set itemHint = *ary.item;
        }
    }
    let valueTy = try visit(self, lit.item, itemHint);
    let count = try checkSizeInt(self, lit.count);
    let arrayTy = Type::Array(ArrayType {
        item: allocType(self, valueTy),
        length: count,
    });
    let _ = try checkNumeric(self, lit.count);
    let mut arrayTy: Type = undefined;
    if let value = constValueEntry(self, lit.count) {
        if not validateConstIntRange(value, Type::U32) {
            throw emitError(self, lit.count, ErrorKind::NumericLiteralOverflow);
        }
        let case ConstValue::Int(int) = value
            else throw emitError(self, lit.count, ErrorKind::ConstExprRequired);
        set arrayTy = Type::Array(ArrayType {
            item: allocType(self, valueTy),
            length: int.magnitude as u32,
        });
    } else if isConstExpr(self, lit.count) and
              containsGenericConstExpr(self, lit.count)
    {
        set arrayTy = Type::GenericArray {
            item: allocType(self, valueTy),
            length: lit.count,
        };
    } else {
        throw emitError(self, lit.count, ErrorKind::ConstExprRequired);
    }
    return setNodeType(self, node, arrayTy);
}

/// Resolve union variant access.
fn resolveUnionVariantAccess(

    let sym = try resolveAccess(self, node, access, self.scope);
    let mut ty: Type = undefined;

    match sym.data {
        case SymbolData::Value { type, .. } => {
            if isGenericDeclaration(sym.node) {
                throw emitError(self, node, ErrorKind::GenericArgumentsRequired);
            }
            setNodeSymbol(self, node, sym);
            set ty = type;
        }
        case SymbolData::Constant { type, value } => {
            // Propagate the constant value.

            }
            setNodeSymbol(self, node, sym);
            set ty = type;
        }
        case SymbolData::Type(t) => {
            if isGenericDeclaration(sym.node) {
                throw emitError(self, node, ErrorKind::GenericArgumentsRequired);
            }
            setNodeSymbol(self, node, sym);
            set ty = Type::Nominal(t);
        }
        case SymbolData::TypeParameter(param) => {
            set *param.used = true;
            setNodeSymbol(self, node, sym);
            set ty = Type::Parameter(param);
        }
        case SymbolData::ConstParameter(param) => {
            set *param.used = true;
            setNodeSymbol(self, node, sym);
            let constType = param.constType
                else throw emitError(self, node, ErrorKind::Internal);
            set ty = *constType;
        }
        case SymbolData::Variant { index, .. } => {
            let ty = typeFor(self, node)
                else throw emitError(self, node, ErrorKind::Internal);
            // For unions without payload, store the variant index as a constant.
            if isVoidUnion(ty) {

        }
    }
    return setNodeType(self, node, ty);
}

/// Find one bound method, rejecting ambiguous unqualified selections.
fn findGenericBoundMethod(
    self: *mut Resolver,
    node: *ast::Node,
    param: *GenericParamType,
    name: *[u8],
) -> GenericBoundMethod throws (ResolveError) {
    let mut found: ?GenericBoundMethod = nil;
    for bound in param.bounds {
        if let method = findTraitMethod(bound, name) {
            if found <> nil {
                throw emitError(self, node, ErrorKind::GenericBoundAmbiguous(name));
            }
            set found = GenericBoundMethod { traitInfo: bound, method };
        }
    }
    let result = found else throw emitError(
        self, node, ErrorKind::RecordFieldUnknown(name)
    );
    return result;
}

/// Analyze a field access expression.
fn resolveFieldAccess(self: *mut Resolver, node: *ast::Node, access: ast::Access) -> Type
    throws (ResolveError)
{
    let parentTy = try infer(self, access.parent);
    if isUnsafePointerType(parentTy) {
        try requireUnsafe(self, access.parent);
    }
    let subjectTy = autoDeref(parentTy);

    if let case Type::Slice { class, item, mutable } = subjectTy {
    if let case Type::Slice(slice) = subjectTy {
        let fieldNode = access.child;
        let fieldName = try nodeName(self, fieldNode);
        if mem::eq(fieldName, PTR_FIELD) {
            setRecordFieldIndex(self, fieldNode, 0);
            return setNodeType(
                self,
                node,
                Type::Pointer { class, target: item, mutable },
                Type::Pointer(PointerType {
                    class: slice.class,
                    target: slice.item,
                    mutable: slice.mutable,
                }),
            );
        }
        if mem::eq(fieldName, LEN_FIELD) {
            setRecordFieldIndex(self, fieldNode, 1);
            return setNodeType(self, node, Type::U32);

            setRecordFieldIndex(self, fieldNode, 2);
            return setNodeType(self, node, Type::U32);
        }
        throw emitError(self, node, ErrorKind::SliceFieldUnknown(fieldName));
    }
    if let case Type::TraitObject { traitInfo, .. } = subjectTy {
    if let case Type::TraitObject(traitObject) = subjectTy {
        let fieldName = try nodeName(self, access.child);
        let method = findTraitMethod(traitInfo, fieldName)
        let method = findTraitMethod(traitObject.traitInfo, fieldName)
            else throw emitError(self, node, ErrorKind::RecordFieldUnknown(fieldName));
        return setNodeType(self, node, Type::Fn(method.fnType));
    }

    match subjectTy {
        case Type::Parameter(param) if param.bounds.len > 0 => {
            let fieldName = try nodeName(self, access.child);
            let selected = try findGenericBoundMethod(
                self, access.child, param, fieldName
            );
            let selfParam: [*GenericParamType; 1] = [selected.method.owner.selfType];
            let selfArg: [*Type; 1] = [allocType(self, Type::Parameter(param))];
            let sub = Substitution {
                params: &selfParam[..],
                args: &selfArg[..],
            };
            let methodType = try substituteType(
                self, Type::Fn(selected.method.fnType), &sub, node
            );
            return setNodeType(self, node, methodType);
        }
        case Type::GenericDataApply(application) => {
            let template = genericTemplateFor(self, application.template)
                else throw emitError(self, node, ErrorKind::Internal);
            let case ast::NodeValue::RecordDecl(decl) = application.template.node.value
                else throw emitError(self, access.parent, ErrorKind::ExpectedRecord);
            let fieldName = try nodeName(self, access.child);
            for fieldNode, index in decl.fields {
                let case ast::NodeValue::RecordField { field: maybeField, .. } =
                    fieldNode.value
                    else throw emitError(self, node, ErrorKind::Internal);
                let fieldNodeName = maybeField
                    else throw emitError(self, fieldNode, ErrorKind::Internal);
                let candidate = try nodeName(self, fieldNodeName);
                if mem::eq(candidate, fieldName) {
                    let sub = Substitution {
                        params: template.params,
                        args: application.args,
                    };
                    let fieldType = try substituteType(
                        self, *template.members[index], &sub, node
                    );
                    setRecordFieldIndex(self, access.child, index);
                    return setNodeType(self, node, fieldType);
                }
            }
            throw emitError(self, node, ErrorKind::RecordFieldUnknown(fieldName));
        }
        case Type::Nominal(NominalType::Record(recordType)) => {
            let fieldNode = access.child;
            let fieldName = try nodeName(self, fieldNode);
            if let fieldIndex = findRecordField(&recordType, fieldName) {
                let fieldTy = recordType.fields[fieldIndex].fieldType;

                return setNodeType(self, node, Type::U32);
            }
            throw emitError(self, node, ErrorKind::ArrayFieldUnknown(fieldName));
        }

        case Type::GenericArray { .. } => {
            let fieldName = try nodeName(self, access.child);
            if mem::eq(fieldName, LEN_FIELD) {
                return setNodeType(self, node, Type::U32);
            }

            throw emitError(self, node, ErrorKind::ArrayFieldUnknown(fieldName));
        }
        else => {
            // Check for standalone methods on any nominal type (e.g. unions).
            if let case Type::Nominal(_) = subjectTy {
                let fieldName = try nodeName(self, access.child);
                if let method = findMethod(self, subjectTy, fieldName) {

            if mutable {
                return true;
            }
            // Check if the type is a mutable pointer or slice.
            let ty = typeFor(self, node) else return false;
            if let case Type::Pointer { mutable, .. } = ty {
                return mutable;
            if let case Type::Pointer(pointer) = ty {
                return pointer.mutable;
            }
            if let case Type::Slice { mutable, .. } = ty {
                return mutable;
            if let case Type::Slice(slice) = ty {
                return slice.mutable;
            }
            return false;
        }
        case ast::NodeValue::FieldAccess(access) => {
            let _ = try infer(self, access.parent);

        case ast::NodeValue::Subscript { container, .. } => {
            let containerTy = try infer(self, container);
            // Subscript auto-derefs pointers, so check the actual indexed type.
            let subjectTy = autoDeref(containerTy);

            if let case Type::Slice { mutable, .. } = subjectTy {
                return mutable;
            if let case Type::Slice(slice) = subjectTy {
                return slice.mutable;
            }
            if let case Type::Array(_) = subjectTy {
                return try canBorrowMutFrom(self, container);
            }
            return false;

        }
        case ast::NodeValue::Call(_) => {
            // A call returning `*mut T` (or `&mut [T]`) yields a
            // mutable place. Non-pointer returns cannot be mutably borrowed.
            let ty = try infer(self, node);
            if let case Type::Pointer { mutable, .. } = ty {
                return mutable;
            if let case Type::Pointer(pointer) = ty {
                return pointer.mutable;
            }
            if let case Type::Slice { mutable, .. } = ty {
                return mutable;
            if let case Type::Slice(slice) = ty {
                return slice.mutable;
            }
            return false;
        }
        case ast::NodeValue::Deref(inner) => {
            let innerTy = try infer(self, inner);

            if let case Type::Pointer { mutable, .. } = innerTy {
                return mutable;
            if let case Type::Pointer(pointer) = innerTy {
                return pointer.mutable;
            }
            if let case Type::Slice { mutable, .. } = innerTy {
                return mutable;
            if let case Type::Slice(slice) = innerTy {
                return slice.mutable;
            }
            // Record deref: mutability depends on the inner binding.
            if let case Type::Nominal(NominalType::Record(recInfo)) = innerTy {
                if not recInfo.labeled and recInfo.fields.len == 1 {
                    return try canBorrowMutFrom(self, inner);

            try checkSliceRangeIndices(self, range);

            let mut item: *Type = undefined;
            let mut capacity: ?u32 = nil;

            if let case Type::Slice { item: sliceItem, mutable: sliceMutable, .. } = subjectTy {
                if addr.mutable and not sliceMutable {
            if let case Type::Slice(slice) = subjectTy {
                if addr.mutable and not slice.mutable {
                    throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
                }
                set item = sliceItem;
                set item = slice.item;
            } else {
                match subjectTy {
                    case Type::Array(arrayInfo) => {
                        try validateArraySliceBounds(self, range, arrayInfo.length, node);
                        set item = arrayInfo.item;

                    else => {
                        throw emitError(self, container, ErrorKind::ExpectedIndexable);
                    }
                }
            }
            let sliceTy = Type::Slice { class, item, mutable: addr.mutable };
            let sliceTy = Type::Slice(SliceType {
                class,
                item,
                mutable: addr.mutable,
            });
            let alloc = allocType(self, sliceTy);
            setSliceRangeInfo(self, node, SliceRangeInfo {
                itemType: item,
                mutable: addr.mutable,
                capacity,

            return setNodeType(self, node, *alloc);
        }
    }
    // Derive a hint for the target type from the slice hint.
    let mut targetHint: Type = Type::Unknown;
    if let case Type::Slice { item, .. } = hint {
        set targetHint = Type::Array(ArrayType { item, length: 0 });
    if let case Type::Slice(slice) = hint {
        set targetHint = Type::Array(ArrayType { item: slice.item, length: 0 });
    }
    let targetTy = try visit(self, addr.target, targetHint);

    // Mark local variable symbols as address-taken so the lowerer
    // allocates a stack slot eagerly.

    if let case Type::Array(arrayInfo) = targetTy {
        match addr.target.value {
            case ast::NodeValue::ArrayLit(_),
                 ast::NodeValue::ArrayRepeatLit(_) =>
            {
                let sliceTy = Type::Slice { class, item: arrayInfo.item, mutable: addr.mutable };
                let sliceTy = Type::Slice(SliceType {
                    class,
                    item: arrayInfo.item,
                    mutable: addr.mutable,
                });
                return setNodeType(self, node, *allocType(self, sliceTy));
            }
            else => {}
        }
    }
    let pointerTy = Type::Pointer {
        class, target: allocType(self, targetTy), mutable: addr.mutable,
    };
    let pointerTy = Type::Pointer(PointerType {
        class,
        target: allocType(self, targetTy),
        mutable: addr.mutable,
    });
    return setNodeType(self, node, pointerTy);
}

/// Analyze a dereference expression.
fn resolveDeref(self: *mut Resolver, node: *ast::Node, targetNode: *ast::Node, hint: Type) -> Type
    throws (ResolveError)
{
    let operandTy = try visit(self, targetNode, hint);
    if let case Type::Pointer { class, target, .. } = operandTy {
        if class == types::PointerClass::Unsafe {
    if let case Type::Pointer(pointer) = operandTy {
        if pointer.class == types::PointerClass::Unsafe {
            try requireUnsafe(self, targetNode);
        }
        // Disallow dereferencing opaque pointers.
        if *target == Type::Opaque {
        if *pointer.target == Type::Opaque {
            throw emitError(self, targetNode, ErrorKind::OpaqueTypeDeref);
        }
        return setNodeType(self, node, *target);
        return setNodeType(self, node, *pointer.target);
    }
    // Auto-deref for single-field unlabeled records.
    if let case Type::Nominal(NominalType::Record(recInfo)) = operandTy {
        if not recInfo.labeled and recInfo.fields.len == 1 {
            let fieldTy = recInfo.fields[0].fieldType;

    throw emitError(self, targetNode, ErrorKind::ExpectedPointer);
}

/// Check if a type is a pointer to opaque.
fn isOpaquePointer(ty: Type) -> bool {
    if let case Type::Pointer { target, .. } = ty {
        return *target == Type::Opaque;
    if let case Type::Pointer(pointer) = ty {
        return *pointer.target == Type::Opaque;
    }
    return false;
}

/// Check if a type is an opaque slice.
fn isOpaqueSlice(ty: Type) -> bool {
    if let case Type::Slice { item, .. } = ty {
        return *item == Type::Opaque;
    if let case Type::Slice(slice) = ty {
        return *slice.item == Type::Opaque;
    }
    return false;
}

/// Check if an `as` cast between two types is valid.

    // TODO: Check that variant index fits in target type.
    if isVoidUnion(source) and isNumericType(target) {
        return true;
    }
    // Allow address to numeric.
    if let case Type::Slice { .. } = source {
    if let case Type::Slice(_) = source {
        // Disallow slice to numeric; slices are fat pointers.
    } else if isAddressType(source) and isNumericType(target) {
        return true;
    }
    // Allow pointer casts if one side is `*opaque` or target types are castable.
    if let case Type::Pointer {
        class: sourceClass, target: sourceTarget, mutable: sourceMutable,
    } = source {
        if let case Type::Pointer {
            class: targetClass, target: targetTarget, mutable: targetMutable,
        } = target {
            if sourceClass <> targetClass {
    if let case Type::Pointer(sourcePointer) = source {
        if let case Type::Pointer(targetPointer) = target {
            if sourcePointer.class <> targetPointer.class {
                return false;
            }
            if targetMutable and not sourceMutable {
            if targetPointer.mutable and not sourcePointer.mutable {
                return false;
            }
            if isOpaquePointer(source) or isOpaquePointer(target) {
                return true;
            }
            return isValidCast(*sourceTarget, *targetTarget);
            return isValidCast(*sourcePointer.target, *targetPointer.target);
        }
    }
    // Allow slice casts if one side is `*[opaque]`, target is `*[u8]`,
    // or element types are castable.
    if let case Type::Slice {
        class: sourceClass, item: sourceItem, mutable: sourceMutable,
    } = source {
        if let case Type::Slice {
            class: targetClass, item: targetItem, mutable: targetMutable,
        } = target {
            if sourceClass <> targetClass {
    if let case Type::Slice(sourceSlice) = source {
        if let case Type::Slice(targetSlice) = target {
            if sourceSlice.class <> targetSlice.class {
                return false;
            }
            if targetMutable and not sourceMutable {
            if targetSlice.mutable and not sourceSlice.mutable {
                return false;
            }
            if isOpaqueSlice(source) or isOpaqueSlice(target) {
                return true;
            }
            if *targetItem == Type::U8 {
            if *targetSlice.item == Type::U8 {
                return true;
            }
            return isValidCast(*sourceItem, *targetItem);
            return isValidCast(*sourceSlice.item, *targetSlice.item);
        }
    }
    return false;
}



    assert sourceTy <> Type::Unknown;
    assert targetTy <> Type::Unknown;

    let mut valid = isValidCast(sourceTy, targetTy);
    if let case Type::Pointer {
        class: sourceClass, target: sourceTarget, mutable: sourceMutable,
    } = sourceTy {
        if let case Type::Pointer {
            class: targetClass, target: targetTarget, mutable: targetMutable,
        } = targetTy {
            if sourceClass == types::PointerClass::Ref and
               targetClass == types::PointerClass::Unsafe and
               (not targetMutable or sourceMutable) and
               isValidCast(*sourceTarget, *targetTarget)
    if let case Type::Pointer(sourcePointer) = sourceTy {
        if let case Type::Pointer(targetPointer) = targetTy {
            if sourcePointer.class == types::PointerClass::Ref and
               targetPointer.class == types::PointerClass::Unsafe and
               (not targetPointer.mutable or sourcePointer.mutable) and
               isValidCast(*sourcePointer.target, *targetPointer.target)
            {
                set valid = true;
            }
        }
    }
    if let case Type::Slice {
        class: sourceClass, item: sourceItem, mutable: sourceMutable,
    } = sourceTy {
        if let case Type::Slice {
            class: targetClass, item: targetItem, mutable: targetMutable,
        } = targetTy {
            if sourceClass == types::PointerClass::Ref and
               targetClass == types::PointerClass::Unsafe and
               (not targetMutable or sourceMutable) and
               isValidCast(*sourceItem, *targetItem)
    if let case Type::Slice(sourceSlice) = sourceTy {
        if let case Type::Slice(targetSlice) = targetTy {
            if sourceSlice.class == types::PointerClass::Ref and
               targetSlice.class == types::PointerClass::Unsafe and
               (not targetSlice.mutable or sourceSlice.mutable) and
               isValidCast(*sourceSlice.item, *targetSlice.item)
            {
                set valid = true;
            }
        }
    }

    throws (ResolveError)
{
    let call = tryExpr.expr;
    let case ast::NodeValue::Call(callExpr) = call.value
        else throw emitError(self, call, ErrorKind::TryNonThrowing);
    let resultTy = try resolveCall(self, call, callExpr, CallCtx::Try);
    let resultTy = try resolveCall(
        self, call, callExpr, CallCtx::Try, hint
    );

    // TODO: It's annoying that we need to re-fetch the function type after
    // analyzing the call.
    let calleeTy = typeFor(self, callExpr.callee)
        else return setNodeType(self, node, resultTy);

            return ConstValue::Bool(l > r if signed else left.magnitude > right.magnitude),
        case ast::BinaryOp::Lte =>
            return ConstValue::Bool(l <= r if signed else left.magnitude <= right.magnitude),
        case ast::BinaryOp::Gte =>
            return ConstValue::Bool(l >= r if signed else left.magnitude >= right.magnitude),
        case ast::BinaryOp::Add => return ConstValue::Int(constIntFromSigned(l + r, bits, signed)),
        case ast::BinaryOp::Sub => return ConstValue::Int(constIntFromSigned(l - r, bits, signed)),
        case ast::BinaryOp::Mul => return ConstValue::Int(constIntFromSigned(l * r, bits, signed)),
        case ast::BinaryOp::Add => {
            if not signed {
                return ConstValue::Int(
                    constIntFromBits(left.magnitude + right.magnitude, bits, false)
                );
            }
            return ConstValue::Int(constIntFromSigned(l + r, bits, true));
        },
        case ast::BinaryOp::Sub => {
            if not signed {
                return ConstValue::Int(
                    constIntFromBits(left.magnitude - right.magnitude, bits, false)
                );
            }
            return ConstValue::Int(constIntFromSigned(l - r, bits, true));
        },
        case ast::BinaryOp::Mul => {
            if not signed {
                return ConstValue::Int(
                    constIntFromBits(left.magnitude * right.magnitude, bits, false)
                );
            }
            return ConstValue::Int(constIntFromSigned(l * r, bits, true));
        },
        case ast::BinaryOp::Div => {
            if signed {
                if r == 0 {
                    return nil;
                }
                if l == parser::I64_MIN and r == -1 {
                    return ConstValue::Int(
                        constIntFromBits(parser::I64_MIN as u64, bits, true)
                    );
                }
                return ConstValue::Int(constIntFromSigned(l / r, bits, true));
            }
            if right.magnitude == 0 {
                return nil;
            }

        case ast::BinaryOp::Mod => {
            if signed {
                if r == 0 {
                    return nil;
                }
                if l == parser::I64_MIN and r == -1 {
                    return ConstValue::Int(
                        constIntFromBits(0, bits, true)
                    );
                }
                return ConstValue::Int(constIntFromSigned(l % r, bits, true));
            }
            if right.magnitude == 0 {
                return nil;
            }
            return constInt(left.magnitude % right.magnitude, bits, false, false);
        },
        case ast::BinaryOp::BitAnd => return ConstValue::Int(constIntFromSigned(l & r, bits, signed)),
        case ast::BinaryOp::BitOr  => return ConstValue::Int(constIntFromSigned(l | r, bits, signed)),
        case ast::BinaryOp::BitXor => return ConstValue::Int(constIntFromSigned(l ^ r, bits, signed)),
        case ast::BinaryOp::BitAnd => return ConstValue::Int(
            constIntFromBits(constIntToBits(left) & constIntToBits(right), bits, signed)
        ),
        case ast::BinaryOp::BitOr => return ConstValue::Int(
            constIntFromBits(constIntToBits(left) | constIntToBits(right), bits, signed)
        ),
        case ast::BinaryOp::BitXor => return ConstValue::Int(
            constIntFromBits(constIntToBits(left) ^ constIntToBits(right), bits, signed)
        ),
        else => return nil,
    }
}

/// Try to constant-fold a binary operation on two resolved operands.

                let leftTy = try infer(self, binop.left);
                let rightTy = try visit(self, binop.right, leftTy);

                // Allow arithmetic on owning pointers and unsafe pointers, but
                // never on references.
                if let case Type::Pointer { class: leftClass, target: leftTarget, .. } = leftTy {
                    if *leftTarget == Type::Opaque {
                if let case Type::Pointer(leftPointer) = leftTy {
                    if *leftPointer.target == Type::Opaque {
                        throw emitError(self, node, ErrorKind::OpaquePointerArithmetic);
                    }
                    if leftClass <> types::PointerClass::Ref
                    if leftPointer.class <> types::PointerClass::Ref
                        and isNumericType(rightTy)
                    {
                        if leftClass == types::PointerClass::Unsafe {
                        if leftPointer.class == types::PointerClass::Unsafe {
                            try requireUnsafe(self, node);
                        }
                        return setNodeType(self, node, leftTy);
                    }
                }
                if let case Type::Pointer { class: rightClass, target: rightTarget, .. } = rightTy {
                    if *rightTarget == Type::Opaque {
                if let case Type::Pointer(rightPointer) = rightTy {
                    if *rightPointer.target == Type::Opaque {
                        throw emitError(self, node, ErrorKind::OpaquePointerArithmetic);
                    }
                    if binop.op == ast::BinaryOp::Add
                        and rightClass <> types::PointerClass::Ref
                        and rightPointer.class <> types::PointerClass::Ref
                        and isNumericType(leftTy)
                    {
                        if rightClass == types::PointerClass::Unsafe {
                        if rightPointer.class == types::PointerClass::Unsafe {
                            try requireUnsafe(self, node);
                        }
                        return setNodeType(self, node, rightTy);
                    }
                }

        },
    };
    return setNodeType(self, node, resultTy);
}

/// Resolve a type signature node and set its type.
fn inferTypeSig(self: *mut Resolver, node: *ast::Node, sig: ast::TypeSig) -> Type
    throws (ResolveError)
{
    let resolved = try resolveTypeSig(self, node, sig);

    return setNodeType(self, node, resolved);
}

/// Convert a type signature node into a type value.
fn resolveTypeSig(self: *mut Resolver, node: *ast::Node, sig: ast::TypeSig) -> Type
    throws (ResolveError)
{
/// Resolve type syntax in an ordinary or symbolic generic context.
fn resolveTypeSyntax(
    self: *mut Resolver,
    node: *ast::Node,
    context: TypeSyntaxContext,
) -> Type throws (ResolveError) {
    let case ast::NodeValue::TypeSig(sig) = node.value
        else panic "resolveTypeSyntax: expected type signature";
    let mut ty: Type = undefined;
    match sig {
        case ast::TypeSig::Void => {
            return Type::Void;
        }
        case ast::TypeSig::Void => set ty = Type::Void,
        case ast::TypeSig::Opaque => {
            return Type::Opaque;
        }
        case ast::TypeSig::Bool => {
            return Type::Bool;
            if let case TypeSyntaxContext::Symbolic = context {
                throw emitError(self, node, ErrorKind::OpaqueTypeNotAllowed);
            }
            set ty = Type::Opaque;
        }
        case ast::TypeSig::Bool => set ty = Type::Bool,
        case ast::TypeSig::Integer { width, sign } => {
            let u = sign == ast::Signedness::Unsigned;
            let unsigned = sign == ast::Signedness::Unsigned;
            match width {
                case 1 => return Type::U8 if u else Type::I8,
                case 2 => return Type::U16 if u else Type::I16,
                case 4 => return Type::U32 if u else Type::I32,
                case 8 => return Type::U64 if u else Type::I64,
                else => {
                    panic "resolveTypeSig: invalid integer width";
                }
                case 1 => set ty = Type::U8 if unsigned else Type::I8,
                case 2 => set ty = Type::U16 if unsigned else Type::I16,
                case 4 => set ty = Type::U32 if unsigned else Type::I32,
                case 8 => set ty = Type::U64 if unsigned else Type::I64,
                else => panic "resolveTypeSyntax: invalid integer width",
            }
        }
        case ast::TypeSig::Array { itemType, length } => {
            let item = try infer(self, itemType);
            let length = try checkSizeInt(self, length);

            return Type::Array(ArrayType { item: allocType(self, item), length });
            let item = try resolveTypeSyntax(self, itemType, context);
            match context {
                case TypeSyntaxContext::Concrete => {
                    let concreteLength = try checkSizeInt(self, length);
                    set ty = Type::Array(ArrayType {
                        item: allocType(self, item),
                        length: concreteLength,
                    });
                }
                case TypeSyntaxContext::Symbolic => {
                    let _ = try checkNumeric(self, length);
                    if let value = constValueEntry(self, length) {
                        if not validateConstIntRange(value, Type::U32) {
                            throw emitError(
                                self, length, ErrorKind::NumericLiteralOverflow
                            );
                        }
                        let case ConstValue::Int(int) = value else {
                            throw emitError(
                                self, length, ErrorKind::ConstExprRequired
                            );
                        };
                        set ty = Type::Array(ArrayType {
                            item: allocType(self, item),
                            length: int.magnitude as u32,
                        });
                    } else if isConstExpr(self, length) and
                              containsGenericConstExpr(self, length)
                    {
                        set ty = Type::GenericArray {
                            item: allocType(self, item),
                            length,
                        };
                    } else {
                        throw emitError(
                            self, length, ErrorKind::ConstExprRequired
                        );
                    }
                }
            }
        }
        case ast::TypeSig::Slice { class, itemType, mutable } => {
            let item = try infer(self, itemType);
            return Type::Slice {
            let item = try resolveTypeSyntax(self, itemType, context);
            set ty = Type::Slice(SliceType {
                class,
                item: allocType(self, item),
                mutable,
            };
            });
        }
        case ast::TypeSig::Pointer { class, valueType, mutable } => {
            let target = try infer(self, valueType);
            return Type::Pointer {
            let target = try resolveTypeSyntax(self, valueType, context);
            set ty = Type::Pointer(PointerType {
                class,
                target: allocType(self, target),
                mutable,
            };
            });
        }
        case ast::TypeSig::Optional { valueType } => {
            let payload = try infer(self, valueType);
            return Type::Optional(allocType(self, payload));
            let payload = try resolveTypeSyntax(self, valueType, context);
            set ty = Type::Optional(allocType(self, payload));
        }
        case ast::TypeSig::Nominal(name) => {
            let ty = try resolveTypeName(self, name);
            return Type::Nominal(ty);
            if let case TypeSyntaxContext::Symbolic = context {
                if let case ast::NodeValue::GenericApply(app) = name.value {
                    let templateSym = try resolveGenericDataTarget(self, app.target);
                    try ensureGenericDataTemplate(self, templateSym);
                    let template = genericTemplateFor(self, templateSym)
                        else throw emitError(self, name, ErrorKind::Internal);
                    if app.args.len <> template.params.len {
                        throw emitError(
                            self,
                            name,
                            ErrorKind::GenericArgumentCount(CountMismatch {
                                expected: template.params.len,
                                actual: app.args.len,
                            }),
                        );
                    }
                    let a = alloc::arenaAllocator(&mut self.arena);
                    let mut args: *mut [*Type] = &mut [];
                    for argNode, i in app.args {
                        let arg = try resolveGenericArgument(
                            self, argNode, template.params[i]
                        );
                        args.append(allocType(self, arg), a);
                    }
                    let symbolic = try! alloc::alloc(
                        &mut self.arena,
                        @sizeOf(GenericDataApplyType),
                        @alignOf(GenericDataApplyType),
                    ) as *mut GenericDataApplyType;
                    set *symbolic = GenericDataApplyType {
                        template: templateSym,
                        args: &args[..],
                        site: name,
                    };
                    return setNodeType(
                        self, node, Type::GenericDataApply(symbolic)
                    );
                }
            }
            if let case ast::NodeValue::Ident(paramName) = name.value {
                if mem::eq(paramName, "Self") {
                    let selfType = self.currentTraitSelf else {
                        throw emitError(
                            self, name, ErrorKind::UnresolvedSymbol(paramName)
                        );
                    };
                    set *selfType.used = true;
                    set ty = Type::Parameter(selfType);
                } else {
                    let sym = findTypeSymbol(self.scope, paramName) else {
                        throw emitError(
                            self, name, ErrorKind::UnresolvedSymbol(paramName)
                        );
                    };
                    match sym.data {
                        case SymbolData::Type(nominal) => {
                            if isGenericDeclaration(sym.node) {
                                throw emitError(
                                    self, name, ErrorKind::GenericArgumentsRequired
                                );
                            }
                            setNodeSymbol(self, name, sym);
                            set ty = Type::Nominal(nominal);
                        }
                        case SymbolData::TypeParameter(param) => {
                            set *param.used = true;
                            setNodeSymbol(self, name, sym);
                            set ty = Type::Parameter(param);
                        }
                        else => throw emitError(
                            self, name, ErrorKind::Internal
                        ),
                    }
                }
            } else {
                let nominal = try resolveTypeName(self, name);
                set ty = Type::Nominal(nominal);
            }
        }
        case ast::TypeSig::Record { fields, labeled } => {
            let recordType = try resolveRecordFields(self, node, fields, labeled);
            let nominalTy = allocNominalType(self, NominalType::Record(recordType));
            return Type::Nominal(nominalTy);
            match context {
                case TypeSyntaxContext::Concrete => {
                    let recordType = try buildRecordType(
                        self,
                        node,
                        fields,
                        labeled,
                        false,
                        AggregateMemberSource::Ordinary,
                    );
                    set ty = Type::Nominal(allocNominalType(
                        self, NominalType::Record(recordType)
                    ));
                }
                case TypeSyntaxContext::Symbolic => {
                    let a = alloc::arenaAllocator(&mut self.arena);
                    let mut result: *mut [RecordField] = &mut [];
                    for field in fields {
                        let case ast::NodeValue::RecordField {
                            field: fieldNameNode,
                            type: typeNode,
                            value,
                        } = field.value else {
                            panic "resolveTypeSyntax: invalid record field";
                        };
                        let fieldType = try resolveTypeSyntax(
                            self, typeNode, context
                        );
                        try ensureStorableType(self, typeNode, fieldType);
                        if let initializer = value {
                            let _ = try checkAssignable(
                                self, initializer, fieldType
                            );
                        }
                        let mut fieldName: ?*[u8] = nil;
                        if let nameNode = fieldNameNode {
                            set fieldName = try nodeName(self, nameNode);
                        }
                        result.append(RecordField {
                            name: fieldName,
                            fieldType,
                            offset: -1,
                        }, a);
                    }
                    let genericRecord = try! alloc::alloc(
                        &mut self.arena,
                        @sizeOf(GenericRecordType),
                        @alignOf(GenericRecordType),
                    ) as *mut GenericRecordType;
                    set *genericRecord = GenericRecordType {
                        fields: &result[..],
                        labeled,
                    };
                    set ty = Type::GenericRecord(genericRecord);
                }
            }
        }
        case ast::TypeSig::Fn(t) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut paramTypes: *mut [*Type] = &mut [];
            let mut throwList: *mut [*Type] = &mut [];

            if t.params.len > MAX_FN_PARAMS {
                throw emitError(self, node, ErrorKind::FnParamOverflow(CountMismatch {
                    expected: MAX_FN_PARAMS,
                    actual: t.params.len,
                }));
        case ast::TypeSig::Fn(signature) => {
            if signature.params.len > MAX_FN_PARAMS {
                throw emitError(self, node, ErrorKind::FnParamOverflow(
                    CountMismatch {
                        expected: MAX_FN_PARAMS,
                        actual: signature.params.len,
                    }
                ));
            }
            if t.throwList.len > MAX_FN_THROWS {
                throw emitError(self, node, ErrorKind::FnThrowOverflow(CountMismatch {
                    expected: MAX_FN_THROWS,
                    actual: t.throwList.len,
                }));
            if signature.throwList.len > MAX_FN_THROWS {
                throw emitError(self, node, ErrorKind::FnThrowOverflow(
                    CountMismatch {
                        expected: MAX_FN_THROWS,
                        actual: signature.throwList.len,
                    }
                ));
            }

            for paramNode in t.params {
                let paramTy = try resolveValueType(self, paramNode);
                paramTypes.append(allocType(self, paramTy), a);
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut params: *mut [*Type] = &mut [];
            let mut throwTypes: *mut [*Type] = &mut [];
            for param in signature.params {
                let paramType = try resolveContextualValueType(
                    self, param, context
                );
                params.append(allocType(self, paramType), a);
            }
            for tyNode in t.throwList {
                let throwTy = try resolveValueType(self, tyNode);
                try ensureStorableType(self, tyNode, throwTy);
                throwList.append(allocType(self, throwTy), a);
            for throwNode in signature.throwList {
                let throwType = try resolveContextualValueType(
                    self, throwNode, context
                );
                try ensureStorableType(self, throwNode, throwType);
                throwTypes.append(allocType(self, throwType), a);
            }
            let mut retType = allocType(self, Type::Void);
            if let ret = t.returnType {
                let resolvedRet = try resolveValueType(self, ret);
                try ensureStorableType(self, ret, resolvedRet);
                set retType = allocType(self, resolvedRet);
            let mut returnType = allocType(self, Type::Void);
            if let returnNode = signature.returnType {
                let resolved = try resolveContextualValueType(
                    self, returnNode, context
                );
                try ensureStorableType(self, returnNode, resolved);
                set returnType = allocType(self, resolved);
            }
            let fnType = FnType {
                paramTypes: &paramTypes[..],
                returnType: retType,
                throwList: &throwList[..],
            set ty = Type::Fn(allocFnType(self, FnType {
                paramTypes: &params[..],
                returnType,
                throwList: &throwTypes[..],
                isUnsafe: false,
                localCount: 0,
            };
            return Type::Fn(allocFnType(self, fnType));
            }));
        }
        // Resolve an opaque trait object signature.
        case ast::TypeSig::TraitObject { class, traitName, mutable } => {
            let sym = try resolveNamePath(self, traitName);
            let case SymbolData::Trait(traitInfo) = sym.data
                else throw emitError(self, traitName, ErrorKind::Internal);
            if traitInfo.state == TraitState::Queued {
                let case ast::NodeValue::TraitDecl {
                    supertraits, methods, ..
                } = sym.node.value else {
                    throw emitError(self, traitName, ErrorKind::Internal);
                };
                try resolveTraitBody(self, sym.node, supertraits, methods);
            }
            if not traitInfo.objectSafe {
                throw emitError(self, traitName, ErrorKind::TraitNotObjectSafe);
            }
            setNodeSymbol(self, traitName, sym);

            return Type::TraitObject { class, traitInfo, mutable };
            set ty = Type::TraitObject(TraitObjectType {
                class,
                traitInfo,
                mutable,
            });
        }
    }
    return setNodeType(self, node, ty);
}

/// Check if a type can be used for inferrence.
fn isTypeInferrable(type: Type) -> bool {
    if let case Type::Pointer { target, .. } = type {
        return isTypeInferrable(*target);
    if let case Type::Pointer(pointer) = type {
        return isTypeInferrable(*pointer.target);
    }
    match type {
        case Type::Unknown, Type::Nil, Type::Undefined, Type::Int => return false,
        case Type::Array(ary) => return isTypeInferrable(*ary.item),
        case Type::Optional(opt) => return isTypeInferrable(*opt),

        return Diagnostics { errors: self.errors };
    };
    exitScope(self);
    setNodeType(self, root, Type::Void);

    try closeGenericFnSpecializations(self) catch {
        return Diagnostics { errors: self.errors };
    };
    try materializeGenericFnTypeUses(self) catch {
        return Diagnostics { errors: self.errors };
    };
    try validateGenericDataRoots(self) catch {
        return Diagnostics { errors: self.errors };
    };
    return Diagnostics { errors: self.errors };
}

/// Analyze the module graph. This pass processes `mod` statements, creating symbols
/// and scopes for them, and also binds type names in each module so that cross-module

/// Resolve all type bodies in a module.
fn resolveTypeBodies(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
    for node in block.statements {
        match node.value {
            case ast::NodeValue::RecordDecl(decl) => {
                try resolveRecordBody(self, node, decl) catch {
                    // Continue resolving other types even if one fails.
                };
                if decl.params.len > 0 {
                    try resolveGenericDataTemplate(
                        self, node, decl.params, decl.fields, decl.derives
                    ) catch {};
                } else {
                    try resolveRecordBody(self, node, decl) catch {
                        // Continue resolving other types even if one fails.
                    };
                }
            }
            case ast::NodeValue::UnionDecl(decl) => {
                try resolveUnionBody(self, node, decl) catch {
                    // Continue resolving other types even if one fails.
                };
                if decl.params.len > 0 {
                    try resolveGenericDataTemplate(
                        self, node, decl.params, decl.variants, decl.derives
                    ) catch {};
                } else {
                    try resolveUnionBody(self, node, decl) catch {
                        // Continue resolving other types even if one fails.
                    };
                }
            }
            case ast::NodeValue::TraitDecl { supertraits, methods, .. } => {
                try resolveTraitBody(self, node, supertraits, methods) catch {
                    // Continue resolving other types even if one fails.
                };

        case ast::NodeValue::AddressOf(addr) => return linearRootSymbol(self, addr.target),
        case ast::NodeValue::FieldAccess(access) =>
            return linearRootSymbol(self, access.parent),
        case ast::NodeValue::Subscript { container, .. } =>
            return linearRootSymbol(self, container),
        case ast::NodeValue::GenericApply(_) => return nil,
        case ast::NodeValue::Deref(target) => return linearRootSymbol(self, target),
        else => return nil,
    }
}


                let method = &traitInfo.methods[methodIndex];
                set receiverClass = method.receiverClass;
                set receiverMutable = method.mutable;
                set haveReceiver = true;
            }
            case NodeExtra::GenericBoundMethodCall {
                traitInfo, methodIndex, explicitReceiver, ..
            } => {
                if not explicitReceiver {
                    let method = &traitInfo.methods[methodIndex];
                    set receiverClass = method.receiverClass;
                    set receiverMutable = method.mutable;
                    set haveReceiver = true;
                }
            }
            case NodeExtra::MethodCall { method } => {
                set receiverClass = method.receiverClass;
                set receiverMutable = method.mutable;
                set haveReceiver = true;
            }


    for arg, i in call.args {
        let expected = *info.paramTypes[i];
        let root = linearRootSymbol(checker.resolver, arg);
        let mut argExclusive = isLinear(expected);
        if let case Type::Pointer { class: types::PointerClass::Ref, mutable, .. } = expected {
        if let case Type::Pointer(PointerType { class: types::PointerClass::Ref, mutable, .. }) = expected {
            set argExclusive = mutable;
        } else if let case Type::Slice { class: types::PointerClass::Ref, mutable, .. } = expected {
        } else if let case Type::Slice(SliceType {
            class: types::PointerClass::Ref, mutable, ..
        }) = expected {
            set argExclusive = mutable;
        } else if let case Type::TraitObject {
        } else if let case Type::TraitObject(TraitObjectType {
            class: types::PointerClass::Ref, mutable, ..
        } = expected {
        }) = expected {
            set argExclusive = mutable;
        }
        if not isUnsafePointerType(expected) {
            if let rootSym = root {
                for j in 0..rootsLen {

                    );
                }
                set env.available |= (1 as u64) << (index as u64);
            }
        }

        case ast::NodeValue::Call(call) => try checkLinearCall(checker, env, node, call),
        case ast::NodeValue::AddressOf(addr) => {
            try checkLinearNode(checker, env, addr.target, LinearUse::Borrow);
        }
        case ast::NodeValue::Deref(target) => {

                }
            }
            try checkLinearNode(checker, env, container, LinearUse::Observe);
            try checkLinearNode(checker, env, index, LinearUse::Consume);
        }
        case ast::NodeValue::GenericApply(_) => {
            let extra = checker.resolver.nodeData.entries[node.id].extra;
            if let case NodeExtra::GenericFnCall(_) = extra {
                return;
            }
            if let case NodeExtra::GenericFnDependency(_) = extra {
                return;
            }
            throw emitError(checker.resolver, node, ErrorKind::Internal);
        }
        case ast::NodeValue::RecordLit(lit) => {
            for fieldNode in lit.fields {
                let case ast::NodeValue::RecordLitField(field) = fieldNode.value
                    else panic "checkLinearNode: expected field";
                try checkLinearNode(checker, env, field.value, LinearUse::Consume);

        let pkg = &packages[i];
        let diags = try resolvePackage(self, pkg.rootEntry, pkg.rootAst);
        if not success(&diags) {
            return diags;
        }
        try closeGenericFnSpecializations(self) catch {
            return Diagnostics { errors: self.errors };
        };
        try materializeGenericFnTypeUses(self) catch {
            return Diagnostics { errors: self.errors };
        };
    }
    // Data roots are validated after every package and reachable generic body
    // has had a chance to root its concrete specialization dependencies.
    try validateGenericDataRoots(self) catch {
        return Diagnostics { errors: self.errors };
    };
    return Diagnostics { errors: self.errors };
}

/// Resolve a package.
fn resolvePackage(self: *mut Resolver, rootEntry: *module::ModuleEntry, node: *ast::Node) -> Diagnostics throws (ResolveError) {

        else panic "resolvePackage: module scope not found";

    // Set up the module scope for this package.
    set self.scope = scope;
    set self.currentMod = rootId;
    set self.genericRoots = 0;
    set self.genericSpecializationCount = 0;

    let case ast::NodeValue::Block(block) = node.value
        else panic "resolvePackage: expected block for module root";

    // Module graph analysis phase: bind all module name symbols and scopes.

lib/std/lang/resolver/printer.rad +135 -9

            io::print("i32");
        }
        case super::Type::I64 => {
            io::print("i64");
        }
        case super::Type::Pointer { class, target, mutable } => {
            printPtrPrefix(class, mutable);
            printTypeBody(*target, brief);
        case super::Type::Pointer(pointer) => {
            printPtrPrefix(pointer.class, pointer.mutable);
            printTypeBody(*pointer.target, brief);
        }
        case super::Type::Slice { class, item, mutable } => {
            printPtrPrefix(class, mutable);
        case super::Type::Slice(slice) => {
            printPtrPrefix(slice.class, slice.mutable);
            io::print("[");
            printTypeBody(*item, brief);
            printTypeBody(*slice.item, brief);
            io::print("]");
        }
        case super::Type::Array(array) => {
            io::print("[");
            printTypeBody(*array.item, brief);
            io::print("; ");
            io::printU32(array.length);
            io::print("]");
        }
        case super::Type::GenericArray { item, .. } => {
            io::print("[");
            printTypeBody(*item, brief);
            io::print("; <const>]");
        }
        case super::Type::Optional(inner) => {
            io::print("?");
            printTypeBody(*inner, brief);
        }
        case super::Type::Fn(fnType) => {

                printNominalTypeName(info);
            } else {
                printNominalType(info);
            }
        }
        case super::Type::TraitObject { class, traitInfo, mutable } => {
            printPtrPrefix(class, mutable);
        case super::Type::Parameter(param) => {
            io::print(param.name);
        }
        case super::Type::ConstParameter(param) => {
            io::print(param.name);
        }
        case super::Type::ConstArgument { .. } => {
            io::print("<const>");
        }
        case super::Type::GenericConstExpr { .. } => {
            io::print("<const-expr>");
        }
        case super::Type::GenericRecord(rec) => {
            io::print("{ ");
            for field, i in rec.fields {
                if i > 0 {
                    io::print(", ");
                }
                if let name = field.name {
                    io::print(name);
                    io::print(": ");
                }
                printTypeBody(field.fieldType, brief);
            }
            io::print(" }");
        }
        case super::Type::GenericDataApply(app) => {
            io::print(app.template.name);
            io::print("[");
            for arg, i in app.args {
                if i > 0 {
                    io::print(", ");
                }
                printTypeBody(*arg, brief);
            }
            io::print("]");
        }
        case super::Type::TraitObject(object) => {
            printPtrPrefix(object.class, object.mutable);
            io::print("opaque ");
            io::print(traitInfo.name);
            io::print(object.traitInfo.name);
        }
        case super::Type::Range { start, end } => {
            if let s = start {
                printTypeBody(*s, brief);
            }

            io::print("duplicate instance declaration for the same trait and type");
        }
        case super::ErrorKind::MissingTraitMethod(name) => {
            printQuoted("missing trait method '", name);
        }
        case super::ErrorKind::InheritedTraitMethod(name) => {
            printQuoted("cannot override inherited trait method '", name);
        }
        case super::ErrorKind::UnexpectedTraitName => {
            io::print("trait name cannot be used as a value");
        }
        case super::ErrorKind::TraitReceiverMismatch => {
            io::print("trait method receiver must be a pointer to the declaring trait");
        }
        case super::ErrorKind::TraitNotObjectSafe => {
            io::print("trait methods using `Self` cannot be used through an opaque object");
        }
        case super::ErrorKind::TraitInheritanceCycle => {
            io::print("supertrait declarations cannot form a cycle");
        }
        case super::ErrorKind::InvalidInstanceTarget => {
            io::print("instance target must be a supported concrete type");
        }
        case super::ErrorKind::TraitMethodSafetyMismatch => {
            io::print("trait method implementation has mismatched unsafe requirement");
        }
        case super::ErrorKind::FnParamOverflow(m) =>
            printMismatch("too many function parameters", "maximum", m),

            io::print("`let-else` fallback must terminate control flow");
        }
        case super::ErrorKind::LinearBranchMismatch(name) => {
            printQuoted("linear value has inconsistent branch state: '", name);
        }
        case super::ErrorKind::GenericBoundAmbiguous(name) => {
            printQuoted("generic bounds expose ambiguous method '", name);
        }
        case super::ErrorKind::LinearPartialMove => {
            io::print("cannot move a field out of a linear value");
        }
        case super::ErrorKind::LinearDiscard => {
            io::print("linear value cannot be discarded");

            io::print("unsafe pointer operation requires an unsafe declaration");
        }
        case super::ErrorKind::UnsafeCall => {
            io::print("calling an unsafe function requires an unsafe declaration");
        }
        case super::ErrorKind::GenericUnsupported => {
            io::print("invalid generic declaration or application");
        }
        case super::ErrorKind::GenericBoundNotTrait => {
            io::print("generic parameter bound must name a trait");
        }
        case super::ErrorKind::GenericConstUnsupported => {
            io::print("constant generic parameter type must be an integer");
        }
        case super::ErrorKind::GenericFnAttribute => {
            io::print("attribute is not supported on a generic function");
        }
        case super::ErrorKind::GenericFnNested => {
            io::print("generic functions must be declared at module scope");
        }
        case super::ErrorKind::GenericFnUnusedParameter(name) => {
            io::print("generic parameter `");
            io::print(name);
            io::print("` does not affect the function");
        }
        case super::ErrorKind::GenericFunctionExpected => {
            io::print("expected a generic function");
        }
        case super::ErrorKind::GenericBoundUnsatisfied(name) => {
            io::print("generic type argument does not satisfy bound `");
            io::print(name);
            io::print("`");
        }
        case super::ErrorKind::GenericFunctionInstantiationRequired => {
            io::print("generic function application requires an explicit instantiation");
        }
        case super::ErrorKind::GenericSpecializationChain => {
            io::print("generic specialization dependency depth exceeded");
        }
        case super::ErrorKind::GenericInferenceIncomplete => {
            io::print("cannot infer every generic type argument");
        }
        case super::ErrorKind::GenericInferenceConflict => {
            io::print("generic type argument inference found conflicting types");
        }
        case super::ErrorKind::GenericLayoutRequired => {
            io::print("generic type parameter does not have a concrete layout");
        }
        case super::ErrorKind::GenericRecursiveLayout => {
            io::print("generic specialization has infinitely recursive layout");
        }
        case super::ErrorKind::GenericArgumentsRequired => {
            io::print("generic declaration requires type arguments");
        }
        case super::ErrorKind::GenericInstantiationRequired => {
            io::print("generic data application requires an explicit instantiation");
        }
        case super::ErrorKind::GenericArgumentCount(mismatch) =>
            printMismatch("generic argument count", "expected", mismatch),
        case super::ErrorKind::GenericDataExpected => {
            io::print("expected a generic record or union");
        }
        case super::ErrorKind::GenericConcreteArgumentsRequired => {
            io::print("generic data specialization requires concrete type arguments");
        }
        case super::ErrorKind::GenericParameterLimit => {
            io::print("generic declaration has too many parameters");
        }
        case super::ErrorKind::GenericRootLimit => {
            io::print("package has too many generic instantiation roots");
        }
        case super::ErrorKind::GenericSpecializationLimit => {
            io::print("package has too many generic specializations");
        }
        case super::ErrorKind::Internal => {
            io::print("internal compiler error");
        }
        case super::ErrorKind::RecordFieldOutOfOrder { .. } => {
            io::print("record field out of order");

lib/std/lang/resolver/tests.rad +919 -10

        if let case super::ErrorKind::RecordFieldUnknown(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::GenericBoundAmbiguous(expectedName) = expected {
        if let case super::ErrorKind::GenericBoundAmbiguous(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::ArrayFieldUnknown(expectedName) = expected {
        if let case super::ErrorKind::ArrayFieldUnknown(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;

        if let case super::ErrorKind::MissingTraitMethod(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::InheritedTraitMethod(expectedName) = expected {
        if let case super::ErrorKind::InheritedTraitMethod(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::MissingSupertraitInstance(expectedName) = expected {
        if let case super::ErrorKind::MissingSupertraitInstance(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;


/// Require a slice type and return its element type.
fn expectSliceType(ty: super::Type, mutable: bool) -> super::Type
    throws (testing::TestError)
{
    let case super::Type::Slice { item, mutable: sliceMut, .. } = ty
    let case super::Type::Slice(super::SliceType {
        class: types::PointerClass::Owned, item, mutable: sliceMut
    }) = ty
        else throw testing::TestError::Failed;
    try testing::expect(sliceMut == mutable);

    return *item;
}

/// Require a pointer type and return its target type.
fn expectPointerType(ty: super::Type, mutable: bool) -> super::Type
    throws (testing::TestError)
{
    let case super::Type::Pointer { target, mutable: ptrMut, .. } = ty
    let case super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Owned, target, mutable: ptrMut
    }) = ty
        else throw testing::TestError::Failed;
    try testing::expect(ptrMut == mutable);

    return *target;
}

    // Resolve should succeed: static is public.
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Qualified callable arrays remain subscripts rather than generic applications.
@test fn testResolveQualifiedCallableSubscript() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let rootId = try registerModule(
        &mut MODULE_GRAPH, nil, "root", "export mod values; mod app;", &mut arena
    );
    let _ = try registerModule(
        &mut MODULE_GRAPH,
        rootId,
        "values",
        "fn value() -> i32 { return 23; } export constant ITEMS: [fn() -> i32; 1] = [value];",
        &mut arena,
    );
    let _ = try registerModule(
        &mut MODULE_GRAPH,
        rootId,
        "app",
        "use root::values; fn main() -> i32 { return values::ITEMS[0](); }",
        &mut arena,
    );
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

@test fn testResolveAccessSuper() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let mut arena = ast::nodeArena(&mut AST_ARENA[..]);


    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn f(a: i32) { let o: *opaque = &a; let ptr: *i32 = o; }");
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(mismatch) = err.kind
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { target: expectedTarget, .. } = mismatch.expected
    let case super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Owned, target: expectedTarget, ..
    }) = mismatch.expected
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { target: actualTarget, .. } = mismatch.actual
    let case super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Owned, target: actualTarget, ..
    }) = mismatch.actual
        else throw testing::TestError::Failed;

    try testing::expect(*expectedTarget == super::Type::I32);
    try testing::expect(*actualTarget == super::Type::Opaque);
}

        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
    let case super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Ref, target, mutable
    }) = payloadValType
        else throw testing::TestError::Failed;
    try testing::expect(not mutable);
    try testing::expect(*target == super::Type::I32);
    assert not mutable;
    assert *target == super::Type::I32;
}

/// Test `match &mut opt` produces mutable pointer bindings.
@test fn testResolveMatchMutRefUnionBinding() throws (testing::TestError) {
    let mut a = testResolver();

        else throw testing::TestError::Failed;
    let payloadSym = super::findSymbolInScope(scope, "x")
        else throw testing::TestError::Failed;
    let case super::SymbolData::Value { type: payloadValType, .. } = payloadSym.data
        else throw testing::TestError::Failed;
    let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
    let case super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Ref, target, mutable
    }) = payloadValType
        else throw testing::TestError::Failed;
    try testing::expect(mutable);
    try testing::expect(*target == super::Type::I32);
    assert mutable;
    assert *target == super::Type::I32;
}

/// Non-constant integer widening must use an explicit cast.
@test fn testResolveIntegerWideningRequiresCast() throws (testing::TestError) {
    {

    let mut a = testResolver();
    let program = "record Marker: Linear {} record Value { number: u32 } trait Read { unsafe fn (&Read) get() -> u32; } instance Read for Value { unsafe fn (value: &Value) get() -> u32 { return value.number; } } fn inspect(object: &opaque Read) -> u32 { return object.get(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// Generic declarations retain rigid parameter identities and resolved bounds.
@test fn testGenericTemplateMetadata() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "trait Copy {} record Box⟨T: Copy⟩ { value: T } union Maybe⟨T⟩ { None, Some(T), Code(u32) } fn id⟨T: Copy⟩(value: T) -> T { return value; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;

    let boxSym = super::symbolFor(&a, block.statements[1])
        else throw testing::TestError::Failed;
    let boxTemplate = super::genericTemplateFor(&a, boxSym)
        else throw testing::TestError::Failed;
    assert boxTemplate.params.len == 1;
    assert boxTemplate.params[0].bounds.len == 1;
    assert boxTemplate.members.len == 1;
    let case super::Type::Parameter(boxField) = *boxTemplate.members[0]
        else throw testing::TestError::Failed;
    assert boxField == boxTemplate.params[0];

    let maybeSym = super::symbolFor(&a, block.statements[2])
        else throw testing::TestError::Failed;
    let maybeTemplate = super::genericTemplateFor(&a, maybeSym)
        else throw testing::TestError::Failed;
    assert maybeTemplate.members.len == 3;
    assert *maybeTemplate.members[0] == super::Type::Void;
    let case super::Type::GenericRecord(payload) = *maybeTemplate.members[1]
        else throw testing::TestError::Failed;
    assert payload.fields.len == 1;
    let case super::Type::Parameter(someType) = payload.fields[0].fieldType
        else throw testing::TestError::Failed;
    assert someType == maybeTemplate.params[0];
    let concrete = super::allocType(&mut a, super::Type::U8);
    let args: [*super::Type; 1] = [concrete];
    let sub = super::Substitution { params: maybeTemplate.params, args: &args[..] };
    let codeType = try super::substituteType(
        &mut a, *maybeTemplate.members[2], &sub, block.statements[2]
    ) catch {
        throw testing::TestError::Failed;
    };
    let case super::Type::Nominal(super::NominalType::Record(codeRecord)) = codeType
        else throw testing::TestError::Failed;
    assert codeRecord.layout.size == 4;

    let fnSym = super::symbolFor(&a, block.statements[3])
        else throw testing::TestError::Failed;
    let fnTemplate = super::genericTemplateFor(&a, fnSym)
        else throw testing::TestError::Failed;
    let signature = fnTemplate.signature else throw testing::TestError::Failed;
    let case super::Type::Parameter(argType) = *signature.paramTypes[0]
        else throw testing::TestError::Failed;
    let case super::Type::Parameter(returnType) = *signature.returnType
        else throw testing::TestError::Failed;
    assert argType == fnTemplate.params[0];
    assert returnType == fnTemplate.params[0];
}

/// Symbolic aggregate members retain rigid types through nested wrappers.
@test fn testGenericNestedMemberTypes() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "union Wrapped⟨T⟩ { List([T; 2]), Maybe(?T), Apply(fn(T) -> T) }",
    );
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let sym = super::symbolFor(&a, block.statements[0])
        else throw testing::TestError::Failed;
    let template = super::genericTemplateFor(&a, sym)
        else throw testing::TestError::Failed;
    assert template.members.len == 3;
    for member in template.members {
        assert super::containsGenericParameter(*member);
    }
    let concrete = super::allocType(&mut a, super::Type::U16);
    let args: [*super::Type; 1] = [concrete];
    let sub = super::Substitution { params: template.params, args: &args[..] };
    for member in template.members {
        let specialized = try super::substituteType(
            &mut a, *member, &sub, block.statements[0]
        ) catch {
            throw testing::TestError::Failed;
        };
        let case super::Type::Nominal(super::NominalType::Record(_)) = specialized
            else throw testing::TestError::Failed;
    }
}

/// Generic function signatures preserve rigid types inside compound types.
@test fn testGenericNestedFunctionSignatureTypes() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn transform⟨T⟩(values: [T; 2], callback: fn(T) -> T) -> ?T { return nil; }",
    );
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let sym = super::symbolFor(&a, block.statements[0])
        else throw testing::TestError::Failed;
    let template = super::genericTemplateFor(&a, sym)
        else throw testing::TestError::Failed;
    let signature = template.signature else throw testing::TestError::Failed;
    assert signature.paramTypes.len == 2;
    assert super::containsGenericParameter(*signature.paramTypes[0]);
    assert super::containsGenericParameter(*signature.paramTypes[1]);
    assert super::containsGenericParameter(*signature.returnType);
}

/// Rigid parameters from separate declarations never compare as the same type.
@test fn testGenericParameterIdentityIsDeclarationScoped() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn first⟨T⟩(value: T) -> T { return value; } fn second⟨T⟩(value: T) -> T { return value; }",
    );
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let first = super::symbolFor(&a, block.statements[0])
        else throw testing::TestError::Failed;
    let second = super::symbolFor(&a, block.statements[1])
        else throw testing::TestError::Failed;
    let firstTemplate = super::genericTemplateFor(&a, first)
        else throw testing::TestError::Failed;
    let secondTemplate = super::genericTemplateFor(&a, second)
        else throw testing::TestError::Failed;
    assert firstTemplate.params[0] <> secondTemplate.params[0];
    assert not super::typesEqual(
        super::Type::Parameter(firstTemplate.params[0]),
        super::Type::Parameter(secondTemplate.params[0]),
    );
}

/// Substitution recursively rewrites rigid parameters through composed types.
@test fn testGenericTypeSubstitution() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn id⟨T⟩(value: T) -> T { return value; }");
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let sym = super::symbolFor(&a, block.statements[0])
        else throw testing::TestError::Failed;
    let template = super::genericTemplateFor(&a, sym)
        else throw testing::TestError::Failed;
    let rigid = super::Type::Parameter(template.params[0]);
    let pointer = super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Owned,
        target: super::allocType(&mut a, rigid),
        mutable: true,
    });
    let symbolic = super::Type::Optional(super::allocType(&mut a, pointer));
    let concrete = super::allocType(&mut a, super::Type::U32);
    let args: [*super::Type; 1] = [concrete];
    let sub = super::Substitution { params: template.params, args: &args[..] };
    let replaced = try super::substituteType(
        &mut a, symbolic, &sub, block.statements[0]
    ) catch {
        throw testing::TestError::Failed;
    };
    let case super::Type::Optional(inner) = replaced
        else throw testing::TestError::Failed;
    let case super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Owned, target, mutable
    }) = *inner
        else throw testing::TestError::Failed;
    assert mutable;
    assert *target == super::Type::U32;
}

/// Duplicate generic parameter names are rejected in their declaration scope.
@test fn testDuplicateGenericParameterRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn duplicate⟨T, T⟩(value: T) {}");
    let err = try expectError(&result);
    let case super::ErrorKind::DuplicateBinding(name) = err.kind
        else throw testing::TestError::Failed;
    assert mem::eq(name, "T");
}

/// Generic bounds must resolve to trait declarations.
@test fn testGenericBoundMustBeTrait() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Value {} fn invalid⟨T: Value⟩(value: T) {}",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericBoundNotTrait);
}

/// Integer constant parameters specialize array layouts.
@test fn testGenericConstParameterArrayLayout() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Buffer⟨constant N: u32⟩ { data: [u8; N] } instantiate Buffer⟨4⟩;",
    );
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(applications) = block.statements[1].value
        else throw testing::TestError::Failed;
    let resolved = super::typeFor(&a, applications[0])
        else throw testing::TestError::Failed;
    let case super::Type::Nominal(nominal) = resolved
        else throw testing::TestError::Failed;
    let case super::NominalType::Record(recordType) = *nominal
        else throw testing::TestError::Failed;
    let case super::Type::Array(arrayType) = recordType.fields[0].fieldType
        else throw testing::TestError::Failed;
    assert arrayType.length == 4;
    assert recordType.layout.size == 4;
}

/// Equivalent integer expressions share a canonical specialization.
@test fn testGenericConstParameterCanonical() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Buffer⟨constant N: u32⟩ { data: [u8; N] } instantiate Buffer⟨4⟩; instantiate Buffer⟨2 + 2⟩; instantiate Buffer⟨5⟩;",
    );
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(firstApplications) = block.statements[1].value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(equalApplications) = block.statements[2].value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(otherApplications) = block.statements[3].value
        else throw testing::TestError::Failed;
    let firstType = super::typeFor(&a, firstApplications[0])
        else throw testing::TestError::Failed;
    let equalType = super::typeFor(&a, equalApplications[0])
        else throw testing::TestError::Failed;
    let otherType = super::typeFor(&a, otherApplications[0])
        else throw testing::TestError::Failed;
    let case super::Type::Nominal(first) = firstType
        else throw testing::TestError::Failed;
    let case super::Type::Nominal(equal) = equalType
        else throw testing::TestError::Failed;
    let case super::Type::Nominal(other) = otherType
        else throw testing::TestError::Failed;
    assert first == equal;
    assert first <> other;
}

/// Constant parameter declarations accept only concrete integer types.
@test fn testGenericConstParameterTypeRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "record Buffer⟨constant N: bool⟩ {}");
    try expectErrorKind(&result, super::ErrorKind::GenericConstUnsupported);
}

/// Constant arguments must be side-effect-free compile-time expressions.
@test fn testGenericConstArgumentRequired() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Buffer⟨constant N: u32⟩ { data: [u8; N] } fn size() -> u32 { return 4; } instantiate Buffer⟨size()⟩;",
    );
    try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);
}

/// Constant arguments are checked against their declared integer width.
@test fn testGenericConstArgumentOverflow() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Buffer⟨constant N: u32⟩ { data: [u8; N] } instantiate Buffer⟨4294967296⟩;",
    );
    try expectErrorKind(&result, super::ErrorKind::NumericLiteralOverflow);
}

/// Constant parameters reject type-valued arguments.
@test fn testGenericConstArgumentKindRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Buffer⟨constant N: u32⟩ { data: [u8; N] } instantiate Buffer⟨u32⟩;",
    );
    try expectErrorKind(&result, super::ErrorKind::ConstExprRequired);
}

/// Type parameters reject expression arguments.
@test fn testGenericTypeArgumentKindRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a, "record Box⟨T⟩ { value: T } instantiate Box⟨4⟩;"
    );
    try expectErrorKind(&result, super::ErrorKind::GenericUnsupported);
}

/// Generic declarations reject parameter lists beyond the implementation limit.
@test fn testGenericParameterLimit() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record TooMany⟨A, B, C, D, E, F, G, H, I⟩ {}",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericParameterLimit);
}

/// Rigid parameters cannot escape the declaration that introduces them.
@test fn testGenericParameterOutsideTemplateUnresolved() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn invalid(value: T) {}");
    let err = try expectError(&result);
    let case super::ErrorKind::UnresolvedSymbol(name) = err.kind
        else throw testing::TestError::Failed;
    assert mem::eq(name, "T");
}

/// Layout-dependent builtins reject symbolic generic types.
@test fn testGenericParameterLayoutRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Sized⟨T⟩ { bytes: u32 = @sizeOf(T) }",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericLayoutRequired);
}

/// Generic data declarations cannot be used without specialization arguments.
@test fn testGenericArgumentsRequired() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Box⟨T⟩ { value: T } fn invalid(value: Box) {}",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericArgumentsRequired);
}

/// Repeated concrete data applications share one canonical nominal type.
@test fn testGenericDataSpecializationCanonical() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Pair⟨T, U⟩ { first: T, second: U } union Maybe⟨T⟩ { None, Some(T) } fn roundtrip(value: Pair⟨i32, bool⟩) -> Pair⟨i32, bool⟩ { return value; } instantiate Pair⟨i32, bool⟩; instantiate Pair⟨i32, bool⟩; instantiate Pair⟨bool, i32⟩; instantiate Maybe⟨i32⟩;";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(firstApplications) = block.statements[3].value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(secondApplications) = block.statements[4].value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(reversedApplications) = block.statements[5].value
        else throw testing::TestError::Failed;
    let firstType = super::typeFor(&a, firstApplications[0])
        else throw testing::TestError::Failed;
    let secondType = super::typeFor(&a, secondApplications[0])
        else throw testing::TestError::Failed;
    let reversedType = super::typeFor(&a, reversedApplications[0])
        else throw testing::TestError::Failed;
    let case super::Type::Nominal(first) = firstType
        else throw testing::TestError::Failed;
    let case super::Type::Nominal(second) = secondType
        else throw testing::TestError::Failed;
    let case super::Type::Nominal(reversed) = reversedType
        else throw testing::TestError::Failed;
    assert first == second;
    assert first <> reversed;
    let case super::NominalType::Record(recordType) = *first
        else throw testing::TestError::Failed;
    assert recordType.fields.len == 2;
    assert recordType.layout.size == 8;
    let pairSym = super::symbolFor(&a, block.statements[0])
        else throw testing::TestError::Failed;
    let args: [*super::Type; 2] = [
        super::allocType(&mut a, super::Type::I32),
        super::allocType(&mut a, super::Type::Bool),
    ];
    let cached = super::findGenericDataSpecialization(&a, pairSym, &args[..])
        else throw testing::TestError::Failed;
    assert cached.rooted;
}

/// Recursive applications reuse the in-progress canonical specialization.
@test fn testGenericDataRecursiveSpecialization() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record List⟨T⟩ { value: T, next: ?*List⟨T⟩ } instantiate List⟨i32⟩;",
    );
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(applications) = block.statements[1].value
        else throw testing::TestError::Failed;
    let resolved = super::typeFor(&a, applications[0])
        else throw testing::TestError::Failed;
    let case super::Type::Nominal(listType) = resolved
        else throw testing::TestError::Failed;
    let case super::NominalType::Record(recordType) = *listType
        else throw testing::TestError::Failed;
    let case super::Type::Optional(optionalTarget) = recordType.fields[1].fieldType
        else throw testing::TestError::Failed;
    let case super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Owned, target, ..
    }) = *optionalTarget
        else throw testing::TestError::Failed;
    let case super::Type::Nominal(nextType) = *target
        else throw testing::TestError::Failed;
    assert nextType == listType;
}

/// Generic data applications diagnose arity before specialization.
@test fn testGenericDataSpecializationArity() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Pair⟨T, U⟩ { first: T, second: U } instantiate Pair⟨i32⟩;",
    );
    let err = try expectError(&result);
    let case super::ErrorKind::GenericArgumentCount(mismatch) = err.kind
        else throw testing::TestError::Failed;
    assert mismatch.expected == 2;
    assert mismatch.actual == 1;
}

/// By-value recursive specializations are rejected instead of recursing.
@test fn testGenericDataRecursiveLayoutRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Loop⟨T⟩ { next: Loop⟨T⟩ } instantiate Loop⟨i32⟩;",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericRecursiveLayout);
}

/// Concrete applications outside templates require an explicit root.
@test fn testGenericDataInstantiationRequired() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Box⟨T⟩ { value: T } fn read(value: Box⟨i32⟩) -> i32 { return value.value; }",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericInstantiationRequired);
}

/// Substitution cannot introduce a stored reference into a generic record.
@test fn testGenericRecordReferenceArgumentRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Box⟨T⟩ { value: T } instantiate Box⟨&i32⟩;",
    );
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Substitution cannot introduce a stored reference into a generic union.
@test fn testGenericUnionReferenceArgumentRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "union Maybe⟨T⟩ { None, Some(T) } instantiate Maybe⟨&i32⟩;",
    );
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Roots traverse ordinary nominal containers to reach generic dependencies.
@test fn testGenericDataRootThroughOrdinaryNominal() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Box⟨T⟩ { value: T } record Holder { value: Box⟨i32⟩ } record Root⟨T⟩ { value: T } instantiate Root⟨Holder⟩;",
    );
    try expectNoErrors(&result);
}

/// Function instantiation roots create a concrete specialization.
@test fn testGenericFunctionSpecializationRoot() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn id⟨T⟩(value: T) -> T { return value; } instantiate id⟨i32⟩;",
    );
    try expectNoErrors(&result);
    let node = super::genericFnSpecializations(&a)
        else throw testing::TestError::Failed;
    assert node.args.len == 1;
    assert *node.args[0] == super::Type::I32;
}

/// Grouped instantiation declarations resolve every specialization root.
@test fn testGroupedGenericSpecializationRoots() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Box⟨T⟩ { value: T } fn id⟨T⟩(value: T) -> T { return value; } instantiate Box⟨i32⟩, id⟨i32⟩, id⟨u64⟩;",
    );
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(applications) = block.statements[2].value
        else throw testing::TestError::Failed;
    assert applications.len == 3;
    assert super::typeFor(&a, applications[0]) <> nil;
    let functions = super::genericFnSpecializations(&a)
        else throw testing::TestError::Failed;
    assert functions.next <> nil;
}

/// Generic free-function bodies are checked with their rigid signature.
@test fn testGenericFunctionBodyChecked() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn id⟨T⟩(value: T) -> T { return value; }",
    );
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let sym = super::symbolFor(&a, block.statements[0])
        else throw testing::TestError::Failed;
    let template = super::genericTemplateFor(&a, sym)
        else throw testing::TestError::Failed;
    assert template.bodyResolved;
    assert *template.params[0].used;
}

/// Rigid parameters compose through pointers, optionals, and throws signatures.
@test fn testGenericFunctionCompoundSignature() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "union Fault { Bad } fn pass⟨T⟩(value: *?T) -> *?T throws (Fault) { return value; }",
    );
    try expectNoErrors(&result);
}

/// Concrete-only arithmetic is rejected while checking the template body.
@test fn testGenericFunctionConcreteOperationRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn add⟨T⟩(left: T, right: T) -> T { return left + right; }",
    );
    try expectErrorKind(&result, super::ErrorKind::ExpectedNumeric);
}

/// Type parameters used only by a body annotation still affect the template.
@test fn testGenericFunctionBodyOnlyParameter() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn local⟨T⟩() { let value: ?T = nil; }",
    );
    try expectNoErrors(&result);
}

/// Parameters that affect neither signature nor body are rejected.
@test fn testGenericFunctionUnusedParameterRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn unused⟨T⟩() {}",
    );
    let err = try expectError(&result);
    let case super::ErrorKind::GenericFnUnusedParameter(name) = err.kind
        else throw testing::TestError::Failed;
    assert mem::eq(name, "T");
}

/// Linkage and entry-point attributes are not valid on templates.
@test fn testGenericFunctionAttributeRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn external⟨T⟩(value: T) -> T;",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericFnAttribute);
    let mut b = testResolver();
    let defaultResult = try resolveProgramStr(
        &mut b,
        "@default fn entry⟨T⟩(value: T) -> T { return value; }",
    );
    try expectErrorKind(&defaultResult, super::ErrorKind::GenericFnAttribute);
}

/// Generic functions cannot introduce nested template scopes.
@test fn testNestedGenericFunctionRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn outer() { fn inner⟨T⟩(value: T) -> T { return value; } }",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericFnNested);
}

/// Bound method operations resolve through their declared trait.
@test fn testGenericBoundMethodResolved() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait Copy { fn (&Copy) copy() -> Self; } fn duplicate⟨T: Copy⟩(value: T) -> T { return value.copy(); }",
    );
    try expectNoErrors(&result);
}

/// Unqualified methods shared by multiple bounds are ambiguous.
@test fn testGenericBoundMethodAmbiguous() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait A { fn (&A) run(); } trait B { fn (&B) run(); } fn invoke⟨T: A + B⟩(value: T) { value.run(); }",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericBoundAmbiguous("run"));
}

/// Qualified bound calls disambiguate methods shared by several traits.
@test fn testGenericBoundMethodQualified() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait A { fn (&A) run() -> u32; } trait B { fn (&B) run() -> u32; } fn invoke⟨T: A + B⟩(value: T) -> u32 { return B::run(&value); }",
    );
    try expectNoErrors(&result);
}

/// Qualified bound dispatch enforces unsafe receiver operations.
@test fn testGenericBoundQualifiedUnsafeReceiverRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait Read { fn (*Read) read(); } fn invoke⟨T: Read⟩(value: *unsafe T) { Read::read(value); }",
    );
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// Qualified bound calls accept module-qualified trait paths.
@test fn testGenericBoundQualifiedAcrossModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let rootId = try registerModule(
        &mut MODULE_GRAPH, nil, "root", "export mod defs; mod app;", &mut arena
    );
    let _ = try registerModule(
        &mut MODULE_GRAPH,
        rootId,
        "defs",
        "export trait Read { fn (&Read) read() -> u32; }",
        &mut arena,
    );
    let _ = try registerModule(
        &mut MODULE_GRAPH,
        rootId,
        "app",
        "use root::defs; fn invoke⟨T: defs::Read⟩(value: T) -> u32 { return defs::Read::read(&value); }",
        &mut arena,
    );
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);
}

/// Imported generic roots share their defining module's specialization.
@test fn testGenericSpecializationAcrossModule() throws (testing::TestError) {
    let mut a = testResolver();
    let mut arena = ast::nodeArena(&mut AST_ARENA[..]);
    let rootId = try registerModule(
        &mut MODULE_GRAPH,
        nil,
        "root",
        "export mod base; use base::*; instantiate base::identity⟨u32⟩; instantiate Box⟨u32⟩;",
        &mut arena,
    );
    let baseId = try registerModule(
        &mut MODULE_GRAPH,
        rootId,
        "base",
        "export record Box⟨T⟩ { value: T } export fn identity⟨T⟩(value: T) -> T { return value; } instantiate identity⟨u32⟩; instantiate Box⟨u32⟩;",
        &mut arena,
    );
    let result = try resolveModuleTree(&mut a, rootId);
    try expectNoErrors(&result);

    let node = super::genericFnSpecializations(&a)
        else throw testing::TestError::Failed;
    assert node.next == nil;
    assert node.template.moduleId == baseId;
}

/// Qualified bound dispatch accepts computed receiver expressions.
@test fn testGenericBoundQualifiedExpressionReceiver() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait Read { fn (*Read) read(); } fn borrow⟨T⟩(value: *T) -> *T { return value; } fn invoke⟨T: Read⟩(value: T) { Read::read(borrow(&value)); }",
    );
    try expectNoErrors(&result);
}

/// Calls select a previously rooted concrete specialization.
@test fn testGenericFunctionRootedCall() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn id⟨T⟩(value: T) -> T { return value; } instantiate id⟨i32⟩; fn run() -> i32 { return id⟨i32⟩(7); }",
    );
    try expectNoErrors(&result);
}

/// Calls cannot implicitly create specialization roots.
@test fn testGenericFunctionUnrootedCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn id⟨T⟩(value: T) -> T { return value; } fn run() -> i32 { return id⟨i32⟩(7); }",
    );
    try expectErrorKind(
        &result, super::ErrorKind::GenericFunctionInstantiationRequired
    );
}

/// A rooted template pulls symbolic callees into the specialization closure.
@test fn testGenericFunctionDependencyClosure() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn id⟨T⟩(value: T) -> T { return value; } fn wrap⟨T⟩(value: T) -> T { return id⟨T⟩(value); } instantiate wrap⟨i32⟩;",
    );
    try expectNoErrors(&result);

    let mut count: u32 = 0;
    let mut cursor = super::genericFnSpecializations(&a);
    while let node = cursor {
        set count += 1;
        set cursor = node.next;
    }
    assert count == 2;
}

/// Inference cannot create a specialization without an explicit root.
@test fn testGenericFunctionInferredUnrootedCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn id⟨T⟩(value: T) -> T { return value; } fn run(value: i32) -> i32 { return id(value); }",
    );
    try expectErrorKind(
        &result, super::ErrorKind::GenericFunctionInstantiationRequired
    );
}

/// Exact argument evidence can select an already rooted specialization.
@test fn testGenericFunctionCallInference() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn id⟨T⟩(value: T) -> T { return value; } instantiate id⟨i32⟩; instantiate id⟨i64⟩; fn run(value: i32) -> i32 { id(1); return id(value); }",
    );
    try expectNoErrors(&result);
}

/// Inference requires evidence for every generic parameter.
@test fn testGenericFunctionInferenceIncomplete() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn absent⟨T⟩() -> ?T { return nil; } fn run() { let value = absent(); }",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericInferenceIncomplete);
}

/// An already known result type can complete local inference.
@test fn testGenericFunctionResultInference() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn absent⟨T⟩() -> ?T { return nil; } instantiate absent⟨i32⟩; fn run() { let value: ?i32 = absent(); }",
    );
    try expectNoErrors(&result);
}

/// Multiple arguments cannot infer different types for one parameter.
@test fn testGenericFunctionInferenceConflict() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn first⟨T⟩(left: T, right: T) -> T { return left; } fn run(left: i32, right: u32) { let value = first(left, right); }",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericInferenceConflict);
}

/// Structurally expanding recursion is rejected at the closure bound.
@test fn testGenericFunctionExpandingRecursion() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "fn expand⟨T⟩() { let marker: ?T = nil; expand⟨*T⟩(); } instantiate expand⟨i32⟩;",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericSpecializationChain);
}

/// Trait `Self` is rigid in the declaration and concrete in an instance.
@test fn testTraitSelfSubstitution() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait Select { fn (&Select) select(other: Self) -> Self; } instance Select for u32 { fn (value: &u32) select(other: u32) -> u32 { return other; } }",
    );
    try expectNoErrors(&result);
}

/// Specialized nominal types are valid concrete instance targets.
@test fn testGenericDataInstanceTarget() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Box⟨T⟩ { value: T } instantiate Box⟨u32⟩; trait Read { fn (&Read) read(); } instance Read for Box⟨u32⟩ { fn (value: &Box⟨u32⟩) read() {} }",
    );
    try expectNoErrors(&result);
}

/// `Self` outside a trait declaration has no implicit binding.
@test fn testTraitSelfOutsideTraitRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "fn invalid(value: Self) {}");
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("Self"));
}

/// A trait exposing `Self` cannot be erased behind an opaque object.
@test fn testTraitSelfObjectSafety() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait Clone { fn (&Clone) clone() -> Self; } fn inspect(value: &opaque Clone) {}",
    );
    try expectErrorKind(&result, super::ErrorKind::TraitNotObjectSafe);
}

/// Resolving a nested trait object preserves the enclosing trait's `Self`.
@test fn testTraitSelfNestedTraitResolution() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait Convert { fn (&Convert) convert(reader: &opaque Reader, value: Self) -> Self; } trait Reader { fn (&Reader) read() -> u32; } record Value {} instance Convert for Value { fn (value: &Value) convert(reader: &opaque Reader, other: Value) -> Value { return other; } }",
    );
    try expectNoErrors(&result);
}

/// Cyclic supertraits cannot expose partially constructed method tables.
@test fn testTraitInheritanceCycleRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait First: Second { fn (&First) first(); } trait Second: First { fn (&Second) second(); }",
    );
    try expectErrorKind(&result, super::ErrorKind::TraitInheritanceCycle);
}

/// A subtrait instance inherits implementations from its supertrait instance.
@test fn testInheritedTraitMethodOverrideRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "trait Base { fn (&Base) value() -> u32; } trait Child: Base {} instance Base for u32 { fn (value: &u32) value() -> u32 { return 1; } } instance Child for u32 { fn (value: &u32) value() -> u32 { return 2; } }",
    );
    try expectErrorKind(&result, super::ErrorKind::InheritedTraitMethod("value"));
}

lib/std/lang/scanner/tests.rad +35 -21

use std::testing;

/// String pool for testing.
static TEST_STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// Create a scanner for test source.
fn testScanner(source: *[u8]) -> super::Scanner {
    return super::scanner(super::SourceLoc::File("test.r"), source, &mut TEST_STRING_POOL);
}

@test fn testScanTokens() throws (testing::TestError) {

        try testing::expect(super::next(&mut s).kind == expectedKind);
    }
}

@test fn testScanKeywords() throws (testing::TestError) {
    let mut s = testScanner("nil mod not static unsafe");
    let tok1: super::Token = super::next(&mut s);

    try testing::expect(tok1.kind == super::TokenKind::Nil);
    try testing::expect(tok1.source.len == 3);

    let tok2: super::Token = super::next(&mut s);
    try testing::expect(tok2.kind == super::TokenKind::Mod);
    try testing::expect(tok2.source.len == 3);

    let tok3: super::Token = super::next(&mut s);
    try testing::expect(tok3.kind == super::TokenKind::Not);
    try testing::expect(tok3.source.len == 3);

    let tok4: super::Token = super::next(&mut s);
    try testing::expect(tok4.kind == super::TokenKind::Static);
    try testing::expect(tok4.source.len == 6);

    let tok5: super::Token = super::next(&mut s);
    try testing::expect(tok5.kind == super::TokenKind::Unsafe);
    try testing::expect(tok5.source.len == 6);
    let mut s = testScanner("constant instantiate nil mod not static unsafe");
    let expected: [super::TokenKind; 8] = [
        super::TokenKind::Constant,
        super::TokenKind::Instantiate,
        super::TokenKind::Nil,
        super::TokenKind::Mod,
        super::TokenKind::Not,
        super::TokenKind::Static,
        super::TokenKind::Unsafe,
        super::TokenKind::Eof,
    ];
    for kind in expected {
        assert super::next(&mut s).kind == kind;
    }
}

@test fn testScanVoidAsIdent() throws (testing::TestError) {
    let mut s = testScanner("void");
    let tok: super::Token = super::next(&mut s);

    try testing::expect(super::next(&mut s).kind == super::TokenKind::Ident);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Semicolon);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::RBrace);
    try testing::expect(super::next(&mut s).kind == super::TokenKind::Eof);
}

@test fn testScanGenericDelimiters() throws (testing::TestError) {
    let mut s = testScanner("Pair⟨T⟩");
    assert super::next(&mut s).kind == super::TokenKind::Ident;
    let open = super::next(&mut s);
    assert open.kind == super::TokenKind::LAngle;
    assert mem::eq(open.source, "⟨");
    assert super::next(&mut s).kind == super::TokenKind::Ident;
    let close = super::next(&mut s);
    assert close.kind == super::TokenKind::RAngle;
    assert mem::eq(close.source, "⟩");
    assert super::next(&mut s).kind == super::TokenKind::Eof;
}

@test fn testRejectGenericDelimiterLookalikes() throws (testing::TestError) {
    // U+3008 LEFT ANGLE BRACKET, not U+27E8 MATHEMATICAL LEFT ANGLE BRACKET.
    let source: [u8; 3] = [0xe3, 0x80, 0x88];
    let mut s = testScanner(&source[..]);
    assert super::next(&mut s).kind == super::TokenKind::Invalid;
}

std.lib.test +1 -0

lib/std/lang/alloc/tests.rad
lib/std/lang/parser/tests.rad
lib/std/lang/module/tests.rad
lib/std/lang/scanner/tests.rad
lib/std/lang/resolver/tests.rad
lib/std/lang/lower/tests.rad
lib/std/lang/gen/bitset/tests.rad

test/runner.rad +12 -0

/// Maximum number of data bytes in a `.ras` test binary.
constant ASM_DATA_CAPACITY: u32 = 1024;

// Static storage for large buffers to avoid stack overflow.
// Tests run serially so sharing these is safe.
/// Source input buffer.
static SOURCE_BUF: [u8; SOURCE_BUF_SIZE] = undefined;
/// Expected snapshot buffer.
static EXPECTED_BUF: [u8; EXPECTED_BUF_SIZE] = undefined;
/// Actual output buffer.
static OUTPUT_BUF: [u8; OUTPUT_BUF_SIZE] = undefined;
/// AST arena storage.
static AST_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
/// IL arena storage.
static IL_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
/// Printer arena storage.
static PRINT_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
/// Resolver arena storage.
static RESOLVER_ARENA_STORAGE: [u8; ARENA_SIZE] = undefined;
/// Resolver node metadata storage.
static NODE_DATA_STORAGE: [resolver::NodeData; MAX_NODE_DATA] = undefined;
/// Resolver diagnostic storage.
static ERROR_STORAGE: [resolver::Error; MAX_ERRORS] = undefined;
/// Assembler text storage.
static ASM_TEXT_STORAGE: [u32; ASM_TEXT_CAPACITY] = undefined;
/// Assembler data storage.
static ASM_DATA_STORAGE: [u8; ASM_DATA_CAPACITY] = undefined;

/// Strip a `//` comment from a line, preserving `//` inside quoted strings.
/// Returns the content before the comment, trimmed of trailing whitespace.
fn stripLine(line: *[u8]) -> *[u8] {

    let codeBytes = @sliceOf(code.ptr as *u8, code.len * rv64::INSTR_SIZE as u32);

    return unix::writeFileParts(path, &[headerBytes, codeBytes, roData, rwData]);
}

/// Assemble a source file into an RV64 image.
fn assembleBinary(sourcePath: *[u8], outputPath: *[u8]) -> bool {
    let source = unix::readFile(sourcePath, &mut SOURCE_BUF[..]) else {
        io::printError("error: could not read source: ");
        io::printError(sourcePath);
        io::printError("\n");

test/tests/generic.bound.dispatch.rad added +27 -0

1	+	//! Bounded generic calls dispatch directly to concrete instances.
2	+	//! returns: 4
3	+
4	+	trait Less {
5	+	fn (&Less) less(other: &Self) -> bool;
6	+	}
7	+
8	+	instance Less for u32 {
9	+	fn (value: &u32) less(other: &u32) -> bool {
10	+	return value < other;
11	+	}
12	+	}
13	+
14	+	/// Return the lesser value.
15	+	fn minimum⟨T: Less⟩(a: T, b: T) -> T {
16	+	if a.less(&b) {
17	+	return a;
18	+	}
19	+	return b;
20	+	}
21	+
22	+	instantiate minimum⟨u32⟩;
23	+
24	+	/// Exercise bounded generic dispatch.
25	+	@default fn main() -> i32 {
26	+	return minimum⟨u32⟩(4, 7) as i32;
27	+	}

test/tests/generic.bound.dispatch.ril added +32 -0

1	+	data $"vtable::u32 test::Less" align 8 {
2	+	fn $"u32 test::Less::less";
3	+	}
4	+
5	+	fn w8 $"u32 test::Less::less"(w64 %0, w64 %1) {
6	+	@entry0
7	+	load w32 %2 %0 0;
8	+	load w32 %3 %1 0;
9	+	ult w32 %4 %2 %3;
10	+	ret %4;
11	+	}
12	+
13	+	fn w32 $main() {
14	+	@entry0
15	+	call w32 %0 $"test::minimum⟨u32⟩"(4, 7);
16	+	ret %0;
17	+	}
18	+
19	+	fn w32 $"test::minimum⟨u32⟩"(w32 %0, w32 %1) {
20	+	@entry0
21	+	reserve %2 4 4;
22	+	store w32 %0 %2 0;
23	+	reserve %3 4 4;
24	+	store w32 %1 %3 0;
25	+	call w8 %4 $"u32 test::Less::less"(%2, %3);
26	+	br.ne w32 %4 0 @then1 @merge2;
27	+	@then1
28	+	ret %0;
29	+	@merge2
30	+	load w32 %5 %3 0;
31	+	ret %5;
32	+	}

test/tests/generic.constant.dependency.rad added +18 -0

1	+	//! returns: 0
2	+
3	+	/// Return a constant generic argument.
4	+	fn inner⟨constant N: u32⟩() -> u32 {
5	+	return N;
6	+	}
7	+
8	+	/// Forward a constant generic argument.
9	+	fn outer⟨constant N: u32⟩() -> u32 {
10	+	return inner⟨N⟩();
11	+	}
12	+
13	+	instantiate outer⟨4⟩;
14	+
15	+	/// Exercise constant generic dependencies.
16	+	@default fn main() -> i32 {
17	+	return outer⟨4⟩() as i32 - 4;
18	+	}

test/tests/generic.constant.dependency.ril added +17 -0

1	+	fn w32 $main() {
2	+	@entry0
3	+	call w32 %0 $"test::outer⟨4⟩"();
4	+	sub w32 %1 %0 4;
5	+	ret %1;
6	+	}
7	+
8	+	fn w32 $"test::inner⟨4⟩"() {
9	+	@entry0
10	+	ret 4;
11	+	}
12	+
13	+	fn w32 $"test::outer⟨4⟩"() {
14	+	@entry0
15	+	call w32 %0 $"test::inner⟨4⟩"();
16	+	ret %0;
17	+	}

test/tests/generic.constant.rad added +32 -0

1	+	//! returns: 0
2	+
3	+	/// Inline storage with a generic capacity.
4	+	record InlineVec⟨T, constant N: u32⟩ {
5	+	/// Element storage.
6	+	data: [T; N],
7	+	/// Number of initialized elements.
8	+	len: u32,
9	+	}
10	+
11	+	/// Nested storage with a derived generic capacity.
12	+	record Nested⟨constant N: u32⟩ {
13	+	/// Storage whose capacity is one greater than `N`.
14	+	inner: InlineVec⟨u8, N + 1⟩,
15	+	}
16	+
17	+	/// Return an array's capacity and first element.
18	+	fn capacity⟨constant N: u32⟩(items: [u8; N]) -> u32 {
19	+	return items.len + items[0] as u32;
20	+	}
21	+
22	+	instantiate InlineVec⟨u8, 4⟩;
23	+	instantiate Nested⟨3⟩;
24	+	instantiate capacity⟨4⟩;
25	+
26	+	/// Exercise constant generic records and functions.
27	+	@default fn main() -> i32 {
28	+	let vector = InlineVec⟨u8, 4⟩ { data: [4, 3, 2, 1], len: 4 };
29	+	let nested = Nested⟨3⟩ { inner: vector };
30	+	let result = capacity⟨4⟩(nested.inner.data);
31	+	return result as i32 - 8;
32	+	}

test/tests/generic.constant.ril added +24 -0

1	+	fn w32 $main() {
2	+	@entry0
3	+	reserve %0 8 4;
4	+	reserve %1 4 1;
5	+	store w8 4 %1 0;
6	+	store w8 3 %1 1;
7	+	store w8 2 %1 2;
8	+	store w8 1 %1 3;
9	+	blit %0 %1 4;
10	+	store w32 4 %0 4;
11	+	reserve %2 8 4;
12	+	blit %2 %0 8;
13	+	call w32 %3 $"test::capacity⟨4⟩"(%2);
14	+	sub w32 %4 %3 8;
15	+	ret %4;
16	+	}
17	+
18	+	fn w32 $"test::capacity⟨4⟩"(w64 %0) {
19	+	@entry0
20	+	load w8 %1 %0 0;
21	+	zext w8 %2 %1;
22	+	add w32 %3 4 %2;
23	+	ret %3;
24	+	}

test/tests/generic.constant.union.rad added +16 -0

1	+	//! returns: 0
2	+
3	+	/// Union whose discriminant depends on a constant argument.
4	+	union Code⟨constant N: u32⟩ {
5	+	/// Variant whose discriminant is `N`.
6	+	First = N,
7	+	/// Variant following `First`.
8	+	Second,
9	+	}
10	+
11	+	instantiate Code⟨4⟩;
12	+
13	+	/// Exercise a constant generic union.
14	+	@default fn main() -> i32 {
15	+	return Code⟨4⟩::First as i32 - 4;
16	+	}

test/tests/generic.constant.union.ril added +6 -0

1	+	fn w32 $main() {
2	+	@entry0
3	+	zext w8 %0 4;
4	+	sub w32 %1 %0 4;
5	+	ret %1;
6	+	}

test/tests/generic.function.call.rad added +59 -0

1	+	//! returns: 67
2	+
3	+	/// Two-word aggregate.
4	+	record Pair {
5	+	/// First word.
6	+	first: i32,
7	+	/// Second word.
8	+	second: i32,
9	+	}
10	+
11	+	/// Five-word aggregate.
12	+	record Large {
13	+	/// First word.
14	+	a: i32,
15	+	/// Second word.
16	+	b: i32,
17	+	/// Third word.
18	+	c: i32,
19	+	/// Fourth word.
20	+	d: i32,
21	+	/// Fifth word.
22	+	e: i32,
23	+	}
24	+
25	+	/// Generic value wrapper.
26	+	record Box⟨T⟩ {
27	+	/// Wrapped value.
28	+	value: T,
29	+	}
30	+
31	+	/// Return a value unchanged.
32	+	fn identity⟨T⟩(value: T) -> T { return value; }
33	+
34	+	/// Return a pointer unchanged.
35	+	fn pointer⟨T⟩(value: T) -> T { return value; }
36	+
37	+	/// Pass a value through a generic call.
38	+	fn passt⟨T⟩(value: T) -> T { return value; }
39	+
40	+	instantiate Box⟨i32⟩,
41	+	identity⟨i32⟩,
42	+	pointer⟨i32⟩,
43	+	passt⟨Pair⟩,
44	+	passt⟨Large⟩,
45	+	passt⟨Box⟨i32⟩⟩;
46	+
47	+	/// Exercise generic calls for scalar and aggregate values.
48	+	@default fn main() -> i32 {
49	+	let number: i32 = 11;
50	+	let pair = Pair { first: 5, second: 13 };
51	+	let large = Large { a: 3, b: 5, c: 7, d: 11, e: 19 };
52	+	let boxed = Box⟨i32⟩ { value: 17 };
53	+	let identify = identity⟨i32⟩;
54	+	return identify(7)
55	+	+ passt⟨Pair⟩(pair).second
56	+	+ passt⟨Large⟩(large).e
57	+	+ *pointer⟨i32⟩(&number)
58	+	+ passt⟨Box⟨i32⟩⟩(boxed).value;
59	+	}

test/tests/generic.function.graph.rad added +48 -0

1	+	//! returns: 0
2	+
3	+	/// Return a value unchanged.
4	+	fn identity⟨T⟩(value: T) -> T {
5	+	return value;
6	+	}
7	+
8	+	/// Forward a value through a generic dependency.
9	+	fn wrap⟨T⟩(value: T) -> T {
10	+	return identity⟨T⟩(value);
11	+	}
12	+
13	+	/// Recurse within one generic specialization.
14	+	fn countdown⟨T⟩(value: T, count: i32) -> T {
15	+	if count == 0 {
16	+	return value;
17	+	}
18	+	return countdown⟨T⟩(value, count - 1);
19	+	}
20	+
21	+	/// Enter a mutually recursive generic call graph.
22	+	fn ping⟨T⟩(value: T, count: i32) -> T {
23	+	if count == 0 {
24	+	return value;
25	+	}
26	+	return pong⟨T⟩(value, count - 1);
27	+	}
28	+
29	+	/// Complete a mutually recursive generic call graph.
30	+	fn pong⟨T⟩(value: T, count: i32) -> T {
31	+	if count == 0 {
32	+	return value;
33	+	}
34	+	return ping⟨T⟩(value, count - 1);
35	+	}
36	+
37	+	instantiate wrap⟨i32⟩;
38	+	instantiate countdown⟨i32⟩;
39	+	instantiate ping⟨i32⟩;
40	+
41	+	/// Exercise generic call graph specialization.
42	+	@default fn main() -> i32 {
43	+	let value: i32 = 7;
44	+	assert wrap(value) == 7;
45	+	assert countdown(value, 3) == 7;
46	+	assert ping(value, 4) == 7;
47	+	return 0;
48	+	}

test/tests/generic.function.graph.ril added +63 -0

1	+	fn w32 $main() {
2	+	@entry0
3	+	call w32 %0 $"test::wrap⟨i32⟩"(7);
4	+	br.eq w32 %0 7 @assert.ok2 @assert.fail1;
5	+	@assert.fail1
6	+	unreachable;
7	+	@assert.ok2
8	+	call w32 %1 $"test::countdown⟨i32⟩"(7, 3);
9	+	br.eq w32 %1 7 @assert.ok4 @assert.fail3;
10	+	@assert.fail3
11	+	unreachable;
12	+	@assert.ok4
13	+	call w32 %2 $"test::ping⟨i32⟩"(7, 4);
14	+	br.eq w32 %2 7 @assert.ok6 @assert.fail5;
15	+	@assert.fail5
16	+	unreachable;
17	+	@assert.ok6
18	+	ret 0;
19	+	}
20	+
21	+	fn w32 $"test::identity⟨i32⟩"(w32 %0) {
22	+	@entry0
23	+	ret %0;
24	+	}
25	+
26	+	fn w32 $"test::pong⟨i32⟩"(w32 %0, w32 %1) {
27	+	@entry0
28	+	br.eq w32 %1 0 @then1 @merge2;
29	+	@then1
30	+	ret %0;
31	+	@merge2
32	+	sub w32 %2 %1 1;
33	+	call w32 %3 $"test::ping⟨i32⟩"(%0, %2);
34	+	ret %3;
35	+	}
36	+
37	+	fn w32 $"test::ping⟨i32⟩"(w32 %0, w32 %1) {
38	+	@entry0
39	+	br.eq w32 %1 0 @then1 @merge2;
40	+	@then1
41	+	ret %0;
42	+	@merge2
43	+	sub w32 %2 %1 1;
44	+	call w32 %3 $"test::pong⟨i32⟩"(%0, %2);
45	+	ret %3;
46	+	}
47	+
48	+	fn w32 $"test::countdown⟨i32⟩"(w32 %0, w32 %1) {
49	+	@entry0
50	+	br.eq w32 %1 0 @then1 @merge2;
51	+	@then1
52	+	ret %0;
53	+	@merge2
54	+	sub w32 %2 %1 1;
55	+	call w32 %3 $"test::countdown⟨i32⟩"(%0, %2);
56	+	ret %3;
57	+	}
58	+
59	+	fn w32 $"test::wrap⟨i32⟩"(w32 %0) {
60	+	@entry0
61	+	call w32 %1 $"test::identity⟨i32⟩"(%0);
62	+	ret %1;
63	+	}

test/tests/generic.function.rad added +79 -0

1	+	/// Two-word aggregate used by generic tests.
2	+	record Pair {
3	+	/// First word.
4	+	first: i32,
5	+	/// Second word.
6	+	second: i32,
7	+	}
8	+
9	+	/// Error used by generic throwing functions.
10	+	union Fault {
11	+	/// Generic operation failed.
12	+	Bad,
13	+	}
14	+
15	+	/// Generic value wrapper.
16	+	record Box⟨T⟩ {
17	+	/// Wrapped value.
18	+	value: T,
19	+	}
20	+
21	+	/// Marker trait used by generic trait-object tests.
22	+	trait Marker {}
23	+
24	+	/// Return a value unchanged.
25	+	fn identity⟨T⟩(value: T) -> T {
26	+	return value;
27	+	}
28	+
29	+	/// Return a pointer unchanged.
30	+	fn pointer⟨T⟩(value: T) -> T {
31	+	return value;
32	+	}
33	+
34	+	/// Return an optional value unchanged.
35	+	fn optional⟨T⟩(value: ?T) -> ?T {
36	+	return value;
37	+	}
38	+
39	+	/// Return a value through a throwing generic function.
40	+	fn fallible⟨T⟩(value: T) -> T throws (Fault) {
41	+	return value;
42	+	}
43	+
44	+	/// Lift a value into an optional.
45	+	fn some⟨T⟩(value: T) -> ?T {
46	+	return value;
47	+	}
48	+
49	+	/// Return a generic slice.
50	+	fn reslice⟨T⟩(items: [T]) -> [T] {
51	+	return &items[..];
52	+	}
53	+
54	+	/// Return the last item or a fallback.
55	+	fn last⟨T⟩(items: *[T], fallback: T) -> T {
56	+	let mut result = fallback;
57	+	for item in items {
58	+	set result = item;
59	+	}
60	+	return result;
61	+	}
62	+
63	+	instantiate Box⟨i32⟩;
64	+	instantiate identity⟨i32⟩;
65	+	instantiate identity⟨u64⟩;
66	+	instantiate pointer⟨i32⟩;
67	+	instantiate identity⟨Box⟨i32⟩⟩;
68	+	instantiate identity⟨*opaque Marker⟩;
69	+	instantiate optional⟨i32⟩;
70	+	instantiate optional⟨Pair⟩;
71	+
72	+	instantiate fallible⟨i32⟩;
73	+	instantiate some⟨i32⟩;
74	+	instantiate some⟨Pair⟩;
75	+	instantiate reslice⟨i32⟩;
76	+	instantiate reslice⟨Pair⟩;
77	+	instantiate last⟨i32⟩;
78	+	instantiate last⟨Pair⟩;
79	+	instantiate fallible⟨Pair⟩;

test/tests/generic.function.ril added +137 -0

1	+	fn w64 $"test::fallible⟨test::Pair⟩"(w64 %0, w64 %1) {
2	+	@entry0
3	+	reserve %2 16 8;
4	+	store w64 0 %2 0;
5	+	add w64 %3 %2 8;
6	+	blit %3 %1 8;
7	+	blit %0 %2 16;
8	+	ret %0;
9	+	}
10	+
11	+	fn w64 $"test::last⟨test::Pair⟩"(w64 %0, w64 %1) {
12	+	@entry0
13	+	reserve %2 8 4;
14	+	blit %2 %1 8;
15	+	load w32 %3 %0 8;
16	+	load w64 %4 %0 0;
17	+	jmp @loop1(0, %2);
18	+	@loop1(w32 %5, w64 %8)
19	+	br.slt w32 %5 %3 @body2 @merge3;
20	+	@body2
21	+	mul w64 %6 %5 8;
22	+	add w64 %7 %4 %6;
23	+	blit %8 %7 8;
24	+	add w32 %9 %5 1;
25	+	jmp @loop1(%9, %8);
26	+	@merge3
27	+	load w64 %10 %8 0;
28	+	ret %10;
29	+	}
30	+
31	+	fn w32 $"test::last⟨i32⟩"(w64 %0, w32 %1) {
32	+	@entry0
33	+	load w32 %2 %0 8;
34	+	load w64 %3 %0 0;
35	+	jmp @loop1(0, %1);
36	+	@loop1(w32 %4, w32 %9)
37	+	br.slt w32 %4 %2 @body2 @merge3;
38	+	@body2
39	+	mul w64 %5 %4 4;
40	+	add w64 %6 %3 %5;
41	+	sload w32 %7 %6 0;
42	+	add w32 %8 %4 1;
43	+	jmp @loop1(%8, %7);
44	+	@merge3
45	+	ret %9;
46	+	}
47	+
48	+	fn w64 $"test::reslice⟨test::Pair⟩"(w64 %0, w64 %1) {
49	+	@entry0
50	+	load w64 %2 %1 0;
51	+	load w32 %3 %1 8;
52	+	reserve %4 16 8;
53	+	store w64 %2 %4 0;
54	+	store w32 %3 %4 8;
55	+	store w32 %3 %4 12;
56	+	blit %0 %4 16;
57	+	ret %0;
58	+	}
59	+
60	+	fn w64 $"test::reslice⟨i32⟩"(w64 %0, w64 %1) {
61	+	@entry0
62	+	load w64 %2 %1 0;
63	+	load w32 %3 %1 8;
64	+	reserve %4 16 8;
65	+	store w64 %2 %4 0;
66	+	store w32 %3 %4 8;
67	+	store w32 %3 %4 12;
68	+	blit %0 %4 16;
69	+	ret %0;
70	+	}
71	+
72	+	fn w64 $"test::some⟨test::Pair⟩"(w64 %0, w64 %1) {
73	+	@entry0
74	+	reserve %2 12 4;
75	+	store w8 1 %2 0;
76	+	add w64 %3 %2 4;
77	+	blit %3 %1 8;
78	+	blit %0 %2 12;
79	+	ret %0;
80	+	}
81	+
82	+	fn w64 $"test::some⟨i32⟩"(w64 %0, w32 %1) {
83	+	@entry0
84	+	reserve %2 8 4;
85	+	store w8 1 %2 0;
86	+	store w32 %1 %2 4;
87	+	blit %0 %2 8;
88	+	ret %0;
89	+	}
90	+
91	+	fn w64 $"test::fallible⟨i32⟩"(w64 %0, w32 %1) {
92	+	@entry0
93	+	reserve %2 12 8;
94	+	store w64 0 %2 0;
95	+	store w32 %1 %2 8;
96	+	blit %0 %2 12;
97	+	ret %0;
98	+	}
99	+
100	+	fn w64 $"test::optional⟨test::Pair⟩"(w64 %0, w64 %1) {
101	+	@entry0
102	+	blit %0 %1 12;
103	+	ret %0;
104	+	}
105	+
106	+	fn w64 $"test::optional⟨i32⟩"(w64 %0, w64 %1) {
107	+	@entry0
108	+	blit %0 %1 8;
109	+	ret %0;
110	+	}
111	+
112	+	fn w64 $"test::identity⟨*opaque test::Marker⟩"(w64 %0, w64 %1) {
113	+	@entry0
114	+	blit %0 %1 16;
115	+	ret %0;
116	+	}
117	+
118	+	fn w64 $"test::identity⟨test::Box⟨i32⟩⟩"(w64 %0) {
119	+	@entry0
120	+	load w64 %1 %0 0;
121	+	ret %1;
122	+	}
123	+
124	+	fn w64 $"test::pointer⟨i32⟩"(w64 %0) {
125	+	@entry0
126	+	ret %0;
127	+	}
128	+
129	+	fn w64 $"test::identity⟨u64⟩"(w64 %0) {
130	+	@entry0
131	+	ret %0;
132	+	}
133	+
134	+	fn w32 $"test::identity⟨i32⟩"(w32 %0) {
135	+	@entry0
136	+	ret %0;
137	+	}

test/tests/generic.module.rad added +12 -0

1	+	//! returns: 0
2	+
3	+	mod base;
4	+	use base::*;
5	+
6	+	instantiate base::identity⟨u32⟩;
7	+	instantiate Box⟨u32⟩;
8	+
9	+	@default fn main() -> i32 {
10	+	let boxed = Box⟨u32⟩ { value: identity⟨u32⟩(7) };
11	+	return boxed.value as i32 - 7;
12	+	}

test/tests/generic.module/base.rad added +12 -0

1	+	/// Generic value wrapper exported by the base module.
2	+	export record Box⟨T⟩ {
3	+	/// Wrapped value.
4	+	value: T,
5	+	}
6	+
7	+	/// Return an exported generic value unchanged.
8	+	export fn identity⟨T⟩(value: T) -> T {
9	+	return value;
10	+	}
11	+
12	+	instantiate identity⟨u32⟩;

test/tests/generic.nested.rad added +28 -0

1	+	//! returns: 0
2	+
3	+	/// Generic pair.
4	+	record Pair⟨T, U⟩ {
5	+	/// First value.
6	+	first: T,
7	+	/// Second value.
8	+	second: U,
9	+	}
10	+
11	+	/// Generic value wrapper.
12	+	record Box⟨T⟩ {
13	+	/// Wrapped value.
14	+	value: T,
15	+	}
16	+
17	+	instantiate Box⟨Pair⟨i32, bool⟩⟩;
18	+
19	+	/// Exercise nested generic applications.
20	+	@default fn main() -> i32 {
21	+	let pair: Pair⟨i32, bool⟩ = Pair⟨i32, bool⟩ { first: 42, second: true };
22	+	let mut boxed: Box⟨Pair⟨i32, bool⟩⟩ = Box⟨Pair⟨i32, bool⟩⟩ { value: pair };
23	+	set boxed.value.first = 43;
24	+	if boxed.value.second {
25	+	return boxed.value.first - 43;
26	+	}
27	+	return 1;
28	+	}

test/tests/generic.record.rad added +19 -0

1	+	/// Generic pair.
2	+	record Pair⟨T, U⟩ {
3	+	/// First value.
4	+	first: T,
5	+	/// Second value.
6	+	second: U,
7	+	}
8	+
9	+	instantiate Pair⟨i32, bool⟩;
10	+
11	+	/// Construct a specialized pair.
12	+	fn makePair(first: i32, second: bool) -> Pair⟨i32, bool⟩ {
13	+	return Pair⟨i32, bool⟩ { first, second };
14	+	}
15	+
16	+	/// Return the first value of a specialized pair.
17	+	fn first(pair: Pair⟨i32, bool⟩) -> i32 {
18	+	return pair.first;
19	+	}

test/tests/generic.record.ril added +14 -0

1	+	fn w64 $makePair(w32 %0, w8 %1) {
2	+	@entry0
3	+	reserve %2 8 4;
4	+	store w32 %0 %2 0;
5	+	store w8 %1 %2 4;
6	+	load w64 %3 %2 0;
7	+	ret %3;
8	+	}
9	+
10	+	fn w32 $first(w64 %0) {
11	+	@entry0
12	+	sload w32 %1 %0 0;
13	+	ret %1;
14	+	}

test/tests/generic.recursive.rad added +17 -0

1	+	//! returns: 0
2	+
3	+	/// Recursive generic list node.
4	+	record List⟨T⟩ {
5	+	/// Stored value.
6	+	value: T,
7	+	/// Next list node.
8	+	next: ?*List⟨T⟩,
9	+	}
10	+
11	+	instantiate List⟨i32⟩;
12	+
13	+	/// Exercise recursive generic specialization.
14	+	@default fn main() -> i32 {
15	+	let value: List⟨i32⟩ = List⟨i32⟩ { value: 42, next: nil };
16	+	return value.value - 42;
17	+	}

test/tests/generic.template.rad added +39 -0

1	+	//! returns: 0
2	+	//! Generic function templates are checked but not emitted.
3	+
4	+	/// Error used by a generic template.
5	+	union Fault {
6	+	/// Generic operation failed.
7	+	Bad,
8	+	}
9	+
10	+	/// Generic value wrapper.
11	+	record Box⟨T⟩ {
12	+	/// Wrapped value.
13	+	value: T,
14	+	}
15	+
16	+	/// Return a value unchanged.
17	+	fn identity⟨T⟩(value: T) -> T {
18	+	return value;
19	+	}
20	+
21	+	/// Return a pointer through a throwing generic function.
22	+	fn passPointer⟨T⟩(value: ?T) -> ?T throws (Fault) {
23	+	return value;
24	+	}
25	+
26	+	/// Type-check a generic local declaration.
27	+	fn bodyType⟨T⟩() {
28	+	let empty: ?T = nil;
29	+	}
30	+
31	+	/// Return a nested generic application.
32	+	fn nestedType⟨T⟩(value: Box⟨T⟩) -> Box⟨T⟩ {
33	+	return value;
34	+	}
35	+
36	+	/// Exercise generic template checking.
37	+	@default fn main() -> i32 {
38	+	return 0;
39	+	}

test/tests/generic.trait.cross.module.rad added +13 -0

1	+	//! Inherited trait methods retain their defining module identity.
2	+	//! returns: 0
3	+
4	+	mod base;
5	+	use base::*;
6	+
7	+	trait Child: Base {}
8	+
9	+	instance Child for Item {}
10	+
11	+	@default fn main() -> i32 {
12	+	return 0;
13	+	}

test/tests/generic.trait.cross.module/base.rad added +12 -0

1	+	/// Concrete item exported by the base module.
2	+	export record Item {}
3	+
4	+	export trait Base {
5	+	fn (&Base) value() -> u32;
6	+	}
7	+
8	+	instance Base for Item {
9	+	fn (value: &Item) value() -> u32 {
10	+	return 7;
11	+	}
12	+	}

test/tests/generic.trait.nominal.identity.rad added +25 -0

1	+	//! Qualified nominal types keep distinct instance identities.
2	+	//! returns: 0
3	+
4	+	mod left;
5	+	mod right;
6	+
7	+	trait Inspect {
8	+	fn (&Inspect) inspect() -> u32;
9	+	}
10	+
11	+	instance Inspect for left::Item {
12	+	fn (value: &left::Item) inspect() -> u32 {
13	+	return 1;
14	+	}
15	+	}
16	+
17	+	instance Inspect for right::Item {
18	+	fn (value: &right::Item) inspect() -> u32 {
19	+	return 2;
20	+	}
21	+	}
22	+
23	+	@default fn main() -> i32 {
24	+	return 0;
25	+	}

test/tests/generic.trait.nominal.identity/left.rad added +2 -0

	1	+	/// Item type from the left module.
	2	+	export record Item {}

test/tests/generic.trait.nominal.identity/right.rad added +2 -0

	1	+	/// Item type from the right module.
	2	+	export record Item {}

test/tests/generic.trait.self.rad added +61 -0

1	+	//! returns: 0
2	+
3	+	trait Choose {
4	+	fn (&Choose) choose(other: Self) -> Self;
5	+	}
6	+
7	+	instance Choose for u32 {
8	+	fn (value: &u32) choose(other: u32) -> u32 {
9	+	return other;
10	+	}
11	+	}
12	+
13	+	/// Generic wrapper used by trait instances.
14	+	record Box⟨T⟩ {
15	+	/// Wrapped value.
16	+	value: T,
17	+	}
18	+
19	+	instantiate Box⟨u32⟩;
20	+	instantiate Box⟨u64⟩;
21	+
22	+	trait Inspect {
23	+	fn (&Inspect) inspect() -> u32;
24	+	}
25	+
26	+	instance Inspect for Box⟨u32⟩ {
27	+	fn (value: &Box⟨u32⟩) inspect() -> u32 {
28	+	return value.value;
29	+	}
30	+	}
31	+
32	+	instance Inspect for Box⟨u64⟩ {
33	+	fn (value: &Box⟨u64⟩) inspect() -> u32 {
34	+	return value.value as u32;
35	+	}
36	+	}
37	+
38	+	trait Left {
39	+	fn (&Left) tag() -> u32;
40	+	}
41	+
42	+	trait Right {
43	+	fn (&Right) tag() -> u32;
44	+	}
45	+
46	+	instance Left for u32 {
47	+	fn (value: &u32) tag() -> u32 {
48	+	return *value;
49	+	}
50	+	}
51	+
52	+	instance Right for u32 {
53	+	fn (value: &u32) tag() -> u32 {
54	+	return *value + 1;
55	+	}
56	+	}
57	+
58	+	/// Exercise generic trait identity and `Self`.
59	+	@default fn main() -> i32 {
60	+	return 0;
61	+	}

test/tests/generic.union.rad added +20 -0

1	+	//! returns: 0
2	+
3	+	/// Generic optional value.
4	+	union Maybe⟨T⟩ {
5	+	/// No value.
6	+	None,
7	+	/// Stored value.
8	+	Some(T),
9	+	}
10	+
11	+	instantiate Maybe⟨i32⟩;
12	+
13	+	/// Exercise generic union specialization.
14	+	@default fn main() -> i32 {
15	+	let value: Maybe⟨i32⟩ = Maybe⟨i32⟩::Some(42);
16	+	match value {
17	+	case Maybe⟨i32⟩::Some(inner) => { return inner - 42; }
18	+	case Maybe⟨i32⟩::None => { return 1; }
19	+	}
20	+	}

test/tests/trait.dispatch.ril +5 -5

data $"vtable::Acc::Ops" align 8 {
    fn $"Acc::get";
    fn $"Acc::put";
data $"vtable::test::Acc test::Ops" align 8 {
    fn $"test::Acc test::Ops::get";
    fn $"test::Acc test::Ops::put";
}

fn w32 $"Acc::get"(w64 %0) {
fn w32 $"test::Acc test::Ops::get"(w64 %0) {
  @entry0
    sload w32 %1 %0 0;
    ret %1;
}

fn w64 $"Acc::put"(w64 %0, w32 %1) {
fn w64 $"test::Acc test::Ops::put"(w64 %0, w32 %1) {
  @entry0
    store w32 %1 %0 0;
    ret;
}


test/tests/trait.object.ril +4 -4

data $"vtable::Counter::Adder" align 8 {
    fn $"Counter::add";
data $"vtable::test::Counter test::Adder" align 8 {
    fn $"test::Counter test::Adder::add";
}

fn w32 $"Counter::add"(w64 %0, w32 %1) {
fn w32 $"test::Counter test::Adder::add"(w64 %0, w32 %1) {
  @entry0
    sload w32 %2 %0 0;
    add w32 %3 %2 %1;
    store w32 %3 %0 0;
    sload w32 %4 %0 0;

  @entry0
    reserve %0 4 4;
    store w32 0 %0 0;
    reserve %1 16 8;
    store w64 %0 %1 0;
    store w64 $"vtable::Counter::Adder" %1 8;
    store w64 $"vtable::test::Counter test::Adder" %1 8;
    load w64 %2 %1 0;
    load w64 %3 %1 8;
    load w64 %4 %3 0;
    call w32 %5 %4(%2, 1);
    ret %5;

test/tests/trait.supertrait.ril +12 -12

data $"vtable::Socket::Reader" align 8 {
    fn $"Socket::read";
data $"vtable::test::Socket test::Reader" align 8 {
    fn $"test::Socket test::Reader::read";
}

data $"vtable::Socket::Writer" align 8 {
    fn $"Socket::write";
data $"vtable::test::Socket test::Writer" align 8 {
    fn $"test::Socket test::Writer::write";
}

data $"vtable::Socket::ReadWriter" align 8 {
    fn $"Socket::read";
    fn $"Socket::write";
    fn $"Socket::flush";
data $"vtable::test::Socket test::ReadWriter" align 8 {
    fn $"test::Socket test::Reader::read";
    fn $"test::Socket test::Writer::write";
    fn $"test::Socket test::ReadWriter::flush";
}

data $main$literal$0 align 1 {
    str "abc";
}

fn w32 $"Socket::read"(w64 %0, w64 %1) {
fn w32 $"test::Socket test::Reader::read"(w64 %0, w64 %1) {
  @entry0
    jmp @while1(0, %1, %0);
  @while1(w32 %3, w64 %4, w64 %6)
    load w32 %5 %4 8;
    br.ult w32 %3 %5 @and#then4 @and#else5;

  @guard#trap10
    ebreak;
    unreachable;
}

fn w32 $"Socket::write"(w64 %0, w64 %1) {
fn w32 $"test::Socket test::Writer::write"(w64 %0, w64 %1) {
  @entry0
    jmp @while1(0, %1, %0);
  @while1(w32 %2, w64 %3, w64 %5)
    load w32 %4 %3 8;
    br.ult w32 %2 %4 @body2 @merge3;

  @guard#trap9
    ebreak;
    unreachable;
}

fn w32 $"Socket::flush"(w64 %0) {
fn w32 $"test::Socket test::ReadWriter::flush"(w64 %0) {
  @entry0
    sload w32 %1 %0 72;
    store w32 0 %0 72;
    ret %1;
}

    store w8 108 %3 0;
    add w64 %4 %0 4;
    store w8 111 %4 0;
    reserve %5 16 8;
    store w64 %0 %5 0;
    store w64 $"vtable::Socket::ReadWriter" %5 8;
    store w64 $"vtable::test::Socket test::ReadWriter" %5 8;
    load w64 %6 %5 0;
    load w64 %7 %5 8;
    load w64 %8 %7 8;
    copy %9 $main$literal$0;
    reserve %10 16 8;

494	494
495	495		/// Lower all packages into a single IL program.
496	496		/// Dependencies are lowered first, then the entry package.
497	497		fn lowerAllPackages(
498	498		ctx: *mut CompileContext,
499		-	res: *mut resolver::Resolver
	499	+	res: *resolver::Resolver,
	500	+	arena: *mut alloc::Arena,
500	501		) -> il::Program throws (Error) {
501	502		let entryIdx = ctx.entryPkgIdx else {
502	503		panic "lowerAllPackages: no entry package";
503	504		};
504	505		let entryPkg = &ctx.packages[entryIdx];
505	506
506	507		// Create the lowerer accumulator using entry package's name.
507	508		let options = lower::LowerOptions { debug: ctx.debug, buildTest: ctx.config.buildTest };
508	509		let mut low = lower::lowerer(
509		-	res, &ctx.graph, entryPkg.name, &mut res.arena, &mut res.arena, options
	510	+	res, &ctx.graph, entryPkg.name, arena, arena, options
510	511		);
511		-	try lowerAllPackagesInto(ctx, res, &mut low);
	512	+	try lowerAllPackagesInto(ctx, &mut low);
512	513
513	514		// Finalize and return the unified program.
514	515		return lower::finalize(&low);
515	516		}
516	517
517	518		/// Lower all packages into an existing lowerer.
518	519		fn lowerAllPackagesInto(
519	520		ctx: *mut CompileContext,
520		-	res: *mut resolver::Resolver,
521		-	low: *mut lower::Lowerer
	521	+	low: *mut lower::Lowerer,
522	522		) throws (Error) {
523	523		let entryIdx = ctx.entryPkgIdx else {
524	524		panic "lowerAllPackagesInto: no entry package";
525	525		};
526	526		// Lower all packages except entry.
527	527		for i in 0..ctx.packageCount {
528	528		if i <> entryIdx {
529		-	try lowerPackage(ctx, res, low, &mut ctx.packages[i], false);
	529	+	try lowerPackage(ctx, low, &mut ctx.packages[i], false);
530	530		}
531	531		}
532	532		// Lower entry package.
533		-	try lowerPackage(ctx, res, low, &mut ctx.packages[entryIdx], true);
	533	+	try lowerPackage(ctx, low, &mut ctx.packages[entryIdx], true);
534	534		}
535	535
536	536		/// Lower all modules in a package into the lowerer accumulator.
537	537		fn lowerPackage(
538	538		ctx: *CompileContext,
539		-	res: *mut resolver::Resolver,
540	539		low: *mut lower::Lowerer,
541	540		pkg: *mut package::Package,
542	541		isEntry: bool
543	542		) throws (Error) {
544	543		let rootId = pkg.rootModuleId else {

755	754		let attrNode = ast::synthNode(arena, ast::NodeValue::Attribute(ast::Attribute::Default));
756	755		let attrList = ast::nodeSlice(arena, 1).append(attrNode, a);
757	756		let fnAttrs = ast::Attributes { list: attrList };
758	757
759	758		return ast::synthNode(arena, ast::NodeValue::FnDecl(ast::FnDecl {
760		-	name: fnName, sig: fnSig, body: fnBody, attrs: fnAttrs,
	759	+	name: fnName, params: ast::nodeSlice(arena, 0), sig: fnSig, body: fnBody, attrs: fnAttrs,
761	760		}));
762	761		}
763	762
764	763		/// Append a declaration to a block node's statement list.
765	764		fn injectIntoBlock(

972	971		}
973	972
974	973		/// Lower all packages while streaming each lowered function into RV64 codegen.
975	974		fn lowerAndGenerateAllPackages(
976	975		ctx: *mut CompileContext,
977		-	res: *mut resolver::Resolver,
	976	+	res: *resolver::Resolver,
	977	+	arena: *mut alloc::Arena,
978	978		fnArena: *mut alloc::Arena,
979	979		codegenOptions: CodegenOptions
980	980		) -> rv64::Program throws (Error) {
981	981		let entryIdx = ctx.entryPkgIdx else {
982	982		panic "lowerAndGenerateAllPackages: no entry package";

995	995		}
996	996		else => {}
997	997		}
998	998		let mut generator = rv64::beginProgram(
999	999		rv64::ProgramOptions { entryPatch, debug: codegenOptions.debug },
1000		-	&mut res.arena
	1000	+	arena
1001	1001		);
1002	1002		let mut codegenCtx = CodegenSinkContext {
1003	1003		generator: &mut generator,
1004	1004		fnArena,
1005	1005		};
1006	1006		let mut low = lower::lowerer(
1007		-	res, &ctx.graph, entryPkg.name, &mut res.arena, fnArena, options
	1007	+	res, &ctx.graph, entryPkg.name, arena, fnArena, options
1008	1008		);
1009	1009		set low.output = lower::FnOutput::Stream(lower::FnSink {
1010	1010		ctx: &mut codegenCtx as *mut opaque,
1011	1011		emitFn: generateLoweredFn,
1012	1012		});
1013	1013		let mut asmDataLen: u32 = 0;
1014	1014		if let path = startupPath {
1015		-	try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, &mut res.arena);
	1015	+	try assembleAsmModule(&mut generator, entryPkg, path, &mut asmDataLen, arena);
1016	1016		}
1017		-	try lowerAllPackagesInto(ctx, res, &mut low);
1018		-	let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, &mut res.arena);
	1017	+	try lowerAllPackagesInto(ctx, &mut low);
	1018	+	let asmData = try assembleAsmInputs(ctx, &mut generator, &mut asmDataLen, arena);
1019	1019
1020	1020		match generator.entryPatch {
1021	1021		case rv64::EntryPatch::Reserved(targetName) => {
1022	1022		if targetName == nil {
1023	1023		throw error(&["fatal:", "no default function found"]);

1032	1032		}
1033	1033
1034	1034		/// Lower, optionally dump, and optionally generate binary output.
1035	1035		fn compile(
1036	1036		ctx: *mut CompileContext,
1037		-	res: *mut resolver::Resolver,
1038		-	fnArena: *mut alloc::Arena
	1037	+	res: *resolver::Resolver,
	1038	+	arena: *mut alloc::Arena,
	1039	+	fnArena: *mut alloc::Arena,
1039	1040		) throws (Error) {
1040	1041		let entryPkg = try getEntryPackage(ctx);
1041	1042		let mut out = sexpr::Output::Stdout;
1042	1043
1043	1044		if ctx.dump == Dump::Il {
1044	1045		// Lower all packages into a single unified IL program for dumping.
1045		-	let program = try lowerAllPackages(ctx, res);
1046		-	il::printer::printProgram(&mut out, &mut res.arena, &program);
	1046	+	let program = try lowerAllPackages(ctx, res, arena);
	1047	+	il::printer::printProgram(&mut out, arena, &program);
1047	1048		io::print("\n");
1048	1049		return;
1049	1050		}
1050	1051		if ctx.dump == Dump::Asm {
1051		-	let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {
	1052	+	let result = try lowerAndGenerateAllPackages(ctx, res, arena, fnArena, CodegenOptions {
1052	1053		logPath: nil,
1053	1054		debug: false,
1054	1055		entryMode: CodegenEntryMode::None,
1055	1056		});
1056		-	printer::printCodeTo(&mut out, entryPkg.name, result.code, result.funcs, &mut res.arena);
	1057	+	printer::printCodeTo(&mut out, entryPkg.name, result.code, result.funcs, arena);
1057	1058		io::print("\n");
1058	1059
1059	1060		return;
1060	1061		}
1061	1062		// Generate binary output if path specified.
1062	1063		let outPath = ctx.outputPath else {
1063		-	try lowerAllPackages(ctx, res);
	1064	+	try lowerAllPackages(ctx, res, arena);
1064	1065		return;
1065	1066		};
1066	1067		let startupPath = getEntryStartupPath(ctx);
1067		-	let result = try lowerAndGenerateAllPackages(ctx, res, fnArena, CodegenOptions {
	1068	+	let result = try lowerAndGenerateAllPackages(ctx, res, arena, fnArena, CodegenOptions {
1068	1069		logPath: outPath,
1069	1070		debug: ctx.debug,
1070	1071		entryMode: CodegenEntryMode::None
1071	1072		if startupPath <> nil
1072	1073		else CodegenEntryMode::DefaultEntry,

33	33		/// Maximum number of test functions we can discover.
34	34		constant MAX_TESTS: u32 = 1024;
35	35		/// Maximum number of assembly source paths we can load per package.
36	36		constant MAX_ASM_MODULES: u32 = 64;
37	37
38		-	/// AST arena size (32 MB) - retains parsed nodes throughout compilation.
39		-	constant TEMP_ARENA_SIZE: u32 = 33554432;
	38	+	/// AST arena size (40 MB) - retains parsed nodes throughout compilation.
	39	+	constant TEMP_ARENA_SIZE: u32 = 41943040;
40	40		/// Per-function lowering and register-allocation arena size (16 MB).
41	41		constant FN_ARENA_SIZE: u32 = 16777216;
42	42		/// Main arena size (96 MB) - lives throughout compilation.
43		-	/// Used for: resolver data, types, symbols, global IL data, and codegen output.
	43	+	/// Resolution owns the prefix it consumes; later phases own the remaining slice.
44	44		constant MAIN_ARENA_SIZE: u32 = 100663296;
45	45
46	46		/// AST storage arena.
47	47		static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
48	48		/// Scratch storage reclaimed after each generated function.

1081	1082		throw error(&["fatal:", "failed to write output file"]);
1082	1083		}
1083	1084
1084	1085		// Write debug info file if enabled.
1085	1086		if ctx.debug {
1086		-	try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, &mut res.arena);
	1087	+	try writeDebugInfo(result.debugEntries, &ctx.graph, outPath, arena);
1087	1088		}
1088	1089		pkgLog(entryPkg, &["ok", "(", outPath, ")"]);
1089	1090		}
1090	1091
1091	1092		@default fn main(env: *sys::Env) -> i32 {

1111	1112		try generateTestRunner(&mut ctx, &mut arena) catch {
1112	1113		return 1;
1113	1114		};
1114	1115		}
1115	1116		// Run resolution phase.
1116		-	let mut res = try runResolver(&mut ctx, arena.nextId) catch {
	1117	+	let res = try runResolver(&mut ctx, arena.nextId) catch {
1117	1118		return 1;
1118	1119		};
	1120	+	// Continue from the resolver's final arena cursor through a phase-owned
	1121	+	// copy; lowering and code generation never mutate resolver state.
	1122	+	let mut compileArena = res.arena;
1119	1123		let mut fnArena = alloc::new(&mut FN_ARENA[..]);
1120	1124
1121	1125		// Lower, dump, and/or generate output.
1122		-	try compile(&mut ctx, &mut res, &mut fnArena) catch {
	1126	+	try compile(&mut ctx, &res, &mut compileArena, &mut fnArena) catch {
1123	1127		return 1;
1124	1128		};
1125	1129		return 0;
1126	1130		}

17	17		arena: alloc::Arena,
18	18		/// Next node ID to assign. Incremented on each node allocation.
19	19		nextId: u32,
20	20		}
21	21
	22	+	/// Generic declaration parameter.
	23	+	export union GenericParam {
	24	+	/// Rigid type parameter with optional trait bounds.
	25	+	Type {
	26	+	/// Parameter name.
	27	+	name: *Node,
	28	+	/// Trait bounds in declaration order.
	29	+	bounds: mut [Node],
	30	+	},
	31	+	/// Compile-time constant parameter.
	32	+	Const {
	33	+	/// Parameter name.
	34	+	name: *Node,
	35	+	/// Declared integer type.
	36	+	type: *Node,
	37	+	},
	38	+	}
	39	+
	40	+	/// Application of ordered generic arguments to a declaration or path.
	41	+	export record GenericApply {
	42	+	/// Declaration or path receiving the arguments.
	43	+	target: *Node,
	44	+	/// Arguments in source order.
	45	+	args: mut [Node],
	46	+	}
	47	+
22	48		/// Initialize a node arena backed by the given byte slice.
23	49		export fn nodeArena(data: *mut [u8]) -> NodeArena {
24	50		return NodeArena {
25	51		arena: alloc::new(data),
26	52		nextId: 0,

472	498
473	499		/// Record declaration.
474	500		export record RecordDecl {
475	501		/// Identifier naming the record.
476	502		name: *Node,
	503	+	/// Generic parameters in declaration order.
	504	+	params: mut [Node],
477	505		/// Field declaration nodes.
478	506		fields: mut [Node],
479	507		/// Optional attribute list applied to the record.
480	508		attrs: ?Attributes,
481	509		/// Trait derivations attached to the record.

486	514
487	515		/// Union declarations.
488	516		export record UnionDecl {
489	517		/// Identifier naming the union.
490	518		name: *Node,
	519	+	/// Generic parameters in declaration order.
	520	+	params: mut [Node],
491	521		/// Variant nodes making up the union.
492	522		variants: mut [Node],
493	523		/// Optional attribute list applied to the union.
494	524		attrs: ?Attributes,
495	525		/// Trait derivations attached to the union.

510	540
511	541		/// Function declaration.
512	542		export record FnDecl {
513	543		/// Identifier naming the function.
514	544		name: *Node,
	545	+	/// Generic parameters in declaration order.
	546	+	params: mut [Node],
515	547		/// Function type signature.
516	548		sig: FnSig,
517	549		/// Optional function body (`nil` for extern functions).
518	550		body: ?*Node,
519	551		/// Optional attribute list applied to the function.

617	649		/// Array or slice.
618	650		container: *Node,
619	651		/// Index expression.
620	652		index: *Node
621	653		},
	654	+	/// Generic declaration or function application.
	655	+	GenericApply(GenericApply),
622	656		/// Binary operator expression.
623	657		BinOp(BinOp),
624	658		/// Unary operator expression.
625	659		UnOp(UnOp),
626	660		/// Builtin function call (e.g. `@sizeOf(T)`).

723	757		UnionDeclVariant(UnionDeclVariant),
724	758		/// Attribute node.
725	759		Attribute(Attribute),
726	760		/// Record type declaration.
727	761		RecordDecl(RecordDecl),
	762	+	/// Generic declaration parameter.
	763	+	GenericParam(GenericParam),
	764	+	/// Explicit generic specialization roots declared as one group.
	765	+	Instantiate(mut [Node]),
728	766		/// Record field declaration.
729	767		RecordField {
730	768		/// Identifier bound by the declaration.
731	769		field: ?*Node,
732	770		/// Declared type annotation.

853	891		let params: mut [Node] = &mut [];
854	892		let throwList: mut [Node] = &mut [];
855	893		let fnSig = FnSig { params, returnType: nil, throwList };
856	894		let fnBody = synthNode(arena, NodeValue::Block(Block { statements: bodyStmts }));
857	895		let fnDecl = synthNode(arena, NodeValue::FnDecl(FnDecl {
858		-	name: fnName, sig: fnSig, body: fnBody, attrs: nil,
	896	+	name: fnName, params: &mut [], sig: fnSig, body: fnBody, attrs: nil,
859	897		}));
860	898		let mut rootStmts: mut [Node] = &mut [];
861	899		rootStmts.append(fnDecl, a);
862	900		let modBody = synthNode(arena, NodeValue::Block(Block { statements: rootStmts }));
863	901

1307	1712		}
1308	1713		throw LowerError::MissingConst(node);
1309	1714		};
1310	1715
1311	1716		if let case resolver::ConstValue::String(s) = val {
1312		-	if let case resolver::Type::Slice { .. } = ty {
	1717	+	if let case resolver::Type::Slice(_) = ty {
1313	1718		let strSym = try getOrCreateStringData(self, s, dataPrefix);
1314	1719		dataSliceHeader(b, strSym, s.len);
1315	1720		return;
1316	1721		}
1317	1722		}

293	293		}
294	294		case super::NodeValue::BuiltinCall { kind, args } =>
295	295		return sexpr::list(a, builtinName(kind), nodeListToExprs(a, &args[..])),
296	296		case super::NodeValue::Subscript { container, index } =>
297	297		return sexpr::list(a, "[]", &[toExpr(a, container), toExpr(a, index)]),
	298	+	case super::NodeValue::GenericApply(app) => {
	299	+	let buf = try! sexpr::allocExprs(a, app.args.len as u32 + 1);
	300	+	set buf[0] = toExpr(a, app.target);
	301	+	for arg, i in app.args { set buf[i + 1] = toExpr(a, arg); }
	302	+	return sexpr::Expr::List { head: "apply", tail: buf, multiline: false };
	303	+	}
298	304		case super::NodeValue::FieldAccess(acc) =>
299	305		return sexpr::list(a, ".", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),
300	306		case super::NodeValue::ScopeAccess(acc) =>
301	307		return sexpr::list(a, "::", &[toExpr(a, acc.parent), toExpr(a, acc.child)]),
302	308		case super::NodeValue::AddressOf(addr) =>

448	454		return prongToExpr(a, p);
449	455		}
450	456		case super::NodeValue::FnDecl(f) => {
451	457		let params = sexpr::list(a, "params", nodeListToExprs(a, &f.sig.params[..]));
452	458		let ret = toExprOrNull(a, f.sig.returnType);
	459	+	if f.params.len > 0 {
	460	+	let generics = sexpr::list(a, "generics", nodeListToExprs(a, &f.params[..]));
	461	+	if let body = f.body {
	462	+	return sexpr::block(a, "fn", &[toExpr(a, f.name), generics, params, ret], &[toExpr(a, body)]);
	463	+	}
	464	+	return sexpr::list(a, "fn", &[toExpr(a, f.name), generics, params, ret]);
	465	+	}
453	466		if let body = f.body {
454	467		return sexpr::block(a, "fn", &[toExpr(a, f.name), params, ret], &[toExpr(a, body)]);
455	468		}
456	469		return sexpr::list(a, "fn", &[toExpr(a, f.name), params, ret]);
457	470		}
458	471		case super::NodeValue::Mod(m) => return sexpr::list(a, "mod", &[toExpr(a, m.name)]),
459	472		case super::NodeValue::Use(u_) => return sexpr::list(a, "use", &[toExpr(a, u_.path)]),
460	473		case super::NodeValue::RecordDecl(r) => {
461	474		let children = fieldListToExprs(a, &r.fields[..]);
	475	+	if r.params.len > 0 {
	476	+	let generics = sexpr::list(a, "generics", nodeListToExprs(a, &r.params[..]));
	477	+	return sexpr::block(a, "record", &[toExpr(a, r.name), generics], children);
	478	+	}
462	479		return sexpr::block(a, "record", &[toExpr(a, r.name)], children);
463	480		}
464	481		case super::NodeValue::RecordField { field, type, value } => {
465	482		return fieldToExpr(a, field, type, value);
466	483		}
467	484		case super::NodeValue::UnionDecl(u_) => {
468	485		let children = variantListToExprs(a, &u_.variants[..]);
	486	+	if u_.params.len > 0 {
	487	+	let generics = sexpr::list(a, "generics", nodeListToExprs(a, &u_.params[..]));
	488	+	return sexpr::block(a, "union", &[toExpr(a, u_.name), generics], children);
	489	+	}
469	490		return sexpr::block(a, "union", &[toExpr(a, u_.name)], children);
470	491		}
471	492		case super::NodeValue::UnionDeclVariant(v) => {
472	493		return variantToExpr(a, v.name, v.type);
473	494		}
474	495		case super::NodeValue::ExprStmt(e) => return toExpr(a, e),
	496	+	case super::NodeValue::GenericParam(param) => {
	497	+	match param {
	498	+	case super::GenericParam::Type { name, bounds } => {
	499	+	let boundExpr = sexpr::list(a, "bounds", nodeListToExprs(a, &bounds[..]));
	500	+	return sexpr::list(a, "type-param", &[toExpr(a, name), boundExpr]);
	501	+	}
	502	+	case super::GenericParam::Const { name, type } =>
	503	+	return sexpr::list(a, "const-param", &[toExpr(a, name), toExpr(a, type)]),
	504	+	}
	505	+	}
	506	+	case super::NodeValue::Instantiate(applications) =>
	507	+	return sexpr::list(a, "instantiate", nodeListToExprs(a, &applications[..])),
475	508		case super::NodeValue::TraitDecl { name, supertraits, methods, .. } => {
476	509		let children = nodeListToExprs(a, &methods[..]);
477	510		let supers = sexpr::list(a, "supertraits", nodeListToExprs(a, &supertraits[..]));
478	511		return sexpr::block(a, "trait", &[toExpr(a, name), supers], children);
479	512		}

85	85		//! ↓
86	86		//! il::DataValue
87	87		//! ↓
88	88		//! il::Data
89	89		//!
	90	+	/// Unit tests for lowering.
	91	+	@test mod tests;
	92	+
90	93		use std::fmt;
91	94		use std::io;
92	95		use std::lang::alloc;
93	96		use std::lang::types;
94	97		use std::mem;

163	166		UnknownIntrinsic,
164	167		/// Allocation failure.
165	168		AllocationFailed,
166	169		}
167	170
	171	+	/// Incrementally build deterministic internal symbol names.
	172	+	record NameBuilder {
	173	+	/// Accumulated name bytes.
	174	+	bytes: *mut [u8],
	175	+	/// Allocator used to grow the name.
	176	+	allocator: alloc::Allocator,
	177	+	}
	178	+
168	179		/// Print a LowerError for debugging.
169	180		export fn printError(err: LowerError) {
170	181		match err {
171	182		case LowerError::MissingSymbol(_) => io::print("MissingSymbol"),
172	183		case LowerError::MissingType(_) => io::print("MissingType"),

278	289		Accumulate(mut [il::Fn]),
279	290		/// Send lowered functions to an external consumer immediately.
280	291		Stream(FnSink),
281	292		}
282	293
283		-	/// Module-level lowering context. Shared across all function lowerings.
284		-	/// Holds global state like the data section (strings, constants) and provides
285		-	/// access to the resolver for type queries.
	294	+	/// Module-level lowering context shared across all function lowerings.
	295	+	///
	296	+	/// The resolver is immutable in this phase. Lowering owns its structural type
	297	+	/// substitutions and all emitted IL, data, and symbol-name allocations.
286	298		export record Lowerer {
287	299		/// Arena for persistent lowering state, including data and symbol names.
288	300		arena: *mut alloc::Arena,
289	301		/// Arena for allocations owned by the function currently being lowered.
290	302		fnArena: *mut alloc::Arena,
291		-	/// Allocator backed by the arena.
	303	+	/// Allocator backed by the persistent lowering arena.
292	304		allocator: alloc::Allocator,
293		-	/// Resolver for type information. Used to query types, symbols, and
294		-	/// compile-time constant values during lowering.
	305	+	/// Fully resolved semantic metadata queried without mutation.
295	306		resolver: *resolver::Resolver,
296	307		/// Module graph for cross-module symbol resolution.
297	308		moduleGraph: ?*module::ModuleGraph,
298	309		/// Package name for qualified symbol names.
299	310		pkgName: *[u8],
300	311		/// Current module being lowered.
301	312		currentMod: ?u16,
	313	+	/// Rigid-to-concrete mapping for the function currently being lowered.
	314	+	specialization: ?*resolver::Substitution,
	315	+	/// Concrete generic function whose body is currently being lowered.
	316	+	genericSpecialization: ?*resolver::GenericFnSpecialization,
302	317		/// Global data items (string literals, constants, static arrays).
303	318		/// These become the data sections in the final binary.
304	319		data: *mut [il::Data],
305	320		/// Destination for lowered functions.
306	321		output: FnOutput,
307	322		/// Map of function symbols to qualified names.
308	323		fnSyms: *mut [FnSymEntry],
309		-	/// Global error type tag table. Maps nominal types to unique tags.
	324	+	/// Global error tag table keyed by persistent concrete types.
310	325		errTags: *mut [ErrTagEntry],
311	326		/// Next error tag to assign (starts at 1; 0 = success).
312	327		errTagCounter: u32,
313	328		/// Lowering options.
314	329		options: LowerOptions,

318	333		record FnSymEntry {
319	334		sym: *resolver::Symbol,
320	335		qualName: *[u8],
321	336		}
322	337
	338	+	/// Entry mapping a local data symbol to its qualified lowering-owned name.
	339	+	record DataSymEntry {
	340	+	/// Resolver symbol identifying the declaration.
	341	+	sym: *resolver::Symbol,
	342	+	/// Function-local qualified data name.
	343	+	qualName: *[u8],
	344	+	}
	345	+
323	346		/// Entry in the global error tag table.
324	347		record ErrTagEntry {
325		-	/// The type of this error, identified by its interned pointer.
	348	+	/// Persistent concrete error type.
326	349		ty: resolver::Type,
327	350		/// The globally unique tag assigned to this error type (non-zero).
328	351		tag: u32,
329	352		}
330	353

338	361		}
339	362		}
340	363		return maxSize;
341	364		}
342	365
343		-	/// Get or assign a globally unique error tag for the given error type.
344		-	/// Tag `0` is reserved for success; error tags start at `1`.
345		-	fn getOrAssignErrorTag(self: *mut Lowerer, errType: resolver::Type) -> u32 {
	366	+	/// Allocate one persistent structural type component.
	367	+	fn allocPersistentType(
	368	+	self: *mut Lowerer,
	369	+	ty: resolver::Type,
	370	+	) -> *resolver::Type {
	371	+	let stored = try! alloc::alloc(
	372	+	self.arena,
	373	+	@sizeOf(resolver::Type),
	374	+	@alignOf(resolver::Type),
	375	+	) as *mut resolver::Type;
	376	+	set *stored = ty;
	377	+	return stored;
	378	+	}
	379	+
	380	+	/// Copy a concrete structural type into persistent lowering storage.
	381	+	///
	382	+	/// Nominal pointers retain their canonical identity; only structural
	383	+	/// components that may live in the function arena are copied.
	384	+	fn persistStructuralType(
	385	+	self: *mut Lowerer,
	386	+	ty: resolver::Type,
	387	+	) -> resolver::Type {
	388	+	match ty {
	389	+	case resolver::Type::Pointer(pointer) => {
	390	+	let target = persistStructuralType(self, *pointer.target);
	391	+	return resolver::Type::Pointer(resolver::PointerType {
	392	+	class: pointer.class,
	393	+	target: allocPersistentType(self, target),
	394	+	mutable: pointer.mutable,
	395	+	});
	396	+	}
	397	+	case resolver::Type::Slice(slice) => {
	398	+	let item = persistStructuralType(self, *slice.item);
	399	+	return resolver::Type::Slice(resolver::SliceType {
	400	+	class: slice.class,
	401	+	item: allocPersistentType(self, item),
	402	+	mutable: slice.mutable,
	403	+	});
	404	+	}
	405	+	case resolver::Type::Array(array) => {
	406	+	let item = persistStructuralType(self, *array.item);
	407	+	return resolver::Type::Array(resolver::ArrayType {
	408	+	item: allocPersistentType(self, item),
	409	+	length: array.length,
	410	+	});
	411	+	}
	412	+	case resolver::Type::Optional(inner) => {
	413	+	let stored = persistStructuralType(self, *inner);
	414	+	return resolver::Type::Optional(allocPersistentType(self, stored));
	415	+	}
	416	+	case resolver::Type::Fn(info) => {
	417	+	let mut params: mut [resolver::Type] = &mut [];
	418	+	let mut throwList: mut [resolver::Type] = &mut [];
	419	+	for param in info.paramTypes {
	420	+	let stored = persistStructuralType(self, *param);
	421	+	params.append(allocPersistentType(self, stored), self.allocator);
	422	+	}
	423	+	for thrown in info.throwList {
	424	+	let stored = persistStructuralType(self, *thrown);
	425	+	throwList.append(
	426	+	allocPersistentType(self, stored), self.allocator
	427	+	);
	428	+	}
	429	+	let returnType = persistStructuralType(self, *info.returnType);
	430	+	let storedInfo = try! alloc::alloc(
	431	+	self.arena,
	432	+	@sizeOf(resolver::FnType),
	433	+	@alignOf(resolver::FnType),
	434	+	) as *mut resolver::FnType;
	435	+	set *storedInfo = resolver::FnType {
	436	+	paramTypes: &params[..],
	437	+	returnType: allocPersistentType(self, returnType),
	438	+	throwList: &throwList[..],
	439	+	isUnsafe: info.isUnsafe,
	440	+	localCount: info.localCount,
	441	+	};
	442	+	return resolver::Type::Fn(storedInfo);
	443	+	}
	444	+	case resolver::Type::Range { start, end } => {
	445	+	let mut storedStart: ?*resolver::Type = nil;
	446	+	let mut storedEnd: ?*resolver::Type = nil;
	447	+	if let value = start {
	448	+	let stored = persistStructuralType(self, *value);
	449	+	set storedStart = allocPersistentType(self, stored);
	450	+	}
	451	+	if let value = end {
	452	+	let stored = persistStructuralType(self, *value);
	453	+	set storedEnd = allocPersistentType(self, stored);
	454	+	}
	455	+	return resolver::Type::Range {
	456	+	start: storedStart,
	457	+	end: storedEnd,
	458	+	};
	459	+	}
	460	+	else => return ty,
	461	+	}
	462	+	}
	463	+
	464	+	/// Get or assign a globally unique tag for a concrete error type.
	465	+	fn getOrAssignErrorTag(
	466	+	self: *mut Lowerer,
	467	+	errType: resolver::Type,
	468	+	) -> u32 {
	469	+	assert not resolver::containsGenericParameter(errType);
346	470		for entry in self.errTags {
347		-	if entry.ty == errType {
	471	+	if resolver::typesEqual(entry.ty, errType) {
348	472		return entry.tag;
349	473		}
350	474		}
351	475		let tag = self.errTagCounter;
352		-
353	476		set self.errTagCounter += 1;
354		-	self.errTags.append(ErrTagEntry { ty: errType, tag }, self.allocator);
355		-
	477	+	self.errTags.append(ErrTagEntry {
	478	+	ty: persistStructuralType(self, errType),
	479	+	tag,
	480	+	}, self.allocator);
356	481		return tag;
357	482		}
358	483
359	484		/// Emit one function to the active output.
360	485		fn emitFunction(self: mut Lowerer, func: il::Fn, role: FnRole) {

679	804		allocator: alloc::Allocator,
680	805		/// Type signature of the function being lowered.
681	806		fnType: *resolver::FnType,
682	807		/// Function name, used as prefix for generated data symbols.
683	808		fnName: *[u8],
	809	+	/// Names assigned to data declarations in this function.
	810	+	dataSyms: *mut [DataSymEntry],
684	811
685	812		// ~ SSA variable tracking ~ //
686	813
687	814		/// Metadata (name, type, mutability) for each variable. Indexed by variable
688	815		/// id. Doesn't change after declaration. For the SSA value of a variable in

733	860		// Module Lowering Entry Point //
734	861		/////////////////////////////////
735	862
736	863		/// Lower a complete module AST to an IL program.
737	864		///
738		-	/// This is the main entry point for the lowering pass. It:
739		-	/// 1. Counts functions to preallocate the output array.
740		-	/// 2. Iterates over top-level declarations, lowering each.
741		-	/// 3. Returns the complete IL program with functions and data section.
742		-	///
743		-	/// The resolver must have already processed the AST -- we rely on its type
744		-	/// annotations, symbol table, and constant evaluations.
	865	+	/// The resolver must have completed semantic analysis and generic
	866	+	/// specialization before this phase. Lowering treats all resolver metadata as
	867	+	/// immutable and allocates emitted state exclusively from `arena`.
745	868		export fn lower(
746	869		res: *resolver::Resolver,
747	870		root: *ast::Node,
748	871		pkgName: *[u8],
749	872		arena: *mut alloc::Arena

754	877		allocator: alloc::arenaAllocator(arena),
755	878		resolver: res,
756	879		moduleGraph: nil,
757	880		pkgName,
758	881		currentMod: nil,
	882	+	specialization: nil,
	883	+	genericSpecialization: nil,
759	884		data: &mut [],
760	885		output: FnOutput::Accumulate(&mut []),
761	886		fnSyms: &mut [],
762	887		errTags: &mut [],
763	888		errTagCounter: 1,

770	895
771	896		/////////////////////////////////
772	897		// Multi-Module Lowering API //
773	898		/////////////////////////////////
774	899
775		-	/// Create a lowerer for multi-module compilation.
	900	+	/// Create a multi-module lowerer over fully resolved immutable metadata.
776	901		export fn lowerer(
777	902		res: *resolver::Resolver,
778	903		graph: *module::ModuleGraph,
779	904		pkgName: *[u8],
780	905		arena: *mut alloc::Arena,

787	912		allocator: alloc::arenaAllocator(arena),
788	913		resolver: res,
789	914		moduleGraph: graph,
790	915		pkgName,
791	916		currentMod: nil,
	917	+	specialization: nil,
	918	+	genericSpecialization: nil,
792	919		data: &mut [],
793	920		output: FnOutput::Accumulate(&mut []),
794	921		fnSyms: &mut [],
795	922		errTags: &mut [],
796	923		errTagCounter: 1,

818	945		let stmtsList = block.statements;
819	946
820	947		for node in stmtsList {
821	948		match node.value {
822	949		case ast::NodeValue::FnDecl(decl) => {
	950	+	// Generic declarations are templates, not emitted functions.
	951	+	if decl.params.len > 0 {
	952	+	continue;
	953	+	}
823	954		if let f = try lowerFnDecl(low, node, decl) {
824	955		let role = lowerFnRole(isRoot, decl.attrs);
825	956		emitFunction(low, f, role);
826	957		}
827	958		}
828	959		case ast::NodeValue::ConstDecl(decl) => {
829		-	try lowerDataDecl(low, node, decl.value, true);
	960	+	try lowerDataDecl(low, node, decl.value, true, nil);
830	961		}
831	962		case ast::NodeValue::StaticDecl(decl) => {
832		-	try lowerDataDecl(low, node, decl.value, false);
	963	+	try lowerDataDecl(low, node, decl.value, false, nil);
833	964		}
834	965		case ast::NodeValue::InstanceDecl { traitName, targetType, methods } => {
835	966		try lowerInstanceDecl(low, node, traitName, targetType, methods);
836	967		}
837	968		case ast::NodeValue::MethodDecl { name, receiverName, receiverType, sig, body, .. } => {

840	971		}
841	972		}
842	973		else => {},
843	974		}
844	975		}
	976	+	try lowerGenericFnSpecializations(low);
	977	+	}
	978	+
	979	+	/// Lower explicit generic function roots owned by the current module.
	980	+	fn lowerGenericFnSpecializations(low: *mut Lowerer) throws (LowerError) {
	981	+	let mut cursor = resolver::genericFnSpecializations(low.resolver);
	982	+	while let specialization = cursor {
	983	+	let templateSym = specialization.template;
	984	+	if low.moduleGraph <> nil and templateSym.moduleId <> low.currentMod {
	985	+	set cursor = specialization.next;
	986	+	continue;
	987	+	}
	988	+	let case ast::NodeValue::FnDecl(decl) = templateSym.node.value else {
	989	+	throw LowerError::ExpectedFunction;
	990	+	};
	991	+	if not shouldLowerFn(&decl, low.options.buildTest) {
	992	+	set cursor = specialization.next;
	993	+	continue;
	994	+	}
	995	+	let template = resolver::genericTemplateFor(low.resolver, templateSym)
	996	+	else throw LowerError::MissingMetadata;
	997	+	let sub = resolver::Substitution {
	998	+	params: template.params,
	999	+	args: specialization.args,
	1000	+	};
	1001	+	let symbolicFnType = template.signature
	1002	+	else throw LowerError::MissingMetadata;
	1003	+	let mut concreteFnType = *specialization.fnType;
	1004	+	set concreteFnType.localCount = symbolicFnType.localCount;
	1005	+	set low.genericSpecialization = specialization;
	1006	+	set low.specialization = ⊂
	1007	+	let name = specializationName(low, specialization);
	1008	+	let func = try lowerConcreteFn(
	1009	+	low,
	1010	+	templateSym.node,
	1011	+	decl,
	1012	+	&concreteFnType,
	1013	+	name,
	1014	+	false,
	1015	+	) catch e {
	1016	+	set low.genericSpecialization = nil;
	1017	+	set low.specialization = nil;
	1018	+	throw e;
	1019	+	};
	1020	+	set low.genericSpecialization = nil;
	1021	+	set low.specialization = nil;
	1022	+	emitFunction(low, func, FnRole::Normal);
	1023	+	set cursor = specialization.next;
	1024	+	}
845	1025		}
846	1026
847	1027		/// Finalize lowering and return the unified IL program.
848	1028		export fn finalize(low: *Lowerer) -> il::Program {
849	1029		let mut fns: mut [il::Fn] = undefined;

892	1072		return name;
893	1073		}
894	1074		return il::formatQualifiedName(self.arena, path, name);
895	1075		}
896	1076
	1077	+	/// Append bytes to a symbol name.
	1078	+	fn namePush(builder: mut NameBuilder, text: [u8]) {
	1079	+	for byte in text {
	1080	+	builder.bytes.append(byte, builder.allocator);
	1081	+	}
	1082	+	}
	1083	+
	1084	+	/// Append a decimal `u32` to a symbol name.
	1085	+	fn namePushU32(builder: *mut NameBuilder, value: u32) {
	1086	+	let mut digits: [u8; 10] = undefined;
	1087	+	namePush(builder, fmt::formatU32(value, &mut digits[..]));
	1088	+	}
	1089	+
	1090	+	/// Append a decimal `u64` to a symbol name.
	1091	+	fn namePushU64(builder: *mut NameBuilder, value: u64) {
	1092	+	let mut digits: [u8; 20] = undefined;
	1093	+	namePush(builder, fmt::formatU64(value, &mut digits[..]));
	1094	+	}
	1095	+
	1096	+	/// Append the stable, source-qualified name of a module-level declaration.
	1097	+	fn namePushQualified(
	1098	+	self: *mut Lowerer,
	1099	+	builder: *mut NameBuilder,
	1100	+	modId: ?u16,
	1101	+	name: *[u8],
	1102	+	) {
	1103	+	let path = getModulePath(self, modId);
	1104	+	if path.len == 0 or path[0] <> self.pkgName {
	1105	+	namePush(builder, self.pkgName);
	1106	+	namePush(builder, "::");
	1107	+	}
	1108	+	for segment in path {
	1109	+	namePush(builder, segment);
	1110	+	namePush(builder, "::");
	1111	+	}
	1112	+	namePush(builder, name);
	1113	+	}
	1114	+
	1115	+	/// Append a trait's qualified name.
	1116	+	fn namePushTrait(
	1117	+	self: *mut Lowerer,
	1118	+	builder: *mut NameBuilder,
	1119	+	traitInfo: *resolver::TraitType,
	1120	+	) {
	1121	+	namePushQualified(self, builder, traitInfo.moduleId, traitInfo.name);
	1122	+	}
	1123	+
	1124	+	/// Append a canonical resolved type using Radiance source syntax.
	1125	+	fn namePushType(
	1126	+	self: *mut Lowerer,
	1127	+	builder: *mut NameBuilder,
	1128	+	ty: resolver::Type,
	1129	+	) {
	1130	+	match ty {
	1131	+	case resolver::Type::Void => namePush(builder, "void"),
	1132	+	case resolver::Type::Opaque => namePush(builder, "opaque"),
	1133	+	case resolver::Type::Never => namePush(builder, "!"),
	1134	+	case resolver::Type::Bool => namePush(builder, "bool"),
	1135	+	case resolver::Type::U8 => namePush(builder, "u8"),
	1136	+	case resolver::Type::U16 => namePush(builder, "u16"),
	1137	+	case resolver::Type::U32 => namePush(builder, "u32"),
	1138	+	case resolver::Type::U64 => namePush(builder, "u64"),
	1139	+	case resolver::Type::I8 => namePush(builder, "i8"),
	1140	+	case resolver::Type::I16 => namePush(builder, "i16"),
	1141	+	case resolver::Type::I32 => namePush(builder, "i32"),
	1142	+	case resolver::Type::I64 => namePush(builder, "i64"),
	1143	+	case resolver::Type::Pointer(pointer) => {
	1144	+	match pointer.class {
	1145	+	case types::PointerClass::Owned => namePush(builder, "*"),
	1146	+	case types::PointerClass::Ref => namePush(builder, "&"),
	1147	+	case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
	1148	+	}
	1149	+	if pointer.mutable { namePush(builder, "mut "); }
	1150	+	namePushType(self, builder, *pointer.target);
	1151	+	}
	1152	+	case resolver::Type::Slice(slice) => {
	1153	+	match slice.class {
	1154	+	case types::PointerClass::Owned => namePush(builder, "*"),
	1155	+	case types::PointerClass::Ref => namePush(builder, "&"),
	1156	+	case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
	1157	+	}
	1158	+	if slice.mutable { namePush(builder, "mut "); }
	1159	+	namePush(builder, "[");
	1160	+	namePushType(self, builder, *slice.item);
	1161	+	namePush(builder, "]");
	1162	+	}
	1163	+	case resolver::Type::Array(array) => {
	1164	+	namePush(builder, "[");
	1165	+	namePushType(self, builder, *array.item);
	1166	+	namePush(builder, "; ");
	1167	+	namePushU32(builder, array.length);
	1168	+	namePush(builder, "]");
	1169	+	}
	1170	+	case resolver::Type::ConstArgument { value, .. } => {
	1171	+	if value.negative { namePush(builder, "-"); }
	1172	+	namePushU64(builder, value.magnitude);
	1173	+	}
	1174	+	case resolver::Type::Optional(inner) => {
	1175	+	namePush(builder, "?");
	1176	+	namePushType(self, builder, *inner);
	1177	+	}
	1178	+	case resolver::Type::Fn(info) => {
	1179	+	if info.isUnsafe { namePush(builder, "unsafe "); }
	1180	+	namePush(builder, "fn(");
	1181	+	for param, i in info.paramTypes {
	1182	+	if i > 0 { namePush(builder, ", "); }
	1183	+	namePushType(self, builder, *param);
	1184	+	}
	1185	+	namePush(builder, ") -> ");
	1186	+	namePushType(self, builder, *info.returnType);
	1187	+	if info.throwList.len > 0 {
	1188	+	namePush(builder, " throws ");
	1189	+	for thrown, i in info.throwList {
	1190	+	if i > 0 { namePush(builder, ", "); }
	1191	+	namePushType(self, builder, *thrown);
	1192	+	}
	1193	+	}
	1194	+	}
	1195	+	case resolver::Type::Nominal(nominal) => {
	1196	+	if let data = resolver::genericDataSpecializationForNominal(
	1197	+	self.resolver, nominal
	1198	+	) {
	1199	+	namePushQualified(
	1200	+	self, builder, data.template.moduleId, data.template.name
	1201	+	);
	1202	+	namePush(builder, "⟨");
	1203	+	for arg, i in data.args {
	1204	+	if i > 0 { namePush(builder, ", "); }
	1205	+	namePushType(self, builder, *arg);
	1206	+	}
	1207	+	namePush(builder, "⟩");
	1208	+	return;
	1209	+	}
	1210	+	if let sym = resolver::symbolForNominal(self.resolver, nominal) {
	1211	+	namePushQualified(self, builder, sym.moduleId, sym.name);
	1212	+	return;
	1213	+	}
	1214	+	match *nominal {
	1215	+	case resolver::NominalType::Record(recordType) => {
	1216	+	namePush(builder, "{ ");
	1217	+	for field, i in recordType.fields {
	1218	+	if i > 0 { namePush(builder, ", "); }
	1219	+	if let name = field.name {
	1220	+	namePush(builder, name);
	1221	+	namePush(builder, ": ");
	1222	+	}
	1223	+	namePushType(self, builder, field.fieldType);
	1224	+	}
	1225	+	namePush(builder, " }");
	1226	+	}
	1227	+	case resolver::NominalType::Union(_) =>
	1228	+	panic "namePushType: anonymous union has no source identity",
	1229	+	case resolver::NominalType::Placeholder(_) =>
	1230	+	panic "namePushType: unresolved nominal type",
	1231	+	}
	1232	+	}
	1233	+	case resolver::Type::TraitObject(object) => {
	1234	+	match object.class {
	1235	+	case types::PointerClass::Owned => namePush(builder, "*"),
	1236	+	case types::PointerClass::Ref => namePush(builder, "&"),
	1237	+	case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
	1238	+	}
	1239	+	if object.mutable { namePush(builder, "mut "); }
	1240	+	namePush(builder, "opaque ");
	1241	+	namePushTrait(self, builder, object.traitInfo);
	1242	+	}
	1243	+	else => panic "namePushType: non-concrete type",
	1244	+	}
	1245	+	}
	1246	+
	1247	+	/// Build a readable specialization name from source identity and canonical arguments.
	1248	+	fn specializationName(
	1249	+	self: *mut Lowerer,
	1250	+	specialization: *resolver::GenericFnSpecialization,
	1251	+	) -> *[u8] {
	1252	+	let template = specialization.template;
	1253	+	let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
	1254	+	namePushQualified(self, &mut builder, template.moduleId, template.name);
	1255	+	namePush(&mut builder, "⟨");
	1256	+	for arg, i in specialization.args {
	1257	+	if i > 0 { namePush(&mut builder, ", "); }
	1258	+	namePushType(self, &mut builder, *arg);
	1259	+	}
	1260	+	namePush(&mut builder, "⟩");
	1261	+	return &builder.bytes[..];
	1262	+	}
	1263	+
897	1264		/// Register a function symbol with its qualified name.
898	1265		/// Called when lowering function declarations, so cross-package calls can find
899	1266		/// the function by name.
900	1267		fn registerFnSym(self: mut Lowerer, sym: resolver::Symbol, qualName: *[u8]) {
901	1268		self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);

913	1280		}
914	1281		}
915	1282		return nil;
916	1283		}
917	1284
	1285	+	/// Register a local data symbol with its lowering-owned qualified name.
	1286	+	fn registerDataSym(
	1287	+	self: *mut FnLowerer,
	1288	+	sym: *resolver::Symbol,
	1289	+	qualName: *[u8],
	1290	+	) {
	1291	+	self.dataSyms.append(DataSymEntry { sym, qualName }, self.allocator);
	1292	+	}
	1293	+
	1294	+	/// Look up the current function's most recently registered local data name.
	1295	+	fn lookupDataSym(self: FnLowerer, sym: resolver::Symbol) -> ?*[u8] {
	1296	+	let mut i = self.dataSyms.len;
	1297	+	while i > 0 {
	1298	+	set i -= 1;
	1299	+	let entry = &self.dataSyms[i];
	1300	+	if entry.sym == sym {
	1301	+	return entry.qualName;
	1302	+	}
	1303	+	}
	1304	+	return nil;
	1305	+	}
	1306	+
918	1307		/// Set the package context for lowering.
919	1308		/// Called before lowering each package.
920	1309		export fn setPackage(self: mut Lowerer, graph: module::ModuleGraph, pkgName: *[u8]) {
921	1310		set self.moduleGraph = graph;
922	1311		set self.pkgName = pkgName;

935	1324		let mut fnLow = FnLowerer {
936	1325		low: self,
937	1326		allocator: alloc::arenaAllocator(self.fnArena),
938	1327		fnType: fnType,
939	1328		fnName: qualName,
	1329	+	dataSyms: &mut [],
940	1330		vars: &mut [],
941	1331		params: &mut [],
942	1332		blockData: &mut [],
943	1333		entryBlock: nil,
944	1334		currentBlock: nil,

988	1378
989	1379		// Register function symbol for cross-package call resolution.
990	1380		if let sym = data.sym {
991	1381		registerFnSym(self, sym, qualName);
992	1382		}
993		-	let mut fnLow = fnLowerer(self, node, fnType, qualName);
	1383	+	return try lowerConcreteFn(self, node, decl, fnType, qualName, isExtern);
	1384	+	}
994	1385
995		-	// If the function returns an aggregate or is throwing, prepend a hidden
996		-	// return parameter. The caller allocates the buffer and passes it
997		-	// as the first argument; the callee writes the return value into it.
	1386	+	/// Lower one already-concrete function signature through the shared body path.
	1387	+	fn lowerConcreteFn(
	1388	+	self: *mut Lowerer,
	1389	+	node: *ast::Node,
	1390	+	decl: ast::FnDecl,
	1391	+	fnType: *resolver::FnType,
	1392	+	qualName: *[u8],
	1393	+	isExtern: bool,
	1394	+	) -> *il::Fn throws (LowerError) {
	1395	+	let mut fnLow = fnLowerer(self, node, fnType, qualName);
998	1396		if requiresReturnParam(fnType) and not isExtern {
999	1397		set fnLow.returnReg = nextReg(&mut fnLow);
1000	1398		}
1001	1399		let lowParams = try lowerParams(&mut fnLow, *fnType, decl.sig.params, nil);
1002		-	let func = try! alloc::alloc(self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)) as *mut il::Fn;
1003	1400
	1401	+	let func = try! alloc::alloc(
	1402	+	self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)
	1403	+	) as *mut il::Fn;
1004	1404		set *func = il::Fn {
1005	1405		name: qualName,
1006	1406		params: lowParams,
1007	1407		returnType: undefined,
1008	1408		isExtern,
1009	1409		isLeaf: true,
1010	1410		blocks: &[],
1011	1411		};
1012		-	// Throwing functions return a result aggregate (word-sized pointer).
1013		-	// TODO: The resolver should set an appropriate type that takes into account
1014		-	// the throws list. It shouldn't set the return type to the "success"
1015		-	// value only.
1016	1412		if fnType.throwList.len > 0 {
1017	1413		set func.returnType = il::Type::W64;
1018	1414		} else {
1019	1415		set func.returnType = ilType(self, *fnType.returnType);
1020	1416		}
1021	1417		let body = decl.body else {
1022		-	// Extern functions have no body.
1023	1418		assert isExtern;
1024	1419		return func;
1025	1420		};
1026	1421		set func.blocks = try lowerFnBody(&mut fnLow, body);
1027	1422		set func.isLeaf = fnLow.isLeaf;
1028	1423
1029	1424		return func;
1030	1425		}
1031	1426
1032		-	/// Build a qualified name of the form "Type::method".
1033		-	fn instanceMethodName(self: mut Lowerer, modId: ?u16, typeName: [u8], methodName: [u8]) -> [u8] {
1034		-	let sepLen: u32 = 2; // "::"
1035		-	let totalLen = typeName.len + sepLen + methodName.len;
1036		-	let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
1037		-	let mut pos: u32 = 0;
1038		-
1039		-	set pos += try! mem::copy(&mut buf[pos..], typeName);
1040		-	set pos += try! mem::copy(&mut buf[pos..], "::");
1041		-	set pos += try! mem::copy(&mut buf[pos..], methodName);
1042		-	assert pos == totalLen;
1043		-
1044		-	return qualifyName(self, modId, &buf[..totalLen]);
1045		-	}
1046		-
1047		-	/// Build a v-table data name of the form "vtable::Type::Trait".
1048		-	fn vtableName(self: mut Lowerer, modId: ?u16, typeName: [u8], traitName: [u8]) -> [u8] {
1049		-	let prefix = "vtable::";
1050		-	let sepLen: u32 = 2; // "::"
1051		-	let totalLen = prefix.len + typeName.len + sepLen + traitName.len;
1052		-	let buf = try! alloc::allocSlice(self.arena, 1, 1, totalLen) as *mut [u8];
1053		-	let mut pos: u32 = 0;
1054		-
1055		-	set pos += try! mem::copy(&mut buf[pos..], prefix);
1056		-	set pos += try! mem::copy(&mut buf[pos..], typeName);
1057		-	set pos += try! mem::copy(&mut buf[pos..], "::");
1058		-	set pos += try! mem::copy(&mut buf[pos..], traitName);
1059		-	assert pos == totalLen;
1060		-
1061		-	return qualifyName(self, modId, &buf[..totalLen]);
	1427	+	/// Build a readable method name from its concrete type, trait, and source name.
	1428	+	fn instanceMethodName(
	1429	+	self: *mut Lowerer,
	1430	+	concreteType: resolver::Type,
	1431	+	traitInfo: ?*resolver::TraitType,
	1432	+	methodName: *[u8],
	1433	+	) -> *[u8] {
	1434	+	let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
	1435	+	namePushType(self, &mut builder, concreteType);
	1436	+	if let traitValue = traitInfo {
	1437	+	namePush(&mut builder, " ");
	1438	+	namePushTrait(self, &mut builder, traitValue);
	1439	+	}
	1440	+	namePush(&mut builder, "::");
	1441	+	namePush(&mut builder, methodName);
	1442	+	return &builder.bytes[..];
	1443	+	}
	1444	+
	1445	+	/// Build a readable v-table name from its concrete type and trait.
	1446	+	fn vtableName(
	1447	+	self: *mut Lowerer,
	1448	+	concreteType: resolver::Type,
	1449	+	traitInfo: *resolver::TraitType,
	1450	+	) -> *[u8] {
	1451	+	let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
	1452	+	namePush(&mut builder, "vtable::");
	1453	+	namePushType(self, &mut builder, concreteType);
	1454	+	namePush(&mut builder, " ");
	1455	+	namePushTrait(self, &mut builder, traitInfo);
	1456	+	return &builder.bytes[..];
1062	1457		}
1063	1458
1064	1459		/// Lower an instance declaration (`instance Trait for Type { ... }`).
1065	1460		///
1066	1461		/// Each method in the instance block is lowered as a standalone function
1067		-	/// with a qualified name of the form `Type::method`. A read-only v-table
1068		-	/// data record is emitted containing pointers to these functions, ordered
1069		-	/// by the trait's method indices. The v-table is later referenced when
	1462	+	/// with a qualified name containing both concrete and declaring-trait
	1463	+	/// identities. A read-only v-table data record points to these functions,
	1464	+	/// ordered by the trait's method indices. The v-table is later referenced when
1070	1465		/// constructing trait objects for dynamic dispatch.
1071	1466		fn lowerInstanceDecl(
1072	1467		self: *mut Lowerer,
1073	1468		node: *ast::Node,
1074	1469		traitNameNode: *ast::Node,
1075	1470		targetTypeNode: *ast::Node,
1076	1471		methods: mut [ast::Node]
1077	1472		) throws (LowerError) {
1078		-	// Look up the trait and type from the resolver.
	1473	+	// Look up the trait and concrete instance from resolver metadata.
1079	1474		let traitSym = resolver::nodeData(self.resolver, traitNameNode).sym
1080	1475		else throw LowerError::MissingSymbol(traitNameNode);
1081	1476		let case resolver::SymbolData::Trait(traitInfo) = traitSym.data
1082	1477		else throw LowerError::MissingMetadata;
1083		-	let typeSym = resolver::nodeData(self.resolver, targetTypeNode).sym
1084		-	else throw LowerError::MissingSymbol(targetTypeNode);
1085	1478
1086		-	let tName = traitSym.name;
1087		-	let typeName = typeSym.name;
	1479	+	let concreteType = resolver::typeFor(self.resolver, targetTypeNode)
	1480	+	else throw LowerError::MissingType(targetTypeNode);
	1481	+	let instEntry = resolver::findInstance(self.resolver, traitInfo, concreteType)
	1482	+	else throw LowerError::MissingMetadata;
1088	1483
1089	1484		// Lower each instance method as a regular function.
1090	1485		// Collect qualified names for the v-table. Empty entries are filled
1091	1486		// later from inherited supertrait methods.
1092	1487		let mut methodNames: [*[u8]; ast::MAX_TRAIT_METHODS] = undefined;

1098	1493		} = methodNode.value else continue;
1099	1494
1100	1495		let case ast::NodeValue::Ident(mName) = name.value else {
1101	1496		throw LowerError::ExpectedIdentifier;
1102	1497		};
1103		-	let qualName = instanceMethodName(self, nil, typeName, mName);
	1498	+	let method = resolver::findTraitMethod(traitInfo, mName)
	1499	+	else panic "lowerInstanceDecl: method not found in trait";
	1500	+	let qualName = instanceMethodName(
	1501	+	self, instEntry.concreteType, method.owner, mName
	1502	+	);
1104	1503		let func = try lowerMethod(self, methodNode, qualName, receiverName, sig, body)
1105	1504		else continue;
1106	1505		emitFunction(self, func, FnRole::Normal);
1107	1506
1108		-	let method = resolver::findTraitMethod(traitInfo, mName)
1109		-	else panic "lowerInstanceDecl: method not found in trait";
1110		-
1111	1507		set methodNames[method.index] = qualName;
1112	1508		set methodNameSet[method.index] = true;
1113	1509		}
1114	1510
1115		-	// Fill inherited method slots from supertraits.
1116		-	// These methods were already lowered as part of the supertrait instance
1117		-	// declarations and use the same `Type::method` qualified name.
	1511	+	// Fill inherited method slots from their declaring supertraits. Their
	1512	+	// declaring-trait identity selects the already lowered implementation.
1118	1513		for method, i in traitInfo.methods {
1119	1514		if not methodNameSet[i] {
1120		-	set methodNames[i] = instanceMethodName(self, nil, typeName, method.name);
	1515	+	let inheritedInst = resolver::findInstance(
	1516	+	self.resolver, method.owner, instEntry.concreteType
	1517	+	) else throw LowerError::MissingMetadata;
	1518	+	set methodNames[i] = instanceMethodName(
	1519	+	self,
	1520	+	inheritedInst.concreteType,
	1521	+	method.owner,
	1522	+	method.name,
	1523	+	);
1121	1524		}
1122	1525		}
1123	1526
1124	1527		// Create v-table in data section, used for dynamic dispatch.
1125		-	let vName = vtableName(self, nil, typeName, tName);
	1528	+	let vName = vtableName(self, instEntry.concreteType, traitInfo);
1126	1529		let values = try! alloc::allocSlice(
1127	1530		self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), traitInfo.methods.len as u32
1128	1531		) as *mut [il::DataValue];
1129	1532
1130	1533		for i in 0..traitInfo.methods.len {

1198	1601		else throw LowerError::MissingSymbol(node);
1199	1602		let case ast::NodeValue::Ident(mName) = name.value
1200	1603		else throw LowerError::ExpectedIdentifier;
1201	1604		let me = resolver::findMethodBySymbol(self.resolver, sym)
1202	1605		else throw LowerError::MissingMetadata;
1203		-	let qualName = instanceMethodName(self, nil, me.concreteTypeName, mName);
	1606	+	let qualName = instanceMethodName(
	1607	+	self, me.concreteType, nil, mName
	1608	+	);
1204	1609
1205	1610		return try lowerMethod(self, node, qualName, receiverName, sig, body);
1206	1611		}
1207	1612
1208	1613		/// Check if a function should be lowered.