// Build qualified function name for multi-module compilation.

    let qualName = qualifyName(self, nil, name);

    // Register function symbol for cross-package call resolution.

        registerSymbolName(self, sym, qualName);

    }

    let variableSlots = variableStorage(functionArena, data.localCount);

    let parent: 'function = &mut *self, arena = &mut *functionArena, variables = &mut variableSlots[..] where 'phase: 'function in {

        let mut fnLow = fnLowerer(parent, node, fnType, qualName, arena, variables);

    traitNameNode: *ast::Node,

    targetTypeNode: *ast::Node,

    methods: *[*ast::Node]

) -> InstanceCursor throws (LowerError) where 'arena: 'phase {

    // Look up the trait and type from the resolver.

        else throw LowerError::MissingSymbol(traitNameNode);

    let case resolver::SymbolData::Trait(traitInfo) = traitSym.data

        else throw LowerError::MissingMetadata;

        else throw LowerError::MissingSymbol(targetTypeNode);

    // Lower each instance method as a regular function.

    // Collect qualified names for the v-table. Empty entries are filled

    // later from inherited supertrait methods.

) -> ?*unsafe il::Fn throws (LowerError) where 'arena: 'phase {

    let data = resolver::nodeData(self.resolver, node);

    let case resolver::Type::Fn(fnType) = data.ty else {

        throw LowerError::ExpectedFunction;

    };

    registerSymbolName(self, sym, qualName);

    let variableSlots = variableStorage(functionArena, data.localCount);

    let parent: 'function = &mut *self, arena = &mut *functionArena, variables = &mut variableSlots[..] where 'phase: 'function in {

        let mut fnLow = fnLowerer(parent, node, fnType, qualName, arena, variables);

    receiverName: *ast::Node,

    sig: ast::FnSig,

    body: *ast::Node,

    functionArena: &mut alloc::Arena,

) -> ?*unsafe il::Fn throws (LowerError) where 'arena: 'phase {

        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;

    node: *ast::Node,

    value: *ast::Node,

    readOnly: bool

) throws (LowerError) where 'arena: 'phase {

    let data = resolver::nodeData(self.resolver, node);

        throw LowerError::MissingSymbol(node);

    };

    if data.ty == resolver::Type::Unknown {

        throw LowerError::MissingType(node);

    }

            }

        }

    }

    // Function pointer references in constant data.

    if let case resolver::Type::Fn(_) = ty {

            else throw LowerError::MissingSymbol(node);

        let modId = resolver::moduleIdForSymbol(self.resolver, sym);

        let qualName = qualifyName(self, modId, sym.name);

        dataBuilderPush(b, il::DataValue {

            item: il::DataItem::Fn(qualName), count: 1,

        });

        return;

    }

    // In constant data, a void variant of a mixed union still occupies the

    // full tagged-union slot. Emitting only the tag corrupts following fields.

        if let case resolver::SymbolData::Variant { type: resolver::Type::Void, .. } = sym.data {

            if let case resolver::Type::Nominal(resolver::NominalType::Union(_)) = ty {

                try lowerConstUnionVariantInto(self, node, sym, ty, &mut [], dataPrefix, b);

                return;

            }

        case ast::NodeValue::ArrayRepeatLit(repeat) =>

            try lowerConstArrayRepeatInto(self, repeat, ty, dataPrefix, b),

        case ast::NodeValue::RecordLit(recLit) =>

            try lowerConstRecordLitInto(self, node, recLit, ty, dataPrefix, b),

        case ast::NodeValue::Call(call) => {

                else throw LowerError::MissingSymbol(call.callee);

            match calleeSym.data {

                case resolver::SymbolData::Variant { .. } =>

                    try lowerConstUnionVariantInto(self, node, calleeSym, ty, call.args, dataPrefix, b),

                case resolver::SymbolData::Type(resolver::NominalType::Record(recInfo)) => {

        case ast::NodeValue::AddressOf(addr) => {

            try lowerConstAddressSliceInto(self, addr, ty, dataPrefix, b);

        }

        case ast::NodeValue::Ident(_) => {

            // Identifier referencing a constant.

                else throw LowerError::MissingSymbol(node);

            let case ast::NodeValue::ConstDecl(decl) = sym.node.value

                else throw LowerError::MissingConst(node);

            try lowerConstDataPayloadInto(self, decl.value, ty, dataPrefix, b);

        },

        case ast::NodeValue::ScopeAccess(_) => {

                else throw LowerError::MissingSymbol(node);

            if let case ast::NodeValue::ConstDecl(decl) = sym.node.value {

                try lowerConstDataPayloadInto(self, decl.value, ty, dataPrefix, b);

            } else {

                try lowerConstScalarDataInto(self, node, ty, dataPrefix, b);

        }

        case resolver::Type::Nominal(resolver::NominalType::Union(_)) => {

            let typeName = recLit.typeName else {

                throw LowerError::ExpectedVariant;

            };

                throw LowerError::MissingSymbol(typeName);

            };

            try lowerConstUnionVariantInto(self, node, sym, ty, recLit.fields, dataPrefix, b);

        }

        else => throw LowerError::ExpectedRecord,

    return try nextDeclDataName(self.low, fnName, counter, "literal");

}

/// Assign a unique function-local data symbol name.

unsafe fn registerLocalDataDeclName 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) throws (LowerError) where 'arena: 'phase, 'phase: 'function {

        else throw LowerError::MissingSymbol(node);

    let prefix = self.fnName;

    let segments = [prefix, "nominal", sym.name];

    let name = try buildSegmentedName(self.low, &segments[..]);

    return ty;

}

/// Look up the symbol for an AST node, or throw `MissingSymbol`.

fn symOf 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, node: *ast::Node) -> *unsafe mut resolver::Symbol throws (LowerError) where 'arena: 'phase, 'phase: 'function {

        else throw LowerError::MissingSymbol(node);

    return sym;

}

/// Remove the last block parameter and its associated variable.

    let data = resolver::nodeData(res, node);

    // Optional equality checks both the presence tag and the union value.

    if let case resolver::Coercion::OptionalLift(_) = data.coercion {

        return nil;

    }

        return nil;

    };

    let case resolver::SymbolData::Variant { type: payloadType, index, .. } = sym.data else {

        return nil;

    };

        return il::Val::Reg(ptr);

    }

    // A qualified constant or static uses its resolved owner's data symbol.

    if let case ast::NodeValue::ScopeAccess(_) = addr.target.value {

            throw LowerError::MissingSymbol(addr.target);

        };

        return il::Val::Reg(emitDataAddr(self, sym));

    }

    // Handle variable address: `&x`

            defVar(self, v, stackVal);

            return stackVal;

        }

        // Fall back to symbol lookup for constants/statics.

            return il::Val::Reg(emitDataAddr(self, sym));

        } else {

            throw LowerError::MissingSymbol(node);

        }

    }

    // If the resolver determined that this variable's address is taken

    // anywhere in the function, allocate a stack slot immediately so the

    // SSA value is always a pointer. This avoids mixing integer and pointer

    // values in loop phis when `&var` or `&mut var` appears inside a loop.

    if not isAggregateType(typ) {

            if let case resolver::SymbolData::Value { addressTaken, .. } = sym.data; addressTaken {

                let layout = resolver::getLayout(self.low.resolver, node, typ);

                let slot = emitReserveLayout(self, layout);

                try emitStore(self, slot, 0, typ, varVal);

    }

    // Check for standalone method call.

    if let case resolver::NodeExtra::MethodCall { method } = nodeData {

        return try lowerMethodCall(self, node, call, method);

    }

        if let case resolver::SymbolData::Type(_) = sym.data {

            let ty = try typeOf(self, node);

            let case resolver::Type::Nominal(nominal) = ty else throw LowerError::ExpectedRecord;

            return try lowerRecordCtor(self, nominal, call.args);

        }

}

/// Check if a call is to a compiler intrinsic and lower it directly.

unsafe fn lowerIntrinsicCall 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, call: ast::Call) -> ?il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    // Get the callee symbol and check if it's marked as an intrinsic.

        // Expressions or function pointers may not have an associated symbol.

        return nil;

    };

    if not ast::hasAttribute(sym.attrs, ast::Attribute::Intrinsic) {

        return nil;

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

unsafe fn lowerCallee 'arena 'phase 'function (self: &mut FnLowerer 'arena 'phase 'function, callee: *ast::Node) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {

        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.

            if let qualName = lookupSymbolName(self.low, sym.id) {

    if let constVal = resolver::constValueEntry(self.low.resolver, node) {

        return try constValueToVal(self, constVal, node);

    }

    // Otherwise get the associated symbol.

    let data = resolver::nodeData(self.low.resolver, node);

        throw LowerError::MissingSymbol(node);

    };

    match sym.data {

        case resolver::SymbolData::Variant { index, .. } => {

            let mut indexValue = index as i64;

    SliceAppend { elemType: *Type },

    /// Slice `.delete(index)` method call.

    SliceDelete { elemType: *Type },

}

/// Combined resolver metadata for a single AST node.

export record NodeData: Copy {

    /// Number of local bindings and internal iteration variables in this function.

    localCount: u32,

    /// Resolved type for this node.

    ty: Type,

    /// Coercion plan applied to this node.

    coercion: Coercion,

    /// Constant value for literal nodes.

    constValue: ?ConstValue,

    /// Lexical scope owned by this node.

    scope: ?*unsafe mut Scope,

    /// Node-specific extra data.

    for i in 0..nodeData.len {

        set nodeData[i] = NodeData {

            localCount: 0,

            ty: Type::Unknown,

            coercion: Coercion::Identity,

            constValue: nil,

            scope: nil,

            extra: NodeExtra::None,

        };

    }

        else throw emitError(self, node, ErrorKind::ExpectedIdentifier);

    return name;

}

/// Associate a resolved symbol with an AST node.

        panic "setNodeSymbol: a symbol is already associated with this node";

    }

}

/// Associate a resolved type with an AST node and return it.

fn setNodeType 'arena (self: &mut Resolver 'arena, node: *ast::Node, ty: Type) -> Type {

    if ty == Type::Unknown {

    return self.nodeData.entries[node.id].scope;

}

/// Get the symbol bound to a node.

export fn symbolFor 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?*unsafe mut Symbol {

}

/// Get the coercion plan associated with a node, if any.

export fn coercionFor 'arena (self: &Resolver 'arena, node: *ast::Node) -> ?Coercion {

    let c = self.nodeData.entries[node.id].coercion;

        }

        case ast::NodeValue::ScopeAccess(_) => {

            // Module-qualified access to a top-level symbol. A `static`

            // binds as a mutable value; a `constant` does not.

            let _ = try infer(self, node);

                else return false;

            if let case SymbolData::Value { mutable, .. } = sym.data {

                return mutable;

            }

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

    set env.len += 1;

}

/// Mark a tracked binding as uninitialized.

    set env.available &= ~((1 as u64) << (index as u64));

}

/// Require exact-use bindings introduced after `start` to be consumed.

fn finishLinearScope 'arena 'checking (

    }

    set env.len = start;

}

/// Require a tracked identifier to remain available for any access.

    checker: &mut LinearChecker 'arena 'checking,

    env: &mut LinearEnv,

    node: *ast::Node,

) throws (ResolveError) where 'arena: 'checking {

    if not linearBindingAvailable(env, index) {

            else ErrorKind::AffineUseAfterMove(sym.name);

        throw emitError(checker.resolver, node, kind);

    }

}

/// Move or consume a tracked identifier once.

    checker: &mut LinearChecker 'arena 'checking,

    env: &mut LinearEnv,

    node: *ast::Node,

) throws (ResolveError) where 'arena: 'checking {

    try checkLinearIdent(checker, env, node);

    set env.available &= ~((1 as u64) << (index as u64));

}

/// Merge ownership availability across two live branches.

/// Validate both inputs before writing to an output that can alias either input.

        let first = resolver::symbolFor(&res, block.statements[0]) else throw testing::TestError::Failed;

        let second = resolver::symbolFor(&res, block.statements[1]) else throw testing::TestError::Failed;

        assert first.id <> second.id;

        assert first.id < res.symbolCount;

        assert second.id < res.symbolCount;

    }

}

/// Short-circuit paths must agree on exact-use regional ownership.

@test unsafe fn testRegionalShortCircuitOwnership() throws (testing::TestError) {