radiance · commit

lang: Implement explicit generics

2034127ddef8f28a7cfb3265a29fc5b58bccd547dd77ceaf815c9a43f98a8301

Alexis Sellier committed 1 month ago 1 parent df4b837f

compiler/radiance.rad +5 -5

/// 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 (64 MB) - lives throughout compilation.
/// Main arena size (80 MB) - lives throughout compilation.
/// Used for: resolver data, types, symbols, global IL data, and codegen output.
constant MAIN_ARENA_SIZE: u32 = 67108864;
constant MAIN_ARENA_SIZE: u32 = 83886080;

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

    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(

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

    fields: *mut [*Node],
    /// When true, remaining fields are discarded (`{ x, .. }`).
    ignoreRest: bool,
}

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

/// Application of ordered generic arguments to a declaration or path.
export record GenericApply {
    target: *Node,
    args: *mut [*Node],
}

/// 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 +598 -144

    fnArena: *mut alloc::Arena,
    /// Allocator backed by the arena.
    allocator: alloc::Allocator,
    /// Resolver for type information. Used to query types, symbols, and
    /// compile-time constant values during lowering.
    resolver: *resolver::Resolver,
    resolver: *mut 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,

/// 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.
export fn lower(
    res: *resolver::Resolver,
    res: *mut resolver::Resolver,
    root: *ast::Node,
    pkgName: *[u8],
    arena: *mut alloc::Arena
) -> il::Program throws (LowerError) {
    let mut low = Lowerer {

        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.
export fn lowerer(
    res: *resolver::Resolver,
    res: *mut resolver::Resolver,
    graph: *module::ModuleGraph,
    pkgName: *[u8],
    arena: *mut alloc::Arena,
    fnArena: *mut alloc::Arena,
    options: LowerOptions

        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);
                }
            }

                }
            }
            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 node = cursor {
        let specialization = &node.specialization;
        let templateSym = specialization.template;
        if low.moduleGraph <> nil and templateSym.moduleId <> low.currentMod {
            set cursor = node.next;
            continue;
        }
        let case ast::NodeValue::FnDecl(decl) = templateSym.node.value else {
            throw LowerError::ExpectedFunction;
        };
        if not shouldLowerFn(&decl, low.options.buildTest) {
            set cursor = node.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 = node.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);
}

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

/// 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);


    // 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;
        }
    }

    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 {

    let reg = il::Reg { n: self.regCounter };
    set self.regCounter += 1;
    return reg;
}

/// Apply the current function specialization to resolver-owned type metadata.
fn specializeType(
    self: *mut FnLowerer,
    ty: resolver::Type,
    node: *ast::Node,
) -> resolver::Type {
    if let sub = self.low.specialization; resolver::containsGenericParameter(ty) {
        return try resolver::substituteType(
            self.low.resolver, ty, sub, node
        ) catch {
            panic "specializeType: substitution failed after resolution";
        };
    }
    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 specializeType(self, ty, node);
}

/// 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

/// 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);

/// 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 specializeType(self, optTy, node);
        }
    }
    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 = specializeType(self, *info.itemType, container);

    // 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 = specializeType(self, *info.itemType, sliceNode);
    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 = specializeType(self, *info.itemType, container);
    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 = specializeType(self, *valType, node);
            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 = specializeType(self, *elemType, node);
            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 = specializeType(self, *elemType, node);
        return try lowerSliceAppend(self, call, &concrete);
    }
    if let case resolver::NodeExtra::SliceDelete { elemType } = nodeData {
        try lowerSliceDelete(self, call, elemType);
        let concrete = specializeType(self, *elemType, node);
        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 = specializeType(
        self, resolver::Type::Parameter(param), node
    );
    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 = specializeType(self, optType, node);
            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,
                specializeType(self, from, node),
                specializeType(self, to, node),
            );
        }
        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);
        }

             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/parser.rad +152 -13

    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
          not check(p, scanner::TokenKind::Eof)

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 +3257 -418

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;

/// Resolution state for a trait signature table.
export union TraitState {
    Queued,
    Resolving,
    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: *[RecordField],
    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 {
    /// Declaration that owns this template.
    decl: *ast::Node,
    /// 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,
    moduleId: ?u16,
    /// Whether a generic function body has already been checked.
    bodyResolved: bool,
    /// Number of body-analysis entries, retained to enforce check-once behavior.
    bodyChecks: u8,
}

/// 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: *mut bool,
    /// First concrete application site, used for root diagnostics.
    site: *ast::Node,
}

/// Worklist state for a concrete generic function body.
export union GenericFnState {
    Queued,
    Lowering,
    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,
}

/// Linked cache entry for generic function specializations.
export record GenericFnSpecializationNode {
    specialization: GenericFnSpecialization,
    next: ?*mut GenericFnSpecializationNode,
}

/// A generic call retained in a checked symbolic function body.
export record GenericFnDependency {
    caller: ?*mut Symbol,
    callee: *mut Symbol,
    args: *[*Type],
    site: *ast::Node,
    next: ?*GenericFnDependency,
}

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

/// Linked cache entry for generic data specializations.
record GenericDataSpecializationNode {
    specialization: GenericDataSpecialization,
    next: ?*GenericDataSpecializationNode,
}

/// Sparse generic metadata entry, allocated only for template symbols.
record GenericTemplateNode {
    symbol: *mut Symbol,
    template: GenericTemplate,
    next: ?*mut GenericTemplateNode,
}

/// Ordered replacement types for rigid parameters.
export record Substitution {
    params: *[*GenericParamType],
    args: *[*Type],
}

/// Symbolic application of a generic data template inside another template.
export record GenericDataApplyType {
    template: *mut Symbol,
    args: *[*Type],
    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.

    by: MatchBy,
}

/// 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,
    /// 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,
    /// Whether this compilation contains explicitly linear declarations.

    instancesLen: u32,
    /// Standalone method registry.
    methods: [MethodEntry; MAX_METHODS],
    /// Number of registered standalone methods.
    methodsLen: u32,
    /// Sparse metadata for generic declarations.
    genericTemplates: ?*mut GenericTemplateNode,
    /// Canonical generic function specializations.
    genericFnSpecializations: ?*mut GenericFnSpecializationNode,
    /// Symbolic and deferred generic call edges.
    genericFnDependencies: ?*GenericFnDependency,
    /// Concrete resolutions of symbolic generic call edges.
    genericFnDependencyResolutions: ?*GenericFnDependencyResolution,
    /// Package-wide canonical generic data specializations.
    genericDataSpecializations: ?*GenericDataSpecializationNode,
    /// 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,
        currentTraitSelf: nil,
        currentMod: 0,
        unsafeDepth: 0,
        linearEnabled: false,
        config,
        arena,

        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 {

/// 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);
}


}

/// 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(self, lhsClass, rhsClass) {
    if let case Type::Pointer(lhs) = to {
        let case Type::Pointer(rhs) = from else return nil;
        if not pointerClassesAssignable(self, 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(self, lhsClass, rhsClass)
                or (lhsMutable and not rhsMutable)
    if let case Type::TraitObject(lhs) = to {
        if let case Type::Pointer(rhs) = from {
            if not pointerClassesAssignable(self, 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(self, lhsClass, rhsClass)
                or lhsTraitInfo <> rhsTraitInfo
        if let case Type::TraitObject(rhs) = from {
            if not pointerClassesAssignable(self, 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(self, 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(self, 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::Array(aa) => {
            let case Type::Array(ab) = b else return false;
            return aa.length == ab.length and typesEqual(*aa.item, *ab.item);

        }
        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);

            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);

            setNodeSymbol(self, node, sym);

            return ty;
        }
        else => panic "resolveTypeName: unsupported node value",
        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,
    }
}

/// 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);
        }
        else => {
            // Ignore non-declaration nodes.
        }
    }
/// 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,
}

/// Require the current declaration to be unsafe.
fn requireUnsafe(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
    if self.unsafeDepth == 0 {
        throw emitError(self, node, ErrorKind::UnsafeOperation);
/// 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;
        }
        set cursor = entry.parent;
    }
    return false;
}

/// Reject calls from safe code through unsafe function types.
/// 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::Nominal(nominal) => {
            let mut cursor = self.genericDataSpecializations;
            while let node = cursor {
                let specialization = &node.specialization;
                if specialization.nominal == nominal {
                    if not *specialization.rooted {
                        set *specialization.rooted = true;
                        return true;
                    }
                    return false;
                }
                set cursor = node.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 node = cursor {
            let specialization = &node.specialization;
            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 = node.next;
        }
        if not changed {
            break;
        }
    }
    let mut cursor = self.genericDataSpecializations;
    while let node = cursor {
        let specialization = &node.specialization;
        if not *specialization.rooted {
            throw emitError(
                self, specialization.site, ErrorKind::GenericInstantiationRequired
            );
        }
        set cursor = node.next;
    }
}

/// Look up a cached specialization by template and ordered arguments.
export fn findGenericDataSpecialization(
    self: *Resolver,
    template: *Symbol,
    args: *[*Type],
) -> ?*GenericDataSpecialization {
    let mut cursor = self.genericDataSpecializations;
    while let node = cursor {
        let entry = &node.specialization;
        if entry.template == template and entry.args.len == args.len {
            let mut equal = true;
            for arg, i in args {
                if not typesEqual(*entry.args[i], *arg) {
                    set equal = false;
                    break;
                }
            }
            if equal {
                return entry;
            }
        }
        set cursor = node.next;
    }
    return nil;
}

/// 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 node = cursor {
        if node.specialization.nominal == nominal {
            return &node.specialization;
        }
        set cursor = node.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, true
            ) 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, false
            ) 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 a concrete record specialization from substituted member types.
fn specializeGenericRecord(
    self: *mut Resolver,
    template: *GenericTemplate,
    decl: ast::RecordDecl,
    sub: *Substitution,
) -> RecordType throws (ResolveError) {
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut fields: *mut [RecordField] = &mut [];
    let mut offset: u32 = 0;
    let mut alignment: u32 = 1;
    for member, i in decl.fields {
        let case ast::NodeValue::RecordField { field, type, .. } = member.value
            else throw emitError(self, member, ErrorKind::Internal);
        let concrete = try substituteType(self, *template.members[i], sub, type);
        if hasUnresolvedNominalLayout(concrete) {
            throw emitError(self, type, ErrorKind::GenericRecursiveLayout);
        }
        try ensureStorableType(self, type, concrete);
        try ensureTypeResolved(self, concrete, type);
        let layout = getTypeLayout(concrete);
        set offset = mem::alignUp(offset, layout.alignment);
        let mut name: ?*[u8] = nil;
        if decl.labeled {
            let nameNode = field else throw emitError(self, member, ErrorKind::Internal);
            set name = try nodeName(self, nameNode);
        }
        fields.append(RecordField {
            name,
            fieldType: concrete,
            offset: offset as i32,
        }, a);
        set offset += layout.size;
        set alignment = max(alignment, layout.alignment);
    }
    return RecordType {
        fields: &fields[..],
        labeled: decl.labeled,
        layout: Layout {
            size: mem::alignUp(offset, alignment),
            alignment,
        },
        declaredLinear: template.declaredLinear,
    };
}

/// Build a concrete union specialization from substituted variant types.
fn specializeGenericUnion(
    self: *mut Resolver,
    templateSym: *mut Symbol,
    template: *GenericTemplate,
    decl: ast::UnionDecl,
    sub: *Substitution,
) -> UnionType throws (ResolveError) {
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut variants: *mut [UnionVariant] = &mut [];
    let mut iota: u32 = 0;
    for variantNode, i in decl.variants {
        let case ast::NodeValue::UnionDeclVariant(variantDecl) = variantNode.value
            else throw emitError(self, variantNode, ErrorKind::Internal);
        let valueType = try substituteType(
            self, *template.members[i], sub, 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, sub);
        let symbol = allocSymbol(
            self,
            SymbolData::Variant {
                type: valueType,
                decl: template.decl,
                ordinal: i,
                index: tag,
            },
            name,
            variantNode,
            0,
        );
        set symbol.moduleId = templateSym.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: template.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 = findGenericDataSpecialization(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 [];
    let rootedFlag = try! alloc::alloc(
        &mut self.arena, @sizeOf(bool), @alignOf(bool)
    ) as *mut bool;
    set *rootedFlag = rooted;
    for arg in args {
        storedArgs.append(arg, a);
    }
    let nominal = allocNominalType(self, NominalType::Placeholder(template.decl));
    let cacheNode = try! alloc::alloc(
        &mut self.arena,
        @sizeOf(GenericDataSpecializationNode),
        @alignOf(GenericDataSpecializationNode),
    ) as *mut GenericDataSpecializationNode;
    set *cacheNode = GenericDataSpecializationNode {
        specialization: GenericDataSpecialization {
            template: templateSym,
            args: &storedArgs[..],
            nominal,
            rooted: rootedFlag,
            site,
        },
        next: self.genericDataSpecializations,
    };
    set self.genericDataSpecializations = cacheNode;
    let sub = Substitution { params: template.params, args: &storedArgs[..] };
    match template.decl.value {
        case ast::NodeValue::RecordDecl(decl) => {
            let recordType = try specializeGenericRecord(self, template, decl, &sub);
            set *nominal = NominalType::Record(recordType);
        }
        case ast::NodeValue::UnionDecl(decl) => {
            let unionType = try specializeGenericUnion(
                self, templateSym, template, decl, &sub
            );
            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 resolveGenericValueType(self, argNode);
        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,
) -> ?*GenericFnSpecializationNode {
    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 node = cursor {
        let entry = &node.specialization;
        if entry.template == template and entry.args.len == args.len {
            let mut equal = true;
            for arg, i in args {
                if not typesEqual(*entry.args[i], *arg) {
                    set equal = false;
                    break;
                }
            }
            if equal {
                return entry;
            }
        }
        set cursor = node.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 cacheNode = try! alloc::alloc(
        &mut self.arena,
        @sizeOf(GenericFnSpecializationNode),
        @alignOf(GenericFnSpecializationNode),
    ) as *mut GenericFnSpecializationNode;
    set *cacheNode = GenericFnSpecializationNode {
        specialization: GenericFnSpecialization {
            template: templateSym,
            args: &storedArgs[..],
            fnType,
            site,
            state: GenericFnState::Queued,
            depth,
        },
        next: self.genericFnSpecializations,
    };
    set self.genericFnSpecializations = cacheNode;
    return &cacheNode.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 node = cursor {
            if let case GenericFnState::Queued = node.specialization.state {
                set queued = &mut node.specialization;
                break;
            }
            set cursor = node.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;
    }
}

/// 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.
        }
    }
}

/// Require the current declaration to be unsafe.
fn requireUnsafe(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
    if self.unsafeDepth == 0 {
        throw emitError(self, node, ErrorKind::UnsafeOperation);
    }
}

/// Reject calls from safe code through unsafe function types.
fn checkUnsafeCall(self: *mut Resolver, node: *ast::Node, info: *FnType)
    throws (ResolveError)
{
    if info.isUnsafe and self.unsafeDepth == 0 {
        throw emitError(self, node, ErrorKind::UnsafeCall);

/// 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);

        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.

            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: *mut 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,
    }
}

/// 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

    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 entry = cursor {
        if entry.symbol == symbol {
            return &entry.template;
        }
        set cursor = entry.next;
    }
    return nil;
}

/// Retrieve mutable metadata while checking a generic function body.
fn genericTemplateForMut(
    self: *mut Resolver,
    symbol: *Symbol,
) -> ?*mut GenericTemplate {
    let mut cursor = self.genericTemplates;
    while let entry = cursor {
        if entry.symbol == symbol {
            return &mut entry.template;
        }
        set cursor = entry.next;
    }
    return nil;
}

/// Return the generic template whose symbolic body is currently being checked.
fn currentGenericTemplateSymbol(self: *Resolver) -> ?*mut Symbol {
    let current = self.currentFn else return nil;
    let mut cursor = self.genericTemplates;
    while let entry = cursor {
        if let signature = entry.template.signature; signature == current {
            return entry.symbol;
        }
        set cursor = entry.next;
    }
    return nil;
}

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

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

/// Resolve and bind a function parameter using its signature mode.
fn resolveFnSignatureParam(self: *mut Resolver, node: *ast::Node, generic: bool) -> Type
    throws (ResolveError)
{
    if not generic {
        return try infer(self, node);
    }
    let case ast::NodeValue::FnParam(param) = node.value
        else throw emitError(self, node, ErrorKind::Internal);
    let ty = try resolveGenericValueType(self, param.type);
    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;
    };
    if let retNode = decl.sig.returnType {
        let retTy = try resolveFnSignatureType(
            self, retNode, genericParams.len > 0
        ) 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, genericParams.len > 0
        ) catch e {
            exitFn(self);
            throw e;
        };
        paramTypes.append(allocType(self, paramTy), a);
    }

    if decl.sig.throwList.len > MAX_FN_THROWS {
        exitFn(self);
        throw emitError(self, node, ErrorKind::FnThrowOverflow(CountMismatch {
            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, genericParams.len > 0
        ) 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, sym, GenericTemplate {
            decl: node,
            params: genericParams,
            signature: fnInfo,
            members: &[],
            declaredLinear: false,
            moduleId: sym.moduleId,
            bodyResolved: false,
            bodyChecks: 0,
        });
    }
    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;
        set template.bodyChecks += 1;
    }
    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);

            set self.unsafeDepth -= 1;
        }
        if self.linearEnabled {
            try checkLinearFn(self, nil, decl.sig.params, body);
        }
        if let template = generic {
            for param in template.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 a type used in generic data without requiring aggregate layout.
fn resolveGenericValueType(self: *mut Resolver, node: *ast::Node) -> Type
    throws (ResolveError)
{
    let case ast::NodeValue::TypeSig(sig) = node.value
        else return try resolveValueType(self, node);
    let mut ty: Type = undefined;
    match sig {
        case ast::TypeSig::Array { itemType, length } => {
            let item = try resolveGenericValueType(self, itemType);
            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 resolveGenericValueType(self, itemType);
            set ty = Type::Slice(SliceType {
                class,
                item: allocType(self, item),
                mutable,
            });
        }
        case ast::TypeSig::Pointer { class, valueType, mutable } => {
            let target = try resolveGenericValueType(self, valueType);
            set ty = Type::Pointer(PointerType {
                class,
                target: allocType(self, target),
                mutable,
            });
        }
        case ast::TypeSig::Optional { valueType } => {
            let payload = try resolveGenericValueType(self, valueType);
            set ty = Type::Optional(allocType(self, payload));
        }
        case ast::TypeSig::Nominal(typeName) => {
            let case ast::NodeValue::GenericApply(app) = typeName.value
                else return try resolveValueType(self, node);
            let templateSym = try resolveGenericDataTarget(self, app.target);
            try ensureGenericDataTemplate(self, templateSym);
            let template = genericTemplateFor(self, templateSym)
                else throw emitError(self, typeName, ErrorKind::Internal);
            if app.args.len <> template.params.len {
                throw emitError(self, typeName, 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: typeName,
            };
            set ty = Type::GenericDataApply(symbolic);
        }
        case ast::TypeSig::Record { fields, labeled } => {
            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 "resolveGenericValueType: invalid record field";
                let fieldType = try resolveGenericValueType(self, typeNode);
                try ensureStorableType(self, typeNode, fieldType);
                if let initializer = value {
                    let _ = try checkAssignable(self, initializer, fieldType);
                }
                let mut fieldName: ?*[u8] = nil;
                if let name = fieldNameNode {
                    set fieldName = try nodeName(self, name);
                }
                result.append(RecordField {
                    name: fieldName,
                    fieldType,
                    offset: -1,
                }, a);
            }
            let rec = try! alloc::alloc(
                &mut self.arena,
                @sizeOf(GenericRecordType),
                @alignOf(GenericRecordType),
            ) as *mut GenericRecordType;
            set *rec = GenericRecordType {
                fields: &result[..],
                labeled,
            };
            set ty = Type::GenericRecord(rec);
        }
        case ast::TypeSig::Fn(fnSig) => {
            if fnSig.params.len > MAX_FN_PARAMS {
                throw emitError(self, node, ErrorKind::FnParamOverflow(CountMismatch {
                    expected: MAX_FN_PARAMS,
                    actual: fnSig.params.len,
                }));
            }
            if fnSig.throwList.len > MAX_FN_THROWS {
                throw emitError(self, node, ErrorKind::FnThrowOverflow(CountMismatch {
                    expected: MAX_FN_THROWS,
                    actual: fnSig.throwList.len,
                }));
            }
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut params: *mut [*Type] = &mut [];
            let mut throwTypes: *mut [*Type] = &mut [];
            for param in fnSig.params {
                let paramType = try resolveGenericValueType(self, param);
                params.append(allocType(self, paramType), a);
            }
            for throwNode in fnSig.throwList {
                let throwType = try resolveGenericValueType(self, throwNode);
                try ensureStorableType(self, throwNode, throwType);
                throwTypes.append(allocType(self, throwType), a);
            }
            let mut returnType = allocType(self, Type::Void);
            if let returnNode = fnSig.returnType {
                let resolved = try resolveGenericValueType(self, returnNode);
                try ensureStorableType(self, returnNode, resolved);
                set returnType = allocType(self, resolved);
            }
            set ty = Type::Fn(allocFnType(self, FnType {
                paramTypes: &params[..],
                returnType,
                throwList: &throwTypes[..],
                isUnsafe: false,
                localCount: 0,
            }));
        }
        else => return try resolveValueType(self, node),
    }
    return setNodeType(self, node, ty);
}

/// 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],
    isRecord: bool,
) throws (ResolveError) {
    let sym = symbolFor(self, node) else return;
    if genericTemplateFor(self, sym) <> nil {
        return;
    }
    enterScope(self, node);
    let genericParams = try resolveGenericParams(self, node, params) catch e {
        exitScope(self);
        throw e;
    };
    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, sym, GenericTemplate {
        decl: node,
        params: genericParams,
        signature: nil,
        members: &[],
        declaredLinear,
        moduleId: sym.moduleId,
        bodyResolved: true,
        bodyChecks: 0,
    });
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut memberTypes: *mut [*Type] = &mut [];
    for member in members {
        let mut memberTy = Type::Void;
        let mut defaultValue: ?*ast::Node = nil;
        if isRecord {
            let case ast::NodeValue::RecordField { type, value, .. } = member.value
                else panic "resolveGenericDataTemplate: invalid record field";
            set memberTy = try resolveGenericValueType(self, type) catch e {
                exitScope(self);
                throw e;
            };
            set defaultValue = value;
            try ensureStorableType(self, type, memberTy) catch e {
                exitScope(self);
                throw e;
            };
        } else {
            let case ast::NodeValue::UnionDeclVariant(variant) = member.value
                else panic "resolveGenericDataTemplate: invalid union variant";
            if let type = variant.type {
                set memberTy = try resolveGenericValueType(self, type) catch e {
                    exitScope(self);
                    throw e;
                };
                try ensureStorableType(self, type, memberTy) catch e {
                    exitScope(self);
                    throw e;
                };
            }
            set defaultValue = variant.value;
        }
        if let value = defaultValue {
            if isRecord {
                let _ = try checkAssignable(self, value, memberTy) catch e {
                    exitScope(self);
                    throw e;
                };
            } else {
                let _ = try checkNumeric(self, value) catch e {
                    exitScope(self);
                    throw e;
                };
                if constValueEntry(self, value) == nil and
                   (not isConstExpr(self, value) or
                    not containsGenericConstExpr(self, value))
                {
                    exitScope(self);
                    throw emitError(self, value, ErrorKind::ConstExprRequired);
                }
            }
        }
        memberTypes.append(allocType(self, memberTy), a);
    }
    exitScope(self);
    set *metadata = GenericTemplate {
        decl: node,
        params: genericParams,
        signature: nil,
        members: &memberTypes[..],
        declaredLinear,
        moduleId: sym.moduleId,
        bodyResolved: true,
        bodyChecks: 0,
    };
}

/// 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);


    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 sym;
}

/// Find a trait method by name.
export fn findTraitMethod(traitType: *TraitType, name: *[u8]) -> ?*TraitMethod {

        }
    }
    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

    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;
        }

        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);
        if let value = variantDecl.value {
            let _ = try checkSizeInt(self, value);
        }
        let tag = try variantTag(self, variantDecl, &mut iota, nil);
        // 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 {

    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.


        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;
}

/// 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;
    }
    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;
        }
    }
    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 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(traitInfo, methodName)
            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);
                    }
                }

            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);
}

/// A uniquely selected method exposed by a generic parameter bound.
record GenericBoundMethod {
    traitInfo: *TraitType,
    method: *TraitMethod,
}

/// 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 Type::Array(ArrayType { item: allocType(self, item), length });
        }
        case ast::TypeSig::Slice { class, itemType, mutable } => {
            let item = try infer(self, itemType);
            return Type::Slice {
            return 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 {
            return 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));
        }
        case ast::TypeSig::Nominal(name) => {
            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;
                    return Type::Parameter(selfType);
                }
                let sym = findTypeSymbol(self.scope, paramName) else {
                    throw emitError(self, name, ErrorKind::UnresolvedSymbol(paramName));
                };
                match sym.data {
                    case SymbolData::Type(ty) => {
                        if isGenericDeclaration(sym.node) {
                            throw emitError(self, name, ErrorKind::GenericArgumentsRequired);
                        }
                        setNodeSymbol(self, name, sym);
                        return Type::Nominal(ty);
                    }
                    case SymbolData::TypeParameter(param) => {
                        set *param.used = true;
                        setNodeSymbol(self, name, sym);
                        return Type::Parameter(param);
                    }
                    else => throw emitError(self, name, ErrorKind::Internal),
                }
            }
            let ty = try resolveTypeName(self, name);
            return Type::Nominal(ty);
        }
        case ast::TypeSig::Record { fields, labeled } => {
            let recordType = try resolveRecordFields(self, node, fields, labeled);

        // 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 };
            return Type::TraitObject(TraitObjectType { class, traitInfo, mutable });
        }
    }
}

/// 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 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, true,
                    ) 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, false,
                    ) 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 {

                }
            }
            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 };
        };
    }
    // Data roots are validated after every package has had a chance to provide
    // an explicit root for a shared specialization.
    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 +949 -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.specialization.args.len == 1;
    assert *node.specialization.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;
    assert template.moduleId == sym.moduleId;
}

/// Re-entering definition analysis does not check a generic body twice.
@test fn testGenericFunctionBodyCheckedOnce() 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.bodyChecks == 1;
}

/// 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.specialization.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);
}

/// Bound receivers participate in call-scoped loan conflict checks.
@test fn testGenericBoundReceiverBorrowConflict() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Marker: Linear {} trait View { fn (&mut View) inspect(other: &Self); } fn inspectTwice⟨T: View⟩(value: T) { let mut local = value; local.inspect(&local); }",
    );
    try expectErrorKind(
        &result, super::ErrorKind::BorrowConflict("local")
    );
}

/// 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;
}

test/runner.rad +13 -1

/// 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");

        return false;
    }

    // Lower to IL.
    let mut ilArena = alloc::new(&mut IL_ARENA_STORAGE[..]);
    let program = try lower::lower(&res, root, "test", &mut ilArena) catch err {
    let program = try lower::lower(&mut res, root, "test", &mut ilArena) catch err {
        io::print("error: lowering failed: ");
        lower::printError(err);
        io::printLn("");
        return false;
    };

test/tests/coercion.implicit.ril +10 -6

    store w8 1 %0 0;
    store w32 42 %0 4;
    reserve %1 8 4;
    blit %1 %0 8;
    load w8 %2 %1 0;
    br.ne w32 %2 0 @merge1 @else2;
  @merge1
    br.ne w32 %2 0 @success1 @else2;
  @success1
    sload w32 %3 %1 4;
    ret %3;
    jmp @merge3;
  @else2
    ret 0;
  @merge3
    ret %3;
}

fn w32 $optionalLiftVar(w32 %0) {
  @entry0
    reserve %1 8 4;

    reserve %2 8 4;
    blit %2 %1 8;
    reserve %3 8 4;
    blit %3 %2 8;
    load w8 %4 %3 0;
    br.ne w32 %4 0 @merge1 @else2;
  @merge1
    br.ne w32 %4 0 @success1 @else2;
  @success1
    sload w32 %5 %3 4;
    ret %5;
    jmp @merge3;
  @else2
    ret 0;
  @merge3
    ret %5;
}

fn w64 $optionalLiftReturn(w64 %0, w32 %1) {
  @entry0
    reserve %2 8 4;

test/tests/cond.letelse.case.ril +5 -3

fn w32 $letElseCase(w32 %0) {
  @entry0
    br.eq w32 %0 1 @merge1 @else2;
  @merge1
    ret 1;
    br.eq w32 %0 1 @success1 @else2;
  @success1
    jmp @merge3;
  @else2
    ret 0;
  @merge3
    ret 1;
}

test/tests/cond.letelse.guard.ril +4 -2

  @entry0
    br.eq w32 %0 1 @guard2 @else1;
  @else1
    ret 0;
  @guard2
    br.slt w32 0 %0 @merge3 @else1;
  @merge3
    br.slt w32 0 %0 @success3 @else1;
  @success3
    jmp @merge4;
  @merge4
    ret 1;
}

test/tests/cond.letelse.mut.ril +6 -4

fn w32 $letMutElse(w64 %0) {
  @entry0
    reserve %1 8 4;
    blit %1 %0 8;
    load w8 %2 %1 0;
    br.ne w32 %2 0 @merge1 @else2;
  @merge1
    br.ne w32 %2 0 @success1 @else2;
  @success1
    sload w32 %3 %1 4;
    add w32 %4 %3 1;
    ret %4;
    jmp @merge3;
  @else2
    ret 0;
  @merge3
    add w32 %4 %3 1;
    ret %4;
}

test/tests/cond.letelse.optional.ril +5 -3

fn w32 $letElseOptional(w64 %0) {
  @entry0
    br.ne w32 %0 0 @merge1 @else2;
  @merge1
    ret 1;
    br.ne w32 %0 0 @success1 @else2;
  @success1
    jmp @merge3;
  @else2
    ret 0;
  @merge3
    ret 1;
}

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 +29 -0

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

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 +14 -0

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

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 +40 -0

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

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 +68 -0

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

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

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 +33 -0

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

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 +15 -0

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

test/tests/opt.slice.npo.ril +8 -7

    reserve %2 16 8;
    blit %2 %1 16;
    reserve %3 16 8;
    blit %3 %2 16;
    load w64 %4 %3 0;
    br.ne w32 %4 0 @merge1 @else2;
  @merge1
    load w32 %5 %3 8;
    br.eq w32 %5 3 @assert.ok4 @assert.fail3;
    br.ne w32 %4 0 @success1 @else2;
  @success1
    jmp @merge3;
  @else2
    ret 40;
  @assert.fail3
  @merge3
    load w32 %5 %3 8;
    br.eq w32 %5 3 @assert.ok5 @assert.fail4;
  @assert.fail4
    unreachable;
  @assert.ok4
  @assert.ok5
    ret 0;
}

fn w64 $returnNil(w64 %0) {
  @entry0

  @then15
    ret %7;
  @merge16
    ret 0;
}


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 -13

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;

  @assert.fail13
    unreachable;
  @assert.ok14
    ret 0;
}


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

468	468		fields: mut [Node],
469	469		/// When true, remaining fields are discarded (`{ x, .. }`).
470	470		ignoreRest: bool,
471	471		}
472	472
	473	+	/// Generic declaration parameter.
	474	+	export union GenericParam {
	475	+	/// Rigid type parameter with optional trait bounds.
	476	+	Type {
	477	+	name: *Node,
	478	+	bounds: mut [Node],
	479	+	},
	480	+	/// Compile-time constant parameter.
	481	+	Const {
	482	+	name: *Node,
	483	+	type: *Node,
	484	+	},
	485	+	}
	486	+
	487	+	/// Application of ordered generic arguments to a declaration or path.
	488	+	export record GenericApply {
	489	+	target: *Node,
	490	+	args: mut [Node],
	491	+	}
	492	+
473	493		/// Record declaration.
474	494		export record RecordDecl {
475	495		/// Identifier naming the record.
476	496		name: *Node,
	497	+	/// Generic parameters in declaration order.
	498	+	params: mut [Node],
477	499		/// Field declaration nodes.
478	500		fields: mut [Node],
479	501		/// Optional attribute list applied to the record.
480	502		attrs: ?Attributes,
481	503		/// Trait derivations attached to the record.

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

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

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

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		-	/// Main arena size (64 MB) - lives throughout compilation.
	42	+	/// Main arena size (80 MB) - lives throughout compilation.
43	43		/// Used for: resolver data, types, symbols, global IL data, and codegen output.
44		-	constant MAIN_ARENA_SIZE: u32 = 67108864;
	44	+	constant MAIN_ARENA_SIZE: u32 = 83886080;
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.
49	49		static FN_ARENA: [u8; FN_ARENA_SIZE] = undefined;

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

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

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		}

290	290		fnArena: *mut alloc::Arena,
291	291		/// Allocator backed by the arena.
292	292		allocator: alloc::Allocator,
293	293		/// Resolver for type information. Used to query types, symbols, and
294	294		/// compile-time constant values during lowering.
295		-	resolver: *resolver::Resolver,
	295	+	resolver: *mut resolver::Resolver,
296	296		/// Module graph for cross-module symbol resolution.
297	297		moduleGraph: ?*module::ModuleGraph,
298	298		/// Package name for qualified symbol names.
299	299		pkgName: *[u8],
300	300		/// Current module being lowered.
301	301		currentMod: ?u16,
	302	+	/// Rigid-to-concrete mapping for the function currently being lowered.
	303	+	specialization: ?*resolver::Substitution,
	304	+	/// Concrete generic function whose body is currently being lowered.
	305	+	genericSpecialization: ?*resolver::GenericFnSpecialization,
302	306		/// Global data items (string literals, constants, static arrays).
303	307		/// These become the data sections in the final binary.
304	308		data: *mut [il::Data],
305	309		/// Destination for lowered functions.
306	310		output: FnOutput,

741	745		/// 3. Returns the complete IL program with functions and data section.
742	746		///
743	747		/// The resolver must have already processed the AST -- we rely on its type
744	748		/// annotations, symbol table, and constant evaluations.
745	749		export fn lower(
746		-	res: *resolver::Resolver,
	750	+	res: *mut resolver::Resolver,
747	751		root: *ast::Node,
748	752		pkgName: *[u8],
749	753		arena: *mut alloc::Arena
750	754		) -> il::Program throws (LowerError) {
751	755		let mut low = Lowerer {

754	758		allocator: alloc::arenaAllocator(arena),
755	759		resolver: res,
756	760		moduleGraph: nil,
757	761		pkgName,
758	762		currentMod: nil,
	763	+	specialization: nil,
	764	+	genericSpecialization: nil,
759	765		data: &mut [],
760	766		output: FnOutput::Accumulate(&mut []),
761	767		fnSyms: &mut [],
762	768		errTags: &mut [],
763	769		errTagCounter: 1,

772	778		// Multi-Module Lowering API //
773	779		/////////////////////////////////
774	780
775	781		/// Create a lowerer for multi-module compilation.
776	782		export fn lowerer(
777		-	res: *resolver::Resolver,
	783	+	res: *mut resolver::Resolver,
778	784		graph: *module::ModuleGraph,
779	785		pkgName: *[u8],
780	786		arena: *mut alloc::Arena,
781	787		fnArena: *mut alloc::Arena,
782	788		options: LowerOptions

787	793		allocator: alloc::arenaAllocator(arena),
788	794		resolver: res,
789	795		moduleGraph: graph,
790	796		pkgName,
791	797		currentMod: nil,
	798	+	specialization: nil,
	799	+	genericSpecialization: nil,
792	800		data: &mut [],
793	801		output: FnOutput::Accumulate(&mut []),
794	802		fnSyms: &mut [],
795	803		errTags: &mut [],
796	804		errTagCounter: 1,

1307	1576		}
1308	1577		throw LowerError::MissingConst(node);
1309	1578		};
1310	1579
1311	1580		if let case resolver::ConstValue::String(s) = val {
1312		-	if let case resolver::Type::Slice { .. } = ty {
	1581	+	if let case resolver::Type::Slice(_) = ty {
1313	1582		let strSym = try getOrCreateStringData(self, s, dataPrefix);
1314	1583		dataSliceHeader(b, strSym, s.len);
1315	1584		return;
1316	1585		}
1317	1586		}

4084	4369		}
4085	4370		case resolver::Type::Nominal(_) => {
4086	4371		// Void unions are small enough to pass by value.
4087	4372		return not resolver::isVoidUnion(typ);
4088	4373		}
4089		-	case resolver::Type::Array(_),
	4374	+	case resolver::Type::Slice(_),
	4375	+	resolver::Type::TraitObject(_),
	4376	+	resolver::Type::Array(_),
4090	4377		resolver::Type::Nil => return true,
4091	4378		else => return false,
4092	4379		}
4093	4380		}
4094	4381

818	826		let stmtsList = block.statements;
819	827
820	828		for node in stmtsList {
821	829		match node.value {
822	830		case ast::NodeValue::FnDecl(decl) => {
	831	+	// Generic declarations are templates, not emitted functions.
	832	+	if decl.params.len > 0 {
	833	+	continue;
	834	+	}
823	835		if let f = try lowerFnDecl(low, node, decl) {
824	836		let role = lowerFnRole(isRoot, decl.attrs);
825	837		emitFunction(low, f, role);
826	838		}
827	839		}

840	852		}
841	853		}
842	854		else => {},
843	855		}
844	856		}
	857	+	try lowerGenericFnSpecializations(low);
	858	+	}
	859	+
	860	+	/// Lower explicit generic function roots owned by the current module.
	861	+	fn lowerGenericFnSpecializations(low: *mut Lowerer) throws (LowerError) {
	862	+	let mut cursor = resolver::genericFnSpecializations(low.resolver);
	863	+	while let node = cursor {
	864	+	let specialization = &node.specialization;
	865	+	let templateSym = specialization.template;
	866	+	if low.moduleGraph <> nil and templateSym.moduleId <> low.currentMod {
	867	+	set cursor = node.next;
	868	+	continue;
	869	+	}
	870	+	let case ast::NodeValue::FnDecl(decl) = templateSym.node.value else {
	871	+	throw LowerError::ExpectedFunction;
	872	+	};
	873	+	if not shouldLowerFn(&decl, low.options.buildTest) {
	874	+	set cursor = node.next;
	875	+	continue;
	876	+	}
	877	+	let template = resolver::genericTemplateFor(low.resolver, templateSym)
	878	+	else throw LowerError::MissingMetadata;
	879	+	let sub = resolver::Substitution {
	880	+	params: template.params,
	881	+	args: specialization.args,
	882	+	};
	883	+	let symbolicFnType = template.signature
	884	+	else throw LowerError::MissingMetadata;
	885	+	let mut concreteFnType = *specialization.fnType;
	886	+	set concreteFnType.localCount = symbolicFnType.localCount;
	887	+	set low.genericSpecialization = specialization;
	888	+	set low.specialization = ⊂
	889	+	let name = specializationName(low, specialization);
	890	+	let func = try lowerConcreteFn(
	891	+	low,
	892	+	templateSym.node,
	893	+	decl,
	894	+	&concreteFnType,
	895	+	name,
	896	+	false,
	897	+	) catch e {
	898	+	set low.genericSpecialization = nil;
	899	+	set low.specialization = nil;
	900	+	throw e;
	901	+	};
	902	+	set low.genericSpecialization = nil;
	903	+	set low.specialization = nil;
	904	+	emitFunction(low, func, FnRole::Normal);
	905	+	set cursor = node.next;
	906	+	}
845	907		}
846	908
847	909		/// Finalize lowering and return the unified IL program.
848	910		export fn finalize(low: *Lowerer) -> il::Program {
849	911		let mut fns: mut [il::Fn] = undefined;

892	954		return name;
893	955		}
894	956		return il::formatQualifiedName(self.arena, path, name);
895	957		}
896	958
	959	+	/// Incrementally build deterministic internal symbol names.
	960	+	record NameBuilder {
	961	+	/// Accumulated name bytes.
	962	+	bytes: *mut [u8],
	963	+	/// Allocator used to grow the name.
	964	+	allocator: alloc::Allocator,
	965	+	}
	966	+
	967	+	/// Append bytes to a symbol name.
	968	+	fn namePush(builder: mut NameBuilder, text: [u8]) {
	969	+	for byte in text {
	970	+	builder.bytes.append(byte, builder.allocator);
	971	+	}
	972	+	}
	973	+
	974	+	/// Append a decimal `u32` to a symbol name.
	975	+	fn namePushU32(builder: *mut NameBuilder, value: u32) {
	976	+	let mut digits: [u8; 10] = undefined;
	977	+	namePush(builder, fmt::formatU32(value, &mut digits[..]));
	978	+	}
	979	+
	980	+	/// Append a decimal `u64` to a symbol name.
	981	+	fn namePushU64(builder: *mut NameBuilder, value: u64) {
	982	+	let mut digits: [u8; 20] = undefined;
	983	+	namePush(builder, fmt::formatU64(value, &mut digits[..]));
	984	+	}
	985	+
	986	+	/// Append the stable, source-qualified name of a module-level declaration.
	987	+	fn namePushQualified(
	988	+	self: *mut Lowerer,
	989	+	builder: *mut NameBuilder,
	990	+	modId: ?u16,
	991	+	name: *[u8],
	992	+	) {
	993	+	let path = getModulePath(self, modId);
	994	+	if path.len == 0 or path[0] <> self.pkgName {
	995	+	namePush(builder, self.pkgName);
	996	+	namePush(builder, "::");
	997	+	}
	998	+	for segment in path {
	999	+	namePush(builder, segment);
	1000	+	namePush(builder, "::");
	1001	+	}
	1002	+	namePush(builder, name);
	1003	+	}
	1004	+
	1005	+	/// Append a trait's qualified name.
	1006	+	fn namePushTrait(
	1007	+	self: *mut Lowerer,
	1008	+	builder: *mut NameBuilder,
	1009	+	traitInfo: *resolver::TraitType,
	1010	+	) {
	1011	+	namePushQualified(self, builder, traitInfo.moduleId, traitInfo.name);
	1012	+	}
	1013	+
	1014	+	/// Append a canonical resolved type using Radiance source syntax.
	1015	+	fn namePushType(
	1016	+	self: *mut Lowerer,
	1017	+	builder: *mut NameBuilder,
	1018	+	ty: resolver::Type,
	1019	+	) {
	1020	+	match ty {
	1021	+	case resolver::Type::Void => namePush(builder, "void"),
	1022	+	case resolver::Type::Opaque => namePush(builder, "opaque"),
	1023	+	case resolver::Type::Never => namePush(builder, "!"),
	1024	+	case resolver::Type::Bool => namePush(builder, "bool"),
	1025	+	case resolver::Type::U8 => namePush(builder, "u8"),
	1026	+	case resolver::Type::U16 => namePush(builder, "u16"),
	1027	+	case resolver::Type::U32 => namePush(builder, "u32"),
	1028	+	case resolver::Type::U64 => namePush(builder, "u64"),
	1029	+	case resolver::Type::I8 => namePush(builder, "i8"),
	1030	+	case resolver::Type::I16 => namePush(builder, "i16"),
	1031	+	case resolver::Type::I32 => namePush(builder, "i32"),
	1032	+	case resolver::Type::I64 => namePush(builder, "i64"),
	1033	+	case resolver::Type::Pointer(pointer) => {
	1034	+	match pointer.class {
	1035	+	case types::PointerClass::Owned => namePush(builder, "*"),
	1036	+	case types::PointerClass::Ref => namePush(builder, "&"),
	1037	+	case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
	1038	+	}
	1039	+	if pointer.mutable { namePush(builder, "mut "); }
	1040	+	namePushType(self, builder, *pointer.target);
	1041	+	}
	1042	+	case resolver::Type::Slice(slice) => {
	1043	+	match slice.class {
	1044	+	case types::PointerClass::Owned => namePush(builder, "*"),
	1045	+	case types::PointerClass::Ref => namePush(builder, "&"),
	1046	+	case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
	1047	+	}
	1048	+	if slice.mutable { namePush(builder, "mut "); }
	1049	+	namePush(builder, "[");
	1050	+	namePushType(self, builder, *slice.item);
	1051	+	namePush(builder, "]");
	1052	+	}
	1053	+	case resolver::Type::Array(array) => {
	1054	+	namePush(builder, "[");
	1055	+	namePushType(self, builder, *array.item);
	1056	+	namePush(builder, "; ");
	1057	+	namePushU32(builder, array.length);
	1058	+	namePush(builder, "]");
	1059	+	}
	1060	+	case resolver::Type::ConstArgument { value, .. } => {
	1061	+	if value.negative { namePush(builder, "-"); }
	1062	+	namePushU64(builder, value.magnitude);
	1063	+	}
	1064	+	case resolver::Type::Optional(inner) => {
	1065	+	namePush(builder, "?");
	1066	+	namePushType(self, builder, *inner);
	1067	+	}
	1068	+	case resolver::Type::Fn(info) => {
	1069	+	if info.isUnsafe { namePush(builder, "unsafe "); }
	1070	+	namePush(builder, "fn(");
	1071	+	for param, i in info.paramTypes {
	1072	+	if i > 0 { namePush(builder, ", "); }
	1073	+	namePushType(self, builder, *param);
	1074	+	}
	1075	+	namePush(builder, ") -> ");
	1076	+	namePushType(self, builder, *info.returnType);
	1077	+	if info.throwList.len > 0 {
	1078	+	namePush(builder, " throws ");
	1079	+	for thrown, i in info.throwList {
	1080	+	if i > 0 { namePush(builder, ", "); }
	1081	+	namePushType(self, builder, *thrown);
	1082	+	}
	1083	+	}
	1084	+	}
	1085	+	case resolver::Type::Nominal(nominal) => {
	1086	+	if let data = resolver::genericDataSpecializationForNominal(
	1087	+	self.resolver, nominal
	1088	+	) {
	1089	+	namePushQualified(
	1090	+	self, builder, data.template.moduleId, data.template.name
	1091	+	);
	1092	+	namePush(builder, "⟨");
	1093	+	for arg, i in data.args {
	1094	+	if i > 0 { namePush(builder, ", "); }
	1095	+	namePushType(self, builder, *arg);
	1096	+	}
	1097	+	namePush(builder, "⟩");
	1098	+	return;
	1099	+	}
	1100	+	if let sym = resolver::symbolForNominal(self.resolver, nominal) {
	1101	+	namePushQualified(self, builder, sym.moduleId, sym.name);
	1102	+	return;
	1103	+	}
	1104	+	match *nominal {
	1105	+	case resolver::NominalType::Record(recordType) => {
	1106	+	namePush(builder, "{ ");
	1107	+	for field, i in recordType.fields {
	1108	+	if i > 0 { namePush(builder, ", "); }
	1109	+	if let name = field.name {
	1110	+	namePush(builder, name);
	1111	+	namePush(builder, ": ");
	1112	+	}
	1113	+	namePushType(self, builder, field.fieldType);
	1114	+	}
	1115	+	namePush(builder, " }");
	1116	+	}
	1117	+	case resolver::NominalType::Union(_) =>
	1118	+	panic "namePushType: anonymous union has no source identity",
	1119	+	case resolver::NominalType::Placeholder(_) =>
	1120	+	panic "namePushType: unresolved nominal type",
	1121	+	}
	1122	+	}
	1123	+	case resolver::Type::TraitObject(object) => {
	1124	+	match object.class {
	1125	+	case types::PointerClass::Owned => namePush(builder, "*"),
	1126	+	case types::PointerClass::Ref => namePush(builder, "&"),
	1127	+	case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
	1128	+	}
	1129	+	if object.mutable { namePush(builder, "mut "); }
	1130	+	namePush(builder, "opaque ");
	1131	+	namePushTrait(self, builder, object.traitInfo);
	1132	+	}
	1133	+	else => panic "namePushType: non-concrete type",
	1134	+	}
	1135	+	}
	1136	+
	1137	+	/// Build a readable specialization name from source identity and canonical arguments.
	1138	+	fn specializationName(
	1139	+	self: *mut Lowerer,
	1140	+	specialization: *resolver::GenericFnSpecialization,
	1141	+	) -> *[u8] {
	1142	+	let template = specialization.template;
	1143	+	let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
	1144	+	namePushQualified(self, &mut builder, template.moduleId, template.name);
	1145	+	namePush(&mut builder, "⟨");
	1146	+	for arg, i in specialization.args {
	1147	+	if i > 0 { namePush(&mut builder, ", "); }
	1148	+	namePushType(self, &mut builder, *arg);
	1149	+	}
	1150	+	namePush(&mut builder, "⟩");
	1151	+	return &builder.bytes[..];
	1152	+	}
	1153	+
897	1154		/// Register a function symbol with its qualified name.
898	1155		/// Called when lowering function declarations, so cross-package calls can find
899	1156		/// the function by name.
900	1157		fn registerFnSym(self: mut Lowerer, sym: resolver::Symbol, qualName: *[u8]) {
901	1158		self.fnSyms.append(FnSymEntry { sym, qualName }, self.allocator);

988	1245
989	1246		// Register function symbol for cross-package call resolution.
990	1247		if let sym = data.sym {
991	1248		registerFnSym(self, sym, qualName);
992	1249		}
993		-	let mut fnLow = fnLowerer(self, node, fnType, qualName);
	1250	+	return try lowerConcreteFn(self, node, decl, fnType, qualName, isExtern);
	1251	+	}
994	1252
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.
	1253	+	/// Lower one already-concrete function signature through the shared body path.
	1254	+	fn lowerConcreteFn(
	1255	+	self: *mut Lowerer,
	1256	+	node: *ast::Node,
	1257	+	decl: ast::FnDecl,
	1258	+	fnType: *resolver::FnType,
	1259	+	qualName: *[u8],
	1260	+	isExtern: bool,
	1261	+	) -> *il::Fn throws (LowerError) {
	1262	+	let mut fnLow = fnLowerer(self, node, fnType, qualName);
998	1263		if requiresReturnParam(fnType) and not isExtern {
999	1264		set fnLow.returnReg = nextReg(&mut fnLow);
1000	1265		}
1001	1266		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		-
	1267	+	let func = try! alloc::alloc(
	1268	+	self.fnArena, @sizeOf(il::Fn), @alignOf(il::Fn)
	1269	+	) as *mut il::Fn;
1004	1270		set *func = il::Fn {
1005	1271		name: qualName,
1006	1272		params: lowParams,
1007	1273		returnType: undefined,
1008	1274		isExtern,
1009	1275		isLeaf: true,
1010	1276		blocks: &[],
1011	1277		};
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	1278		if fnType.throwList.len > 0 {
1017	1279		set func.returnType = il::Type::W64;
1018	1280		} else {
1019	1281		set func.returnType = ilType(self, *fnType.returnType);
1020	1282		}
1021	1283		let body = decl.body else {
1022		-	// Extern functions have no body.
1023	1284		assert isExtern;
1024	1285		return func;
1025	1286		};
1026	1287		set func.blocks = try lowerFnBody(&mut fnLow, body);
1027	1288		set func.isLeaf = fnLow.isLeaf;
1028		-
1029	1289		return func;
1030	1290		}
1031	1291
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]);
	1292	+	/// Build a readable method name from its concrete type, trait, and source name.
	1293	+	fn instanceMethodName(
	1294	+	self: *mut Lowerer,
	1295	+	concreteType: resolver::Type,
	1296	+	traitInfo: ?*resolver::TraitType,
	1297	+	methodName: *[u8],
	1298	+	) -> *[u8] {
	1299	+	let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
	1300	+	namePushType(self, &mut builder, concreteType);
	1301	+	if let traitValue = traitInfo {
	1302	+	namePush(&mut builder, " ");
	1303	+	namePushTrait(self, &mut builder, traitValue);
	1304	+	}
	1305	+	namePush(&mut builder, "::");
	1306	+	namePush(&mut builder, methodName);
	1307	+	return &builder.bytes[..];
	1308	+	}
	1309	+
	1310	+	/// Build a readable v-table name from its concrete type and trait.
	1311	+	fn vtableName(
	1312	+	self: *mut Lowerer,
	1313	+	concreteType: resolver::Type,
	1314	+	traitInfo: *resolver::TraitType,
	1315	+	) -> *[u8] {
	1316	+	let mut builder = NameBuilder { bytes: &mut [], allocator: self.allocator };
	1317	+	namePush(&mut builder, "vtable::");
	1318	+	namePushType(self, &mut builder, concreteType);
	1319	+	namePush(&mut builder, " ");
	1320	+	namePushTrait(self, &mut builder, traitInfo);
	1321	+	return &builder.bytes[..];
1062	1322		}
1063	1323
1064	1324		/// Lower an instance declaration (`instance Trait for Type { ... }`).
1065	1325		///
1066	1326		/// 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
	1327	+	/// with a qualified name containing both concrete and declaring-trait
	1328	+	/// identities. A read-only v-table data record points to these functions,
	1329	+	/// ordered by the trait's method indices. The v-table is later referenced when
1070	1330		/// constructing trait objects for dynamic dispatch.
1071	1331		fn lowerInstanceDecl(
1072	1332		self: *mut Lowerer,
1073	1333		node: *ast::Node,
1074	1334		traitNameNode: *ast::Node,
1075	1335		targetTypeNode: *ast::Node,
1076	1336		methods: mut [ast::Node]
1077	1337		) throws (LowerError) {
1078		-	// Look up the trait and type from the resolver.
	1338	+	// Look up the trait and concrete instance from resolver metadata.
1079	1339		let traitSym = resolver::nodeData(self.resolver, traitNameNode).sym
1080	1340		else throw LowerError::MissingSymbol(traitNameNode);
1081	1341		let case resolver::SymbolData::Trait(traitInfo) = traitSym.data
1082	1342		else throw LowerError::MissingMetadata;
1083		-	let typeSym = resolver::nodeData(self.resolver, targetTypeNode).sym
1084		-	else throw LowerError::MissingSymbol(targetTypeNode);
1085		-
1086		-	let tName = traitSym.name;
1087		-	let typeName = typeSym.name;
	1343	+	let concreteType = resolver::typeFor(self.resolver, targetTypeNode)
	1344	+	else throw LowerError::MissingType(targetTypeNode);
	1345	+	let instEntry = resolver::findInstance(self.resolver, traitInfo, concreteType)
	1346	+	else throw LowerError::MissingMetadata;
1088	1347
1089	1348		// Lower each instance method as a regular function.
1090	1349		// Collect qualified names for the v-table. Empty entries are filled
1091	1350		// later from inherited supertrait methods.
1092	1351		let mut methodNames: [*[u8]; ast::MAX_TRAIT_METHODS] = undefined;

1098	1357		} = methodNode.value else continue;
1099	1358
1100	1359		let case ast::NodeValue::Ident(mName) = name.value else {
1101	1360		throw LowerError::ExpectedIdentifier;
1102	1361		};
1103		-	let qualName = instanceMethodName(self, nil, typeName, mName);
	1362	+	let method = resolver::findTraitMethod(traitInfo, mName)
	1363	+	else panic "lowerInstanceDecl: method not found in trait";
	1364	+	let qualName = instanceMethodName(
	1365	+	self, instEntry.concreteType, method.owner, mName
	1366	+	);
1104	1367		let func = try lowerMethod(self, methodNode, qualName, receiverName, sig, body)
1105	1368		else continue;
1106	1369		emitFunction(self, func, FnRole::Normal);
1107	1370
1108		-	let method = resolver::findTraitMethod(traitInfo, mName)
1109		-	else panic "lowerInstanceDecl: method not found in trait";
1110		-
1111	1371		set methodNames[method.index] = qualName;
1112	1372		set methodNameSet[method.index] = true;
1113	1373		}
1114	1374
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.
	1375	+	// Fill inherited method slots from their declaring supertraits. Their
	1376	+	// declaring-trait identity selects the already lowered implementation.
1118	1377		for method, i in traitInfo.methods {
1119	1378		if not methodNameSet[i] {
1120		-	set methodNames[i] = instanceMethodName(self, nil, typeName, method.name);
	1379	+	let inheritedInst = resolver::findInstance(
	1380	+	self.resolver, method.owner, instEntry.concreteType
	1381	+	) else throw LowerError::MissingMetadata;
	1382	+	set methodNames[i] = instanceMethodName(
	1383	+	self,
	1384	+	inheritedInst.concreteType,
	1385	+	method.owner,
	1386	+	method.name,
	1387	+	);
1121	1388		}
1122	1389		}
1123	1390
1124	1391		// Create v-table in data section, used for dynamic dispatch.
1125		-	let vName = vtableName(self, nil, typeName, tName);
	1392	+	let vName = vtableName(self, instEntry.concreteType, traitInfo);
1126	1393		let values = try! alloc::allocSlice(
1127	1394		self.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue), traitInfo.methods.len as u32
1128	1395		) as *mut [il::DataValue];
1129	1396
1130	1397		for i in 0..traitInfo.methods.len {

1198	1465		else throw LowerError::MissingSymbol(node);
1199	1466		let case ast::NodeValue::Ident(mName) = name.value
1200	1467		else throw LowerError::ExpectedIdentifier;
1201	1468		let me = resolver::findMethodBySymbol(self.resolver, sym)
1202	1469		else throw LowerError::MissingMetadata;
1203		-	let qualName = instanceMethodName(self, nil, me.concreteTypeName, mName);
	1470	+	let qualName = instanceMethodName(
	1471	+	self, me.concreteType, nil, mName
	1472	+	);
1204	1473
1205	1474		return try lowerMethod(self, node, qualName, receiverName, sig, body);
1206	1475		}
1207	1476
1208	1477		/// Check if a function should be lowered.

1379	1648		addr: ast::AddressOf,
1380	1649		ty: resolver::Type,
1381	1650		dataPrefix: *[u8],
1382	1651		b: *mut DataValueBuilder
1383	1652		) throws (LowerError) {
1384		-	let case resolver::Type::Slice { mutable, .. } = ty
	1653	+	let case resolver::Type::Slice(slice) = ty
1385	1654		else throw LowerError::ExpectedSliceOrArray;
1386	1655		let targetTy = resolver::typeFor(self.resolver, addr.target)
1387	1656		else throw LowerError::MissingType(addr.target);
1388	1657		let case resolver::Type::Array(arrInfo) = targetTy
1389	1658		else throw LowerError::ExpectedArray;

1391	1660		let mut nested = dataBuilder(self.allocator);
1392	1661		let layout = resolver::getTypeLayout(targetTy);
1393	1662		try lowerConstDataInto(self, addr.target, targetTy, layout.size, dataPrefix, &mut nested);
1394	1663
1395	1664		let backing = dataBuilderFinish(&nested);
1396		-	let readOnly = not mutable;
	1665	+	let readOnly = not slice.mutable;
1397	1666		let mut dataName: *[u8] = undefined;
1398	1667		if readOnly {
1399	1668		if let found = findConstData(self, backing.values, layout.alignment) {
1400	1669		set dataName = found;
1401	1670		} else {

1929	2198		let reg = il::Reg { n: self.regCounter };
1930	2199		set self.regCounter += 1;
1931	2200		return reg;
1932	2201		}
1933	2202
	2203	+	/// Apply the current function specialization to resolver-owned type metadata.
	2204	+	fn specializeType(
	2205	+	self: *mut FnLowerer,
	2206	+	ty: resolver::Type,
	2207	+	node: *ast::Node,
	2208	+	) -> resolver::Type {
	2209	+	if let sub = self.low.specialization; resolver::containsGenericParameter(ty) {
	2210	+	return try resolver::substituteType(
	2211	+	self.low.resolver, ty, sub, node
	2212	+	) catch {
	2213	+	panic "specializeType: substitution failed after resolution";
	2214	+	};
	2215	+	}
	2216	+	return ty;
	2217	+	}
	2218	+
1934	2219		/// Look up the resolved type of an AST node, or throw `MissingType`.
1935	2220		fn typeOf(self: mut FnLowerer, node: ast::Node) -> resolver::Type throws (LowerError) {
1936	2221		let ty = resolver::typeFor(self.low.resolver, node)
1937	2222		else throw LowerError::MissingType(node);
1938		-	return ty;
	2223	+	return specializeType(self, ty, node);
1939	2224		}
1940	2225
1941	2226		/// Look up the symbol for an AST node, or throw `MissingSymbol`.
1942	2227		fn symOf(self: mut FnLowerer, node: ast::Node) -> *mut resolver::Symbol throws (LowerError) {
1943	2228		let sym = resolver::nodeData(self.low.resolver, node).sym

3190	3475		/// For null-ptr-optimized types, loads the data pointer, or returns it
3191	3476		/// directly for scalar pointers. For aggregates, returns the tag register.
3192	3477		fn optionalNilReg(self: *mut FnLowerer, val: il::Val, typ: resolver::Type) -> il::Reg throws (LowerError) {
3193	3478		let reg = emitValToReg(self, val);
3194	3479
3195		-	match typ {
3196		-	case resolver::Type::Optional(resolver::Type::Slice { .. }) => {
	3480	+	if let case resolver::Type::Optional(inner) = typ {
	3481	+	if let case resolver::Type::Slice(_) = *inner {
3197	3482		let ptrReg = nextReg(self);
3198	3483		emitLoadW64At(self, ptrReg, reg, SLICE_PTR_OFFSET);
3199	3484		return ptrReg;
3200	3485		}
3201		-	case resolver::Type::Optional(resolver::Type::Pointer { .. }) => return reg,
3202		-	case resolver::Type::Optional(_) => return tvalTagReg(self, reg),
3203		-	else => return reg,
	3486	+	if let case resolver::Type::Pointer(_) = *inner {
	3487	+	return reg;
	3488	+	}
	3489	+	return tvalTagReg(self, reg);
3204	3490		}
	3491	+	return reg;
3205	3492		}
3206	3493
3207	3494		/// Lower an optional nil check (`opt == nil` or `opt <> nil`).
3208	3495		fn lowerNilCheck(self: mut FnLowerer, opt: ast::Node, isEq: bool) -> il::Val throws (LowerError) {
3209	3496		let optTy = try typeOf(self, opt);

3421	3708		}
3422	3709		// Plain nested record destructuring pattern.
3423	3710		// Auto-deref: if the field is a pointer, load it first.
3424	3711		let mut derefType = fieldInfo.fieldType;
3425	3712		let mut nestedBase = emitPtrOffset(self, base, fieldInfo.offset);
3426		-	if let case resolver::Type::Pointer { target, .. } = fieldInfo.fieldType {
	3713	+	if let case resolver::Type::Pointer(pointer) = fieldInfo.fieldType {
3427	3714		let ptrReg = nextReg(self);
3428	3715		emitLoadW64At(self, ptrReg, nestedBase, 0);
3429	3716		set nestedBase = ptrReg;
3430		-	set derefType = *target;
	3717	+	set derefType = *pointer.target;
3431	3718		}
3432	3719		let recInfo = resolver::getRecord(derefType)
3433	3720		else throw LowerError::ExpectedRecord;
3434	3721
3435	3722		try bindNestedRecordFields(self, nestedBase, lit, recInfo, matchBy, failBlock);

3457	3744
3458	3745		// Auto-deref: when the field is a pointer and the pattern destructures
3459	3746		// the pointed-to value, load the pointer and use the target type.
3460	3747		// The loaded pointer becomes the base address for the nested subject.
3461	3748		let mut derefBase: ?il::Reg = nil;
3462		-	if let case resolver::Type::Pointer { target, .. } = fieldType {
	3749	+	if let case resolver::Type::Pointer(pointer) = fieldType {
3463	3750		if resolver::isDestructuringPattern(pattern) {
3464	3751		let ptrReg = nextReg(self);
3465	3752		emitLoadW64At(self, ptrReg, fieldPtr, 0);
3466	3753		set derefBase = ptrReg;
3467		-	set fieldType = *target;
	3754	+	set fieldType = *pointer.target;
3468	3755		}
3469	3756		}
3470	3757		// Build a MatchSubject for the nested field.
3471	3758		let ilTy = ilType(self.low, fieldType);
3472	3759		let kind = matchSubjectKind(fieldType);

4061	4348		/// choosing how to compare or store that value.
4062	4349		fn effectiveType(self: mut FnLowerer, node: ast::Node) -> resolver::Type throws (LowerError) {
4063	4350		let ty = try typeOf(self, node);
4064	4351		if let coerce = resolver::coercionFor(self.low.resolver, node) {
4065	4352		if let case resolver::Coercion::OptionalLift(optTy) = coerce {
4066		-	return optTy;
	4353	+	return specializeType(self, optTy, node);
4067	4354		}
4068	4355		}
4069	4356		return ty;
4070	4357		}
4071	4358
4072	4359		/// Check if a resolver type lowers to an aggregate in memory.
4073	4360		fn isAggregateType(typ: resolver::Type) -> bool {
4074	4361		match typ {
4075		-	case resolver::Type::Slice { .. },
4076		-	resolver::Type::TraitObject { .. } => return true,
4077		-	case resolver::Type::Optional(resolver::Type::Pointer { .. }) => {
	4362	+	case resolver::Type::Optional(resolver::Type::Pointer(_)) => {
4078	4363		// Optional pointers are scalar due to NPO.
4079	4364		return false;
4080	4365		}
4081	4366		case resolver::Type::Optional(_) => {
4082	4367		// All other optionals, including optional slices, are aggregates.

4239	4526		/// For optional pointers (`?*T`), returns an immediate `0` (null pointer).
4240	4527		/// For other optionals, builds a tagged aggregate with tag set to `0` (absent).
4241	4528		fn buildNilOptional(self: *mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {
4242	4529		let case resolver::Type::Optional(inner) = optType
4243	4530		else throw LowerError::ExpectedOptional;
4244		-	if let case resolver::Type::Pointer { .. } = *inner {
	4531	+	if let case resolver::Type::Pointer(_) = *inner {
4245	4532		return il::Val::Imm(0);
4246	4533		}
4247		-	if let case resolver::Type::Slice { item, mutable, .. } = *inner {
	4534	+	if let case resolver::Type::Slice(slice) = *inner {
4248	4535		return try buildSliceValue(
4249		-	self, item, mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
	4536	+	self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)
4250	4537		);
4251	4538		}
4252	4539		let valOffset = resolver::getOptionalValOffset(*inner) as i32;
4253	4540		return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);
4254	4541		}

4274	4561		mutable: bool,
4275	4562		ptrVal: il::Val,
4276	4563		lenVal: il::Val,
4277	4564		capVal: il::Val
4278	4565		) -> il::Val throws (LowerError) {
4279		-	let sliceType = resolver::Type::Slice {
	4566	+	let sliceType = resolver::Type::Slice(resolver::SliceType {
4280	4567		class: types::PointerClass::Unsafe,
4281	4568		item: elemTy,
4282	4569		mutable,
4283		-	};
	4570	+	});
4284	4571		let dst = try emitReserve(self, sliceType);
4285		-	let ptrTy = resolver::Type::Pointer {
	4572	+	let ptrTy = resolver::Type::Pointer(resolver::PointerType {
4286	4573		class: types::PointerClass::Unsafe,
4287	4574		target: elemTy,
4288	4575		mutable,
4289		-	};
	4576	+	});
4290	4577
4291	4578		try emitStore(self, dst, SLICE_PTR_OFFSET, ptrTy, ptrVal);
4292	4579		try emitStore(self, dst, SLICE_LEN_OFFSET, resolver::Type::U32, lenVal);
4293	4580		try emitStore(self, dst, SLICE_CAP_OFFSET, resolver::Type::U32, capVal);
4294	4581

4300	4587		self: *mut FnLowerer,
4301	4588		dataVal: il::Val,
4302	4589		traitInfo: *resolver::TraitType,
4303	4590		inst: *resolver::InstanceEntry
4304	4591		) -> il::Val throws (LowerError) {
4305		-	let vName = vtableName(self.low, inst.moduleId, inst.concreteTypeName, traitInfo.name);
	4592	+	let vName = vtableName(
	4593	+	self.low, inst.concreteType, traitInfo
	4594	+	);
4306	4595
4307	4596		// Reserve space for the trait object on the stack.
4308	4597		let slot = emitReserveLayout(self, resolver::Layout {
4309	4598		size: resolver::PTR_SIZE * 2,
4310	4599		alignment: resolver::PTR_SIZE,

4472	4761		mutable: bool,
4473	4762		a: il::Reg,
4474	4763		b: il::Reg,
4475	4764		offset: i32
4476	4765		) -> il::Val throws (LowerError) {
4477		-	let ptrTy = resolver::Type::Pointer {
	4766	+	let ptrTy = resolver::Type::Pointer(resolver::PointerType {
4478	4767		class: types::PointerClass::Unsafe,
4479	4768		target: elemTy,
4480	4769		mutable,
4481		-	};
	4770	+	});
4482	4771		let ptrEq = try emitEqAtOffset(self, a, b, offset + SLICE_PTR_OFFSET, ptrTy);
4483	4772		let lenEq = try emitEqAtOffset(self, a, b, offset + SLICE_LEN_OFFSET, resolver::Type::U32);
4484	4773
4485	4774		return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, ptrEq, lenEq);
4486	4775		}

4725	5014		a: il::Reg,
4726	5015		b: il::Reg,
4727	5016		offset: i32
4728	5017		) -> il::Val throws (LowerError) {
4729	5018		match typ {
4730		-	case resolver::Type::Slice { item, mutable, .. } =>
4731		-	return try lowerSliceEq(self, item, mutable, a, b, offset),
	5019	+	case resolver::Type::Slice(slice) =>
	5020	+	return try lowerSliceEq(self, slice.item, slice.mutable, a, b, offset),
4732	5021		case resolver::Type::Optional(inner) => {
4733		-	if let case resolver::Type::Slice { item, mutable, .. } = *inner {
	5022	+	if let case resolver::Type::Slice(slice) = *inner {
4734	5023		// Optional slices use null pointer optimization.
4735		-	return try lowerSliceEq(self, item, mutable, a, b, offset);
	5024	+	return try lowerSliceEq(self, slice.item, slice.mutable, a, b, offset);
4736	5025		}
4737	5026		return try lowerOptionalEq(self, *inner, a, b, offset);
4738	5027		}
4739	5028		case resolver::Type::Array(arr) =>
4740	5029		return try lowerArrayEq(self, arr, a, b, offset),

4942	5231		range: ast::Range,
4943	5232		info: resolver::SliceRangeInfo
4944	5233		) -> SliceRangeResult throws (LowerError) {
4945	5234		let baseVal = try lowerExpr(self, container);
4946	5235		let baseReg = emitValToReg(self, baseVal);
	5236	+	let itemType = specializeType(self, *info.itemType, container);
4947	5237
4948	5238		// Extract data pointer and container length.
4949	5239		let mut dataReg = baseReg;
4950	5240		let mut containerLen: il::Val = undefined;
4951	5241		if let cap = info.capacity { // Slice from array.

4983	5273		// Only compute range offset and count if the start value is not
4984	5274		// statically known to be zero.
4985	5275		if startVal <> il::Val::Imm(0) {
4986	5276		// Offset the data pointer by the start value.
4987	5277		set dataReg = emitElem(
4988		-	self, resolver::getTypeLayout(*info.itemType).size, dataReg, startVal
	5278	+	self, resolver::getTypeLayout(itemType).size, dataReg, startVal
4989	5279		);
4990	5280		// Compute the count as `end - start`.
4991	5281		let lenReg = nextReg(self);
4992	5282		emit(self, il::Instr::BinOp {
4993	5283		op: il::BinOp::Sub,