radiance · commit

lang: Prepare linear ownership

d45ecf680cc1334a65f235c26e2f358d20ae5b77156d8731d90c11a04e8f0b66

Alexis Sellier committed 1 month ago 1 parent 8ed9e8cc

compiler/radiance.rad +2 -2


/// AST arena size (32 MB) - retains parsed nodes throughout compilation.
constant TEMP_ARENA_SIZE: u32 = 33554432;
/// 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 (96 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 = 100663296;

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

lib/std/lang/resolver.rad +1665 -279

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 number of linear bindings active in one function.
constant MAX_LINEAR_BINDINGS: u32 = 32;
/// Maximum nesting depth tracked for loops.
constant MAX_LINEAR_LOOP_DEPTH: u32 = 16;

/// Trait definition stored in the resolver.
export record TraitType {
    /// Trait name.
    name: *[u8],

    name: *[u8],
    /// Function type for the method, excluding the receiver.
    fnType: *FnType,
    /// Whether the receiver is mutable.
    mutable: bool,
    /// Pointer-like class used by the receiver.
    receiverClass: types::PointerClass,
    /// V-table slot index.
    index: u32,
}

/// An entry in the trait instance registry.

    name: *[u8],
    /// Function type excluding the receiver.
    fnType: *FnType,
    /// Whether the receiver is mutable.
    mutable: bool,
    /// Pointer-like class used by the receiver.
    receiverClass: types::PointerClass,
    /// Symbol for the method.
    symbol: *mut Symbol,
}

/// Identifier for the synthetic `len` field.

export record RecordType {
    fields: *[RecordField],
    labeled: bool,
    /// Cached layout.
    layout: Layout,
    /// Whether the declaration explicitly carries the `Linear` marker.
    declaredLinear: bool,
}

/// Union nominal type.
export record UnionType {
    variants: *[UnionVariant],

    layout: Layout,
    /// Cached payload offset within the union aggregate.
    valOffset: u32,
    /// If all variants have void payloads.
    isAllVoid: bool,
    /// Whether the declaration explicitly carries the `Linear` marker.
    declaredLinear: bool,
}

/// Metadata for user-defined types.
export union NominalType {
    /// Placeholder for a type that hasn't been fully resolved yet.

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

/// Describes a type computed during semantic analysis.
export union Type {

    /// Range types, eg. `start..end`.
    Range {
        start: ?*Type,
        end: ?*Type,
    },
    /// Pointer-like address.
    /// Owning pointer-like address.
    Pointer {
        class: types::PointerClass,
        target: *Type,
        mutable: bool,
    },
    /// Pointer-like slice.
    /// Owning slice.
    Slice {
        class: types::PointerClass,
        item: *Type,
        mutable: bool,
    },

    Optional(*Type),
    /// Eg. `fn id(i32) -> i32`.
    Fn(*FnType),
    /// Named, ie. user-defined types, includes union variants.
    Nominal(*NominalType),
    /// An erased pointer-like type with a v-table.
    /// Owning trait object. An erased type with v-table.
    TraitObject {
        /// Ownership and safety class.
        class: types::PointerClass,
        /// Trait definition.
        traitInfo: *TraitType,

    MissingTraitMethod(*[u8]),
    /// Trait name used as a value expression.
    UnexpectedTraitName,
    /// Trait method receiver does not point to the declaring trait.
    TraitReceiverMismatch,
    /// Trait declaration and instance disagree about unsafe call requirements.
    TraitMethodSafetyMismatch,
    /// Function declaration has too many parameters.
    FnParamOverflow(CountMismatch),
    /// Function declaration has too many throws.
    FnThrowOverflow(CountMismatch),
    /// Trait declaration has too many methods.
    TraitMethodOverflow(CountMismatch),
    /// Instance declaration is missing a required supertrait instance.
    MissingSupertraitInstance(*[u8]),
    /// Linear binding was consumed more than once.
    LinearUseAfterConsume(*[u8]),
    /// Linear binding remains available at an exit.
    LinearNotConsumed(*[u8]),
    /// A case-pattern `let-else` fallback must terminate control flow.
    LinearLetElseMustTerminate,
    /// Branches disagree about a linear binding's state.
    LinearBranchMismatch(*[u8]),
    /// A linear field cannot be moved independently.
    LinearPartialMove,
    /// A linear value cannot be discarded.
    LinearDiscard,
    /// Assignment would overwrite a live linear value.
    LinearOverwrite,
    /// `undefined` cannot initialize a linear type.
    LinearUndefined,
    /// A reference appears in a storable or escaping position.
    InvalidRefPosition,
    /// A reference cannot be bound to a local.
    RefBinding,
    /// Call arguments contain overlapping incompatible loans.
    BorrowConflict(*[u8]),
    /// Unsafe pointer operation outside an `unsafe` declaration.
    UnsafeOperation,
    /// Safe code cannot call an `unsafe` function.
    UnsafeCall,
    /// Internal error.
    Internal,
}

/// Diagnostics returned by the analyzer.

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

/// How an expression uses a linear result.
union LinearUse {
    /// Consume the value and end its availability.
    Consume,
    /// Read the value without consuming it.
    Observe,
    /// Borrow the value through a reference.
    Borrow,
    /// Discard an unused expression result.
    Discard,
    /// Use the value as an assignment target.
    Place,
}

/// Per-control-flow-path ownership state.
record LinearEnv {
    /// Symbols tracked on this control-flow path.
    symbols: [?*mut Symbol; MAX_LINEAR_BINDINGS],
    /// Bit set for each binding that remains available.
    available: u64,
    /// Number of entries in `symbols`.
    len: u32,
    /// Whether this control-flow path has terminated.
    terminated: bool,
}

/// Function-local exact-use checker state.
record LinearChecker {
    /// Resolver that owns the symbols and diagnostics.
    resolver: *mut Resolver,
    /// Binding count at entry to each active loop.
    loopMarks: [u32; MAX_LINEAR_LOOP_DEPTH],
    /// Available bindings at entry to each active loop.
    loopAvailable: [u64; MAX_LINEAR_LOOP_DEPTH],
    /// Available bindings shared by the exits from each active loop.
    loopExitAvailable: [u64; MAX_LINEAR_LOOP_DEPTH],
    /// Whether each active loop can exit without `break`.
    loopHasNaturalExit: [bool; MAX_LINEAR_LOOP_DEPTH],
    /// Whether each active loop contains a reachable `break`.
    loopBreakSeen: [bool; MAX_LINEAR_LOOP_DEPTH],
    /// Number of active loops.
    loopDepth: u32,
}

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

    loopDepth: u32,
    /// Signature of the function currently being analyzed.
    currentFn: ?*FnType,
    /// Current module being analyzed.
    currentMod: u16,
    /// Nesting depth of unsafe modules and function bodies.
    unsafeDepth: u32,
    /// Configuration for semantic analysis.
    config: Config,
    /// Unified arena for symbols, scopes, and nominal type.
    arena: alloc::Arena,
    /// Combined semantic metadata table indexed by node ID.

        pkgScope: storage.pkgScope,
        loopStack: undefined,
        loopDepth: 0,
        currentFn: nil,
        currentMod: 0,
        unsafeDepth: 0,
        config,
        arena,
        nodeData: NodeDataTable { entries: storage.nodeData },
        types: nil,
        errors: @sliceOf(storage.errors.ptr, 0, storage.errors.len),

}

/// 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 { .. } =>
            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 },
        case Type::Int => return Layout { size: 8, alignment: 8 },
        case Type::U64, Type::I64 => return Layout { size: 8, alignment: 8 },
        case Type::Pointer { .. },
             Type::Fn(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::Slice { .. },
             Type::TraitObject { .. } => return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
        case Type::Fn(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::Array(arr) => return getArrayLayout(arr),
        case Type::Optional(inner) => return getOptionalLayout(*inner),
        case Type::Nominal(info) => return getNominalLayout(*info),
        else => {
            panic "getTypeLayout: the given type cannot be layed out";

    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::Pointer { .. }, Type::Slice { .. }, Type::Fn(_) => return true,
        case 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::Array(arr) => try ensureTypeResolved(self, *arr.item, site),
        case Type::Slice { item, .. } => try ensureTypeResolved(self, *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 => {},
    }
}


        }
    }
    return true;
}

/// Return whether pointer classes are compatible.
fn pointerClassesAssignable(
    to: types::PointerClass,
    from: types::PointerClass,
) -> bool {
    return to == from or (
        to == types::PointerClass::Owned
        and from == types::PointerClass::Ref
    );
}

/// Check if the `from` type is assignable to the `to` type, and return a
/// coercion plan if so.
fn isAssignable(self: *mut Resolver, to: Type, from: Type, rval: *ast::Node) -> ?Coercion {
    if to == Type::Unknown or from == Type::Unknown {
        return nil;

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


                    }
                    return nil;
                }
            }
        }
        case Type::Pointer { target: lhsTarget, mutable: lhsMutable, .. } => {
            let case Type::Pointer { target: rhsTarget, mutable: rhsMutable, .. } = from
                else return nil;

            // Allow coercion from `*T` to `*opaque`, and `*mut T` to `*mut opaque`.
            if *lhsTarget == Type::Opaque {
                if lhsMutable and not rhsMutable {
                    return nil;
                }
                return Coercion::Identity;
            }
            if lhsMutable and not rhsMutable {
                return nil;
            }
            return isAssignable(self, *lhsTarget, *rhsTarget, rval);
        }
        case Type::Optional(inner) => {
            if from == Type::Nil {
                return Coercion::OptionalLift(to);
            }
            if let _ = isAssignable(self, *inner, from, rval) {

            if let case Type::Optional(fromInner) = from {
                return isAssignable(self, *inner, *fromInner, rval);
            }
            return nil;
        }
        case Type::TraitObject {
            class: lhsClass, traitInfo, mutable: lhsMutable,
        } => {
            // Coerce `*T` or `*mut T` where `T` implements the trait.
            if let case Type::Pointer { target, mutable: rhsMutable, .. } = from {
                if lhsMutable and not rhsMutable {
                    return nil;
                }
                // Look up instance registry.
                if let inst = findInstance(self, traitInfo, *target) {
                    return Coercion::TraitObject { traitInfo, inst };
                }
            }
            // Identity: same trait object.
            if let case Type::TraitObject {
                class: rhsClass, traitInfo: rhsTrait, mutable: rhsMutable,
            } = from {
                if lhsClass <> rhsClass or traitInfo <> rhsTrait {
                    return nil;
                }
                if lhsMutable and not rhsMutable {
                    return nil;
                }
                return Coercion::Identity;
            }
            return nil;
        }
        case Type::Slice { class: lhsClass, item: lhsItem, mutable: lhsMutable } => {
            match from {
                case Type::Slice { class: rhsClass, item: rhsItem, mutable: rhsMutable } => {
                    if lhsClass <> rhsClass {
                        return nil;
                    }
                    if lhsMutable and not rhsMutable {
                        return nil;
                    }
                    // Allow coercion from `*[T]` to `*[opaque]`, and `*mut [T]` to `*mut [opaque]`.
                    if *lhsItem == Type::Opaque {
                        return Coercion::Identity;
                    }
                    return isAssignable(self, *lhsItem, *rhsItem, rval);
                }
                else => return nil,
            }
        }

        case Type::Fn(toInfo) => {
            // Allow function type structural matching.
            if let case Type::Fn(fromInfo) = from {
                if fnTypeEqual(toInfo, fromInfo) {
                    return Coercion::Identity;

    return nil;
}

/// Check if two function type descriptors are structurally equivalent.
fn fnTypeEqual(a: *FnType, b: *FnType) -> bool {
    if a.isUnsafe <> b.isUnsafe {
        return false;
    }
    if a.paramTypes.len <> b.paramTypes.len {
        return false;
    }
    if a.throwList.len <> b.throwList.len {
        return false;

/// 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::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::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;
    }
    match a {
        case Type::Pointer { class: aClass, target: aTarget, mutable: aMutable } => {
            let case Type::Pointer { class: bClass, target: bTarget, mutable: bMutable } = b
                else return false;
            return aClass == bClass and aMutable == bMutable and typesEqual(*aTarget, *bTarget);
        }
        case Type::Slice { class: aClass, item: aItem, mutable: aMutable } => {
            let case Type::Slice { class: bClass, item: bItem, mutable: bMutable } = b
                else return false;
            return aClass == bClass and aMutable == bMutable and typesEqual(*aItem, *bItem);
        }
        case Type::Array(aa) => {
            let case Type::Array(ab) = b else return false;
            return aa.length == ab.length and typesEqual(*aa.item, *ab.item);
        }
        case Type::Optional(oa) => {

        }
        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,
        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::Slice { item, .. } = ty {
        return containsRef(*item);
    }
    match ty {
        case Type::Array(array) => return containsRef(*array.item),
        case Type::Optional(inner) => return containsRef(*inner),
        // 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::Array(array) => return isLinear(*array.item),
        case Type::Optional(inner) => return isLinear(*inner),
        case Type::Nominal(NominalType::Record(recInfo)) => {
            if recInfo.declaredLinear {
                return true;
            }
            for field in recInfo.fields {
                if isLinear(field.fieldType) {
                    return true;
                }
            }
            return false;
        }
        case Type::Nominal(NominalType::Union(unionType)) => {
            if unionType.declaredLinear {
                return true;
            }
            for variant in unionType.variants {
                if isLinear(variant.valueType) {
                    return true;
                }
            }
            return false;
        }
        else => return false,
    }
}

/// 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,
        else => return false,
    }
}

/// Get the record info from a record type.
export fn getRecord(ty: Type) -> ?RecordType {
    let case Type::Nominal(NominalType::Record(recInfo)) = ty else return nil;
    return recInfo;
}

    return ty;
}

/// Get field info for a record-like type (records, slices) by field index.
export fn getRecordField(ty: Type, index: u32) -> ?RecordField {
    match ty {
        case Type::Nominal(NominalType::Record(recInfo)) => {
            if index >= recInfo.fields.len {
                return nil;
            }
            return recInfo.fields[index];
        }
        case Type::Slice { item, mutable, .. } => {
            match index {
                case 0 => return RecordField {
                    name: PTR_FIELD,
                    fieldType: Type::Pointer {
                        class: types::PointerClass::Owned, target: item, mutable,
                    },
                    offset: 0,
                },
                case 1 => return RecordField {
                    name: LEN_FIELD,
                    fieldType: Type::U32,
                    offset: PTR_SIZE as i32,
                },
                case 2 => return RecordField {
                    name: CAP_FIELD,
                    fieldType: Type::U32,
                    offset: PTR_SIZE as i32 + 4,
                },
                else => return nil,
            }
        }
        else => return nil,
    if let case Type::Slice { class, item, mutable } = ty {
        match index {
            case 0 => return RecordField {
                name: PTR_FIELD,
                fieldType: Type::Pointer { class, target: item, mutable },
                offset: 0,
            },
            case 1 => return RecordField {
                name: LEN_FIELD,
                fieldType: Type::U32,
                offset: PTR_SIZE as i32,
            },
            case 2 => return RecordField {
                name: CAP_FIELD,
                fieldType: Type::U32,
                offset: PTR_SIZE as i32 + 4,
            },
            else => return nil,
        }
    }
    if let case Type::Nominal(NominalType::Record(recInfo)) = ty;
        index < recInfo.fields.len
    {
        return recInfo.fields[index];
    }
    return nil;
}

/// Check if the two types can be compared for equality.
fn isComparable(left: Type, right: Type) -> bool {
    if left == Type::Unknown or right == Type::Unknown {

    scope: *Scope
) -> *mut Symbol throws (ResolveError) {
    assert path.len <> 0, "resolvePath: empty path";
    // Start by finding the root of the path.
    let root = path[0];
    let sym = findInScopeRecursive(scope, root, isAnySymbol) else
        throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));
    let sym = findInScopeRecursive(scope, root, isAnySymbol)
        else throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));
    let suffix = &path[1..];

    // Check visibility for symbol.
    if not isSymbolVisible(sym, scope, self.scope) {
        throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));

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

/// Visit a top-level definition, recursing into sub-modules.
fn visitDef(self: *mut Resolver, node: *ast::Node) throws (ResolveError) {
    match node.value {
        case ast::NodeValue::FnDecl(decl) => {
            try resolveFnDeclBody(self, node, decl) catch {

            }
            let modName = try nodeName(self, decl.name);
            let submod = try enterSubModule(self, modName, node);
            let case ast::NodeValue::Block(block) = submod.root.value
                else panic "visitDef: expected block for module root";
            try resolveModuleDefs(self, &block);
            let mut isUnsafe = false;
            if let attrs = decl.attrs {
                set isUnsafe = ast::attributesContains(&attrs, ast::Attribute::Unsafe);
            }
            if isUnsafe {
                set self.unsafeDepth += 1;
            }
            try resolveModuleDefs(self, &block) catch e {
                if isUnsafe { set self.unsafeDepth -= 1; }
                exitModuleScope(self, submod);
                throw e;
            };
            if isUnsafe {
                set self.unsafeDepth -= 1;
            }
            exitModuleScope(self, submod);
        }
        case ast::NodeValue::RecordDecl(_),
             ast::NodeValue::UnionDecl(_),
             ast::NodeValue::Use(_),

/// Try to infer a node's type.
fn infer(self: *mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
    return try visit(self, node, Type::Unknown);
}

/// 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) {
                throw emitError(self, node, ErrorKind::InvalidRefPosition);
            }
        } else if let case Type::Slice { item, .. } = ty {
            if containsRef(*item) {
                throw emitError(self, node, ErrorKind::InvalidRefPosition);
            }
        }
    } else if containsRef(ty) {
        throw emitError(self, node, ErrorKind::InvalidRefPosition);
    }
}

/// Require a type that may be stored or escape a call.
fn ensureStorableType(self: *mut Resolver, node: *ast::Node, ty: Type)
    throws (ResolveError)
{
    if containsRef(ty) {
        throw emitError(self, node, ErrorKind::InvalidRefPosition);
    }
}

/// Resolve a type signature node.
fn resolveValueType(self: *mut Resolver, node: *ast::Node) -> Type throws (ResolveError) {
    let ty = try visit(self, node, Type::Unknown);
    // Opaque value types are not allowed.
    if ty == Type::Opaque {
        throw emitError(self, node, ErrorKind::OpaqueTypeNotAllowed);
    }
    try validateValueTypeReferences(self, node, ty);
    return ty;
}

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

        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.
                class: types::PointerClass::Owned,
                item: allocType(self, Type::U8),
                mutable: false
                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.
                class: types::PointerClass::Owned,
                item: allocType(self, Type::U8),
                mutable: false
                mutable: false,
            });
            return setNodeType(self, node, Type::Void);
        },
        case ast::NodeValue::UnOp(unop) => return try resolveUnOp(self, node, unop),
        case ast::NodeValue::ExprStmt(expr) => {

        if not isTypeInferrable(bindingTy) {
            throw emitError(self, decl.value, ErrorKind::CannotInferType);
        }
    }
    // Variables cannot have void type.
    if containsRef(bindingTy) {
        throw emitError(self, node, ErrorKind::RefBinding);
    }
    if bindingTy == Type::Void {
        throw emitError(self, decl.value, ErrorKind::CannotAssignVoid);
    }
    // Variables cannot have opaque type directly.
    if bindingTy == Type::Opaque {

    attrList: ?ast::Attributes,
    isConst: bool
) -> Type throws (ResolveError) {
    let attrs = resolveAttributes(self, attrList);
    let bindingTy = try infer(self, typeNode);
    try ensureStorableType(self, typeNode, bindingTy);
    let valueTy = try checkAssignable(self, valueNode, bindingTy);

    if isConst {
        let mut constVal = constValueEntry(self, valueNode);
        if constVal == nil and not isConstExpr(self, valueNode) {

{
    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);
    }
    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),
        throwList: &[],
        isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
        localCount: 0,
    };
    // Enter the function scope to process parameters.
    enterFn(self, node, &fnType);


        let throwTy = try infer(self, throwNode) 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[..];


        panic "resolveFnDeclBody: unexpected symbol data for function";
    };
    let retTy = *fnType.returnType;
    let isExtern = ast::hasAttribute(sym.attrs, ast::Attribute::Extern);
    let isIntrinsic = ast::hasAttribute(sym.attrs, ast::Attribute::Intrinsic);
    let isUnsafe = fnType.isUnsafe;

    if let body = decl.body {
        if isIntrinsic {
            throw emitError(self, node, ErrorKind::IntrinsicUnexpectedBody);
        }
        if isExtern {
            throw emitError(self, node, ErrorKind::FnUnexpectedBody);
        }
        if isUnsafe {
            set self.unsafeDepth += 1;
        }
        enterFn(self, node, fnType); // Enter function scope for body analysis.

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


    let _ = try bindValueIdent(self, param.name, node, ty, false, 0, 0);

    return ty;
}

/// Resolve the compiler-known `Linear` marker from a derive list.
fn resolveLinearDerive(self: *mut Resolver, derives: *mut [*ast::Node]) -> bool
    throws (ResolveError)
{
    let mut linear = false;
    for derive in derives {
        let name = try nodeName(self, derive);
        if mem::eq(name, "Linear") {
            if linear {
                throw emitError(self, derive, ErrorKind::DuplicateBinding(name));
            }
            set linear = true;
        } else {
            // Resolve an ordinary trait derive.
            try infer(self, derive);
        }
    }
    return linear;
}

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

            field: fieldNode,
            type: typeNode,
            value: valueNode
        } = field.value else panic "resolveRecordFields: invalid record field";
        let fieldTy = try resolveValueType(self, typeNode);
        try ensureStorableType(self, typeNode, fieldTy);

        if let v = valueNode {
            let _valTy = try checkAssignable(self, v, fieldTy);
        }
        // Get field name for labeled records.

    // Compute cached layout.
    let recordLayout = Layout {
        size: mem::alignUp(currentOffset, maxAlignment),
        alignment: maxAlignment
    };
    return RecordType { fields: &result[..], labeled, layout: recordLayout };
    return RecordType {
        fields: &result[..],
        labeled,
        layout: recordLayout,
        declaredLinear: false,
    };
}

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


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

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

/// Bind a type name.

            }
            traitType.methods.append(TraitMethod {
                name: inherited.name,
                fnType: inherited.fnType,
                mutable: inherited.mutable,
                receiverClass: inherited.receiverClass,
                index: traitType.methods.len as u32,
            }, a);
        }
        traitType.supertraits.append(superTrait, a);
    }

            actual: traitType.methods.len as u32 + methods.len as u32,
        }));
    }

    for methodNode in methods {
        let case ast::NodeValue::TraitMethodSig { name, receiver, sig, .. } = methodNode.value
        let case ast::NodeValue::TraitMethodSig { name, receiver, sig, attrs } = methodNode.value
            else continue;
        let methodName = try nodeName(self, name);
        let attrMask = resolveAttributes(self, attrs);

        // Reject duplicate method names.
        if let _ = findTraitMethod(traitType, methodName) {
            throw emitError(self, name, ErrorKind::DuplicateBinding(methodName));
        }
        // Determine receiver mutability from the receiver type node
        // and validate that the receiver points to the declaring trait.
        // Determine the receiver class and mutability, and validate that it
        // points to the declaring trait.
        let case ast::NodeValue::TypeSig(typeSig) = receiver.value
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Pointer { mutable, valueType, .. } = typeSig
        let case ast::TypeSig::Pointer {
            class: receiverClass, valueType: receiverValueType, mutable,
        } = typeSig
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let case ast::NodeValue::TypeSig(innerSig) = valueType.value
        let case ast::NodeValue::TypeSig(innerSig) = receiverValueType.value
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Nominal(nameNode) = innerSig
            else throw emitError(self, receiver, ErrorKind::TraitReceiverMismatch);
        let receiverTargetName = try nodeName(self, nameNode);


        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: retType,
            throwList: &throwList[..],
            isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
            localCount: 0,
        };
        traitType.methods.append(TraitMethod {
            name: methodName,
            fnType: allocFnType(self, fnType),
            mutable,
            receiverClass,
            index: traitType.methods.len as u32,
        }, a);

        setNodeType(self, methodNode, Type::Void);
    }

    let mut covered: [bool; ast::MAX_TRAIT_METHODS] = [false; ast::MAX_TRAIT_METHODS];

    // Match each instance method to a trait method.
    for methodNode in methods {
        let case ast::NodeValue::MethodDecl {
            name, receiverName, receiverType, sig, body, ..
            name, receiverName, receiverType, sig, body, attrs,
        } = methodNode.value else continue;

        let methodName = try nodeName(self, name);
        let attrMask = resolveAttributes(self, attrs);

        // Find the matching trait method.
        let tm = findTraitMethod(traitInfo, methodName)
            else throw emitError(self, name, ErrorKind::UnresolvedSymbol(methodName));
        let instanceUnsafe = ast::hasAttribute(attrMask, ast::Attribute::Unsafe);
        if instanceUnsafe <> tm.fnType.isUnsafe {
            throw emitError(self, methodNode, ErrorKind::TraitMethodSafetyMismatch);
        }

        // Determine receiver mutability and validate receiver type.
        // The receiver must be `*Type` or `*mut Type`.
        let case ast::NodeValue::TypeSig(typeSig) = receiverType.value
            else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
        let case ast::TypeSig::Pointer { mutable: receiverMut, valueType, .. } = typeSig
        let case ast::TypeSig::Pointer {
            class: receiverClass, valueType, mutable: receiverMut,
        } = typeSig
            else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
        if receiverClass <> tm.receiverClass {
            throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
        }

        // Validate that the receiver type annotation matches the
        // concrete type from the instance declaration.
        let annotatedTy = try infer(self, valueType);
        if not typesEqual(annotatedTy, concreteType) {

        }

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

        // Validate that the instance method's signature matches the

        }
        let fnType = FnType {
            paramTypes: &paramTypes[..],
            returnType: tm.fnType.returnType,
            throwList: tm.fnType.throwList,
            isUnsafe: tm.fnType.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
        // must not pollute the enclosing scope.
        let fnTy = Type::Fn(allocFnType(self, fnType));
        let mName = try nodeName(self, name);
        let sym = allocSymbol(self, SymbolData::Value {
            mutable: false, alignment: 0, type: fnTy, addressTaken: false,
        }, mName, methodNode, 0);
        }, mName, methodNode, attrMask);

        setNodeSymbol(self, methodNode, sym);
        setNodeType(self, methodNode, fnTy);
        setNodeType(self, name, fnTy);


) throws (ResolveError) {
    let sym = symbolFor(self, node)
        else throw emitError(self, node, ErrorKind::Internal);
    let case SymbolData::Value { type: Type::Fn(fnType), .. } = sym.data
        else panic "resolveMethodBody: expected value symbol";
    let isUnsafe = fnType.isUnsafe;
    if isUnsafe {
        set self.unsafeDepth += 1;
    }

    // Enter function scope.
    enterFn(self, node, fnType);

    // Bind the receiver parameter.
    let receiverTy = *fnType.paramTypes[0];
    try bindValueIdent(self, receiverName, receiverName, receiverTy, false, 0, 0) catch e {
        exitFn(self);
        if isUnsafe { set self.unsafeDepth -= 1; }
        throw e;
    };
    // Bind the remaining parameters from the signature.
    for paramNode in sig.params {
        let paramTy = try infer(self, paramNode) catch e {
            exitFn(self);
            if isUnsafe { set self.unsafeDepth -= 1; }
            throw e;
        };
    }

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

/// Resolve a standalone method declaration (signature only).
/// Validates the receiver type and registers the method in the method table.
/// Extract the type name from a resolved receiver type node (`*T` or `*mut T`).
fn receiverTypeName(self: *mut Resolver, receiverType: *ast::Node) -> *[u8] throws (ResolveError) {
    let case ast::NodeValue::TypeSig(ast::TypeSig::Pointer { valueType, .. }) = receiverType.value

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

    return sym.name;
}

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

    attrs: ?ast::Attributes,
) throws (ResolveError) {
    // Resolve the receiver type: must be `*Type` or `*mut Type` pointing to a
    // nominal type.
    let fullReceiverTy = try infer(self, receiverType);
    let case Type::Pointer { target, mutable: receiverMut, .. } = fullReceiverTy
    let case Type::Pointer {
        class: receiverClass, target: receiverTarget, mutable: receiverMut,
    } = fullReceiverTy
        else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
    let concreteType = *target;
    let concreteType = *receiverTarget;
    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) {
        throw emitError(self, name, ErrorKind::DuplicateBinding(methodName));
    }

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

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


    }

    let retTypePtr = allocType(self, returnType);
    let throwList = &throwTypes[..];

    let isUnsafe = ast::hasAttribute(attrMask, ast::Attribute::Unsafe);
    // Full function type (receiver + params) for lowering.
    let fullFnType = FnType {
        paramTypes: &paramTypes[..], returnType: retTypePtr, throwList, localCount: 0,
        paramTypes: &paramTypes[..],
        returnType: retTypePtr,
        throwList,
        isUnsafe,
        localCount: 0,
    };
    let fnTy = Type::Fn(allocFnType(self, fullFnType));

    // Function type excluding receiver, for call arg checking.
    let checkFnType = FnType {
        paramTypes: &paramTypes[1..], returnType: retTypePtr, throwList, localCount: 0,
        paramTypes: &paramTypes[1..],
        returnType: retTypePtr,
        throwList,
        isUnsafe,
        localCount: 0,
    };

    // Compute attribute mask.
    let mut attrMask: u32 = 0;
    if let a = attrs {
        for attrNode in a.list {
            if let case ast::NodeValue::Attribute(attr) = attrNode.value {
                set attrMask = attrMask | (attr as u32);
            }
        }
    }

    // Create a symbol for the method without binding it into the module scope.
    let sym = allocSymbol(self, SymbolData::Value {
        mutable: false, alignment: 0, type: fnTy, addressTaken: false,
    }, methodName, node, attrMask);


        concreteType,
        concreteTypeName: typeName,
        name: methodName,
        fnType: allocFnType(self, checkFnType),
        mutable: receiverMut,
        receiverClass,
        symbol: sym,
    };
    set self.methodsLen += 1;
}


    let mut variants: *mut [UnionVariant] = &mut [];

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

    try visitList(self, decl.derives);

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

    set *nominalTy = NominalType::Union(UnionType {
        variants: &variants[..],
        layout: info.layout,
        valOffset: info.valOffset,
        isAllVoid: info.isAllVoid,
        declaredLinear,
    });
}

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

    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);
        return;
    }
    // TODO: Collapse these nested matches.
    match scrutineeTy {
        case Type::Pointer { target, .. } => {
            // Auto-deref: when the scrutinee is a pointer and the pattern
            // is a destructuring pattern, resolve against the pointed-to type.
            if isDestructuringPattern(pattern) {
                try resolveCasePattern(self, pattern, *target, mode, matchBy);
                return;
            }
        }
        case Type::Nominal(info) => {
            try ensureNominalResolved(self, info, pattern);

            match *info {
                case NominalType::Union(unionType) => {

        }
    }
    // 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;
            setForLoopInfo(self, node, ForLoopInfo::Collection {
                elemType: 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.
            let valType = start else {
                throw emitError(self, forStmt.iterable, ErrorKind::ExpectedIterable);

                length: arrayInfo.length,
                bindingName,
                indexName,
            });
        }
        case Type::Slice { item, .. } => {
            set itemTy = *item;
            setForLoopInfo(self, node, ForLoopInfo::Collection {
                elemType: item, length: nil, bindingName, indexName
            });
        }
        else => throw emitError(self, forStmt.iterable, ErrorKind::ExpectedIterable),
    }
    enterScope(self, node);
    try bindForLoopPattern(self, forStmt.binding, itemTy, false);


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

            });
        }
    }
}

/// Return whether a case pattern introduces value bindings.
fn casePatternIntroducesBindings(pattern: *ast::Node, nested: bool) -> bool {
    match pattern.value {
        case ast::NodeValue::Ident(_) => return nested,
        case ast::NodeValue::Call(call) => {
            for arg in call.args {
                if casePatternIntroducesBindings(arg, true) {
                    return true;
                }
            }
        }
        case ast::NodeValue::RecordLit(lit) => {
            for fieldNode in lit.fields {
                let case ast::NodeValue::RecordLitField(field) = fieldNode.value
                    else continue;
                if casePatternIntroducesBindings(field.value, true) {
                    return true;
                }
            }
        }
        case ast::NodeValue::ArrayLit(items) => {
            for item in items {
                if casePatternIntroducesBindings(item, true) {
                    return true;
                }
            }
        }
        else => {}
    }
    return false;
}

/// Analyze a `let-else` guard.
fn resolveLetElse(self: *mut Resolver, node: *ast::Node, letElse: ast::LetElse) -> Type
    throws (ResolveError)
{
    let pat = &letElse.pattern;

            let case Type::Optional(inner) = exprTy else {
                throw emitError(self, pat.scrutinee, ErrorKind::ExpectedOptional);
            };
            let payloadTy = *inner;
            let _ = try bindValueIdent(self, pat.pattern, node, payloadTy, pat.mutable, 0, 0);
            // The `else` branch must be assignable to the payload type.
            // The `else` branch supplies the binding when the optional is nil.
            try checkAssignable(self, letElse.elseBranch, payloadTy);

            return setNodeType(self, node, Type::Void);
        }
        case ast::PatternKind::Case => {
            // Analyze pattern against expression type.
            try resolveCasePattern(self, pat.pattern, exprTy, IdentMode::Compare, MatchBy::Value);
            // Resolve the failure path before introducing success-only bindings.
            let elseTy = try checkAssignable(self, letElse.elseBranch, exprTy);
            try resolveCasePattern(
                self,
                pat.pattern,
                exprTy,
                IdentMode::Compare,
                MatchBy::Value,
            );
            if let guardExpr = pat.guard {
                try checkBoolean(self, guardExpr);
            }
            if elseTy <> Type::Never and
               casePatternIntroducesBindings(pat.pattern, false)
            {
                throw emitError(
                    self,
                    letElse.elseBranch,
                    ErrorKind::LinearLetElseMustTerminate,
                );
            }
        }
    }
    if let guardExpr = pat.guard {
        try checkBoolean(self, guardExpr);
    }
    // The `else` branch must be assignable to the expression type.
    try checkAssignable(self, letElse.elseBranch, exprTy);

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

/// Analyze builtin function calls like `@sizeOf(T)` and `@alignOf(T)`.
fn resolveBuiltinCall(

                expected: 2,
                actual: args.len as u32,
            }));
        }
        let ptrType = try visit(self, args[0], Type::Unknown);
        let case Type::Pointer { target, mutable, .. } = ptrType else {
        let case Type::Pointer { class, target, mutable } = 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: types::PointerClass::Owned, item: target, mutable,
        });
        return setNodeType(self, node, Type::Slice { class, item: target, mutable });
    }
    if args.len <> 1 {
        throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
            expected: 1,
            actual: args.len as u32,

    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 {
            let methodName = try nodeName(self, access.child);
            if methodName == "append" {
                return try resolveSliceAppend(self, node, access.parent, parentTy, call.args, item, mutable);
                return try resolveSliceAppend(
                    self, node, access.parent, parentTy, call.args, item, mutable
                );
            }
            if methodName == "delete" {
                return try resolveSliceDelete(self, node, access.parent, call.args, item, mutable);
                return try resolveSliceDelete(
                    self, node, access.parent, call.args, item, mutable
                );
            }
        }
    }
    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 {

            try checkSliceRangeIndices(self, range);

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

            match subjectTy {
                case Type::Array(a) => {
                    try validateArraySliceBounds(self, range, a.length, node);
                    set item = a.item;
                    set capacity = a.length;
            if let case Type::Slice { item: sliceItem, mutable: sliceMutable, .. } = subjectTy {
                if not sliceMutable {
                    throw emitError(self, container, ErrorKind::ImmutableBinding);
                }
                case Type::Slice { item: i, mutable, .. } => {
                    if not mutable { throw emitError(self, container, ErrorKind::ImmutableBinding); }
                    set item = i;
                set item = sliceItem;
            } else {
                match subjectTy {
                    case Type::Array(a) => {
                        try validateArraySliceBounds(self, range, a.length, node);
                        set item = a.item;
                        set capacity = a.length;
                    }
                    else => throw emitError(self, container, ErrorKind::ExpectedIndexable),
                }
                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: srcItem, .. } = rhsTy {
                if *srcItem <> *item {
                    throw emitTypeMismatch(self, assign.right, TypeMismatch { expected: *item, actual: *srcItem });
            if let case Type::Slice { item: sourceItem, .. } = rhsTy {
                if *sourceItem <> *item {
                    throw emitTypeMismatch(
                        self,
                        assign.right,
                        TypeMismatch { expected: *item, actual: *sourceItem },
                    );
                }
            } else {
                try checkAssignable(self, assign.right, *item);
            }
            setSliceRangeInfo(self, node, SliceRangeInfo { itemType: item, mutable: true, capacity });

        let _ = try infer(self, container);
        try checkSliceRangeIndices(self, range);
        throw emitError(self, node, ErrorKind::SliceRequiresAddress);
    }
    let containerTy = try infer(self, container);
    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);
    }

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

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

    match subjectTy {
        case Type::Nominal(NominalType::Record(recordType)) => {
            let fieldNode = access.child;
            let fieldName = try nodeName(self, fieldNode);
            if let fieldIndex = findRecordField(&recordType, fieldName) {
    if let case Type::Slice { class, item, mutable } = 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 },
            );
        }
        if mem::eq(fieldName, LEN_FIELD) {
            setRecordFieldIndex(self, fieldNode, 1);
            return setNodeType(self, node, Type::U32);
        }
        if mem::eq(fieldName, CAP_FIELD) {
            setRecordFieldIndex(self, fieldNode, 2);
            return setNodeType(self, node, Type::U32);
        }
        throw emitError(self, node, ErrorKind::SliceFieldUnknown(fieldName));
    }
    if let case Type::TraitObject { traitInfo, .. } = subjectTy {
        let fieldName = try nodeName(self, access.child);
        let method = findTraitMethod(traitInfo, fieldName)
            else throw emitError(self, node, ErrorKind::RecordFieldUnknown(fieldName));
        return setNodeType(self, node, Type::Fn(method.fnType));
    }

    match subjectTy {
        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;
                setRecordFieldIndex(self, fieldNode, fieldIndex);
                return setNodeType(self, node, fieldTy);
            }
            // Not a field: check for a standalone method.


                return setNodeType(self, node, Type::U32);
            }
            throw emitError(self, node, ErrorKind::ArrayFieldUnknown(fieldName));
        }
        case Type::Slice { item, mutable, .. } => {
            let fieldNode = access.child;
            let fieldName = try nodeName(self, fieldNode);

            if mem::eq(fieldName, PTR_FIELD) {
                setRecordFieldIndex(self, fieldNode, 0);
                let ptrTy = Type::Pointer {
                    class: types::PointerClass::Owned,
                    target: item,
                    mutable,
                };
                return setNodeType(self, node, ptrTy);
            }
            if mem::eq(fieldName, LEN_FIELD) {
                setRecordFieldIndex(self, fieldNode, 1);
                return setNodeType(self, node, Type::U32);
            }
            if mem::eq(fieldName, CAP_FIELD) {
                setRecordFieldIndex(self, fieldNode, 2);
                return setNodeType(self, node, Type::U32);
            }
            throw emitError(self, node, ErrorKind::SliceFieldUnknown(fieldName));
        }
        case Type::TraitObject { traitInfo, .. } => {
            let fieldName = try nodeName(self, access.child);
            let method = findTraitMethod(traitInfo, fieldName)
                else throw emitError(self, node, ErrorKind::RecordFieldUnknown(fieldName));

            return setNodeType(self, node, Type::Fn(method.fnType));
        }
        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) {


/// Analyze an address-of expression.
fn resolveAddressOf(self: *mut Resolver, node: *ast::Node, addr: ast::AddressOf, hint: Type) -> Type
    throws (ResolveError)
{
    // Checked and unsafe pointer contexts require a reference source.
    let class = types::PointerClass::Ref
        if isRefType(hint) or isUnsafePointerType(hint)
        else types::PointerClass::Owned;
    if addr.mutable {
        if not try canBorrowMutFrom(self, addr.target) {
            throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
        }
    }

            try checkSliceRangeIndices(self, range);

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

            match subjectTy {
                case Type::Array(arrayInfo) => {
                    try validateArraySliceBounds(self, range, arrayInfo.length, node);
                    set item = arrayInfo.item;
                    set capacity = arrayInfo.length;
            if let case Type::Slice { item: sliceItem, mutable: sliceMutable, .. } = subjectTy {
                if addr.mutable and not sliceMutable {
                    throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
                }
                case Type::Slice { item: sliceItem, mutable, .. } => {
                    if addr.mutable and not mutable {
                        throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
                set item = sliceItem;
            } else {
                match subjectTy {
                    case Type::Array(arrayInfo) => {
                        try validateArraySliceBounds(self, range, arrayInfo.length, node);
                        set item = arrayInfo.item;
                        set capacity = arrayInfo.length;
                    }
                    else => {
                        throw emitError(self, container, ErrorKind::ExpectedIndexable);
                    }
                    set item = sliceItem;
                }
                else => {
                    throw emitError(self, container, ErrorKind::ExpectedIndexable);
                }
            }
            let sliceTy = Type::Slice {
                class: types::PointerClass::Owned, item, mutable: addr.mutable,
            };
            let sliceTy = Type::Slice { class, item, mutable: addr.mutable };
            let alloc = allocType(self, sliceTy);
            setSliceRangeInfo(self, node, SliceRangeInfo {
                itemType: item,
                mutable: addr.mutable,
                capacity,

    if let case Type::Array(arrayInfo) = targetTy {
        match addr.target.value {
            case ast::NodeValue::ArrayLit(_),
                 ast::NodeValue::ArrayRepeatLit(_) =>
            {
                let sliceTy = Type::Slice {
                    class: types::PointerClass::Owned,
                    item: arrayInfo.item,
                    mutable: addr.mutable,
                };
                let sliceTy = Type::Slice { class, item: arrayInfo.item, mutable: addr.mutable };
                return setNodeType(self, node, *allocType(self, sliceTy));
            }
            else => {}
        }
    }
    let pointerTy = Type::Pointer {
        class: types::PointerClass::Owned,
        target: allocType(self, targetTy),
        mutable: addr.mutable,
        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 { target, .. } = operandTy {
    if let case Type::Pointer { class, target, .. } = operandTy {
        if class == types::PointerClass::Unsafe {
            try requireUnsafe(self, targetNode);
        }
        // Disallow dereferencing opaque pointers.
        if *target == Type::Opaque {
            throw emitError(self, targetNode, ErrorKind::OpaqueTypeDeref);
        }
        return setNodeType(self, node, *target);

        // 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 { target: sourceTarget, .. } = source {
        if let case Type::Pointer { target: targetTarget, .. } = target {
    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 {
                return false;
            }
            if targetMutable and not sourceMutable {
                return false;
            }
            if isOpaquePointer(source) or isOpaquePointer(target) {
                return true;
            }
            return isValidCast(*sourceTarget, *targetTarget);
        }
    }
    // Allow slice casts if one side is `*[opaque]`, target is `*[u8]`,
    // or element types are castable.
    if let case Type::Slice { item: sourceItem, .. } = source {
        if let case Type::Slice { item: targetItem, .. } = target {
    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 {
                return false;
            }
            if targetMutable and not sourceMutable {
                return false;
            }
            if isOpaqueSlice(source) or isOpaqueSlice(target) {
                return true;
            }
            if *targetItem == Type::U8 {
                return true;

fn resolveAs(self: *mut Resolver, node: *ast::Node, expr: ast::As) -> Type
    throws (ResolveError)
{
    let targetTy = try infer(self, expr.type);
    let sourceTy = try visit(self, expr.value, targetTy);
    if isUnsafePointerType(sourceTy) or isUnsafePointerType(targetTy) {
        try requireUnsafe(self, node);
    }

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

    if isValidCast(sourceTy, targetTy) {
    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)
            {
                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)
            {
                set valid = true;
            }
        }
    }
    if valid {
        // Propagate the constant value after applying the cast's target-width
        // truncation and signed interpretation.
        if let value = constValueEntry(self, expr.value) {
            if let case ConstValue::Int(i) = value {
                setNodeConstValue(self, node, castConstInt(i, targetTy));

        case ast::BinaryOp::Eq,
             ast::BinaryOp::Ne =>
        {
            let leftTy = try infer(self, binop.left);
            let rightTy = try visit(self, binop.right, leftTy);
            if isUnsafePointerType(leftTy) or isUnsafePointerType(rightTy) {
                try requireUnsafe(self, node);
            }

            if not isComparable(leftTy, rightTy) {
                throw emitTypeMismatch(self, binop.right, TypeMismatch {
                    expected: leftTy,
                    actual: rightTy,

            // Check for pointer arithmetic before numeric check.
            if binop.op == ast::BinaryOp::Add or binop.op == ast::BinaryOp::Sub {
                let leftTy = try infer(self, binop.left);
                let rightTy = try visit(self, binop.right, leftTy);

                // Disallow pointer arithmetic on opaque pointers.
                if let case Type::Pointer { target: leftTarget, .. } = leftTy; *leftTarget == Type::Opaque {
                    throw emitError(self, node, ErrorKind::OpaquePointerArithmetic);
                }
                if let case Type::Pointer { target: rightTarget, .. } = rightTy; *rightTarget == Type::Opaque {
                    throw emitError(self, node, ErrorKind::OpaquePointerArithmetic);
                }
                // Allow pointer plus integer or integer plus pointer.
                if let case Type::Pointer { .. } = leftTy; isNumericType(rightTy) {
                    return setNodeType(self, node, 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 {
                        throw emitError(self, node, ErrorKind::OpaquePointerArithmetic);
                    }
                    if leftClass <> types::PointerClass::Ref
                        and isNumericType(rightTy)
                    {
                        if leftClass == types::PointerClass::Unsafe {
                            try requireUnsafe(self, node);
                        }
                        return setNodeType(self, node, leftTy);
                    }
                }
                if binop.op == ast::BinaryOp::Add {
                    if let case Type::Pointer { .. } = rightTy; isNumericType(leftTy) {
                if let case Type::Pointer { class: rightClass, target: rightTarget, .. } = rightTy {
                    if *rightTarget == Type::Opaque {
                        throw emitError(self, node, ErrorKind::OpaquePointerArithmetic);
                    }
                    if binop.op == ast::BinaryOp::Add
                        and rightClass <> types::PointerClass::Ref
                        and isNumericType(leftTy)
                    {
                        if rightClass == types::PointerClass::Unsafe {
                            try requireUnsafe(self, node);
                        }
                        return setNodeType(self, node, rightTy);
                    }
                }
            }
            let leftTy = try checkNumeric(self, binop.left);

                    actual: t.throwList.len,
                }));
            }

            for paramNode in t.params {
                let paramTy = try infer(self, paramNode);
                let paramTy = try resolveValueType(self, paramNode);
                paramTypes.append(allocType(self, paramTy), a);
            }
            for tyNode in t.throwList {
                let throwTy = try infer(self, tyNode);
                let throwTy = try resolveValueType(self, tyNode);
                try ensureStorableType(self, tyNode, throwTy);
                throwList.append(allocType(self, throwTy), a);
            }
            let mut retType = allocType(self, Type::Void);
            if let ret = t.returnType {
                set retType = allocType(self, try infer(self, ret));
                let resolvedRet = try resolveValueType(self, ret);
                try ensureStorableType(self, ret, resolvedRet);
                set retType = allocType(self, resolvedRet);
            }
            let fnType = FnType {
                paramTypes: &paramTypes[..],
                returnType: retType,
                throwList: &throwList[..],
                isUnsafe: false,
                localCount: 0,
            };
            return Type::Fn(allocFnType(self, fnType));
        }
        // Resolve an opaque trait object signature.
        case ast::TypeSig::TraitObject { class, traitName, mutable } => {
            let sym = try resolveNamePath(self, traitName);
            let case SymbolData::Trait(traitInfo) = sym.data
                else throw emitError(self, traitName, ErrorKind::Internal);
            setNodeSymbol(self, traitName, sym);

            return Type::TraitObject {
                class,
                traitInfo,
                mutable,
            };
            return Type::TraitObject { 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);
    }
    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),
        case Type::Pointer { target, .. } => return isTypeInferrable(*target),
        else => return true,
    }
}

/// Analyze a standalone expression by wrapping it in a synthetic function.

    for stmt in block.statements {
        try visitDecl(res, stmt);
    }
}

/// Find a tracked binding by symbol identity.
fn findLinearBinding(env: *LinearEnv, sym: *mut Symbol) -> ?u32 {
    for i in 0..env.len {
        if let bound = env.symbols[i]; bound == sym {
            return i;
        }
    }
    return nil;
}

/// Return whether a tracked binding is still available.
fn linearBindingAvailable(env: *LinearEnv, index: u32) -> bool {
    return (env.available & ((1 as u64) << (index as u64))) <> 0;
}

/// Add a local binding when its resolved type is linear.
fn addLinearBinding(checker: *mut LinearChecker, env: *mut LinearEnv, node: *ast::Node)
    throws (ResolveError)
{
    let sym = symbolFor(checker.resolver, node) else return;
    let case SymbolData::Value { type: ty, .. } = sym.data else return;
    if not isLinear(ty) {
        return;
    }
    if env.len >= MAX_LINEAR_BINDINGS {
        throw emitError(checker.resolver, node, ErrorKind::Internal);
    }
    set env.symbols[env.len] = sym;
    set env.available |= (1 as u64) << (env.len as u64);
    set env.len += 1;
}

/// Require all bindings introduced after `start` to have been consumed.
fn finishLinearScope(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    start: u32,
) throws (ResolveError) {
    if not env.terminated {
        for i in start..env.len {
            if linearBindingAvailable(env, i) {
                let sym = env.symbols[i] else panic "finishLinearScope: missing symbol";
                throw emitError(
                    checker.resolver,
                    sym.node,
                    ErrorKind::LinearNotConsumed(sym.name),
                );
            }
        }
    }
    set env.len = start;
}

/// Consume a tracked identifier exactly once.
fn consumeLinearIdent(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    let sym = symbolFor(checker.resolver, node) else return;
    let index = findLinearBinding(env, sym) else return;
    if not linearBindingAvailable(env, index) {
        throw emitError(
            checker.resolver,
            node,
            ErrorKind::LinearUseAfterConsume(sym.name),
        );
    }
    set env.available &= ~((1 as u64) << (index as u64));
}

/// Verify that two live branches agree on every outer binding.
fn joinLinearBranches(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    left: LinearEnv,
    right: LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    if left.terminated and right.terminated {
        set *env = left;
        set env.terminated = true;
        return;
    }
    if left.terminated {
        set *env = right;
        return;
    }
    if right.terminated {
        set *env = left;
        return;
    }
    assert left.len == right.len, "joinLinearBranches: scope mismatch";
    for i in 0..left.len {
        if linearBindingAvailable(&left, i) <> linearBindingAvailable(&right, i) {
            let sym = left.symbols[i] else panic "joinLinearBranches: missing symbol";
            throw emitError(
                checker.resolver,
                node,
                ErrorKind::LinearBranchMismatch(sym.name),
            );
        }
    }
    set *env = left;
}

/// Require all current bindings to be consumed at a function exit.
fn finishLinearExit(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
) throws (ResolveError) {
    for i in 0..env.len {
        if linearBindingAvailable(env, i) {
            let sym = env.symbols[i] else panic "finishLinearExit: missing symbol";
            throw emitError(
                checker.resolver,
                sym.node,
                ErrorKind::LinearNotConsumed(sym.name),
            );
        }
    }
    set env.terminated = true;
}

/// Find the local root borrowed or consumed by an argument expression.
fn linearRootSymbol(self: *mut Resolver, node: *ast::Node) -> ?*mut Symbol {
    match node.value {
        case ast::NodeValue::Ident(_) => return symbolFor(self, node),
        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::Deref(target) => return linearRootSymbol(self, target),
        else => return nil,
    }
}

/// Add the value identifiers introduced by a pattern.
fn addLinearPatternBindings(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    pattern: *ast::Node,
) throws (ResolveError) {
    match pattern.value {
        case ast::NodeValue::Ident(_) => try addLinearBinding(checker, env, pattern),
        case ast::NodeValue::Call(call) => {
            for arg in call.args {
                try addLinearPatternBindings(checker, env, arg);
            }
        }
        case ast::NodeValue::RecordLit(lit) => {
            for fieldNode in lit.fields {
                let case ast::NodeValue::RecordLitField(field) = fieldNode.value
                    else panic "addLinearPatternBindings: expected field";
                try addLinearPatternBindings(checker, env, field.value);
            }
        }
        case ast::NodeValue::ArrayLit(items) => {
            for item in items {
                try addLinearPatternBindings(checker, env, item);
            }
        }
        else => {}
    }
}

/// Check a lexical block and exact-use of locals introduced in it.
fn checkLinearBlock(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    let start = env.len;
    let case ast::NodeValue::Block(block) = node.value
        else panic "checkLinearBlock: expected block";
    for stmt in block.statements {
        if env.terminated {
            break;
        }
        try checkLinearNode(checker, env, stmt, LinearUse::Discard);
    }
    try finishLinearScope(checker, env, start);
}

/// Push a repeated-control-flow boundary.
fn enterLinearLoop(checker: *mut LinearChecker, env: *LinearEnv) {
    assert checker.loopDepth < MAX_LINEAR_LOOP_DEPTH, "linear loop nesting overflow";
    let depth = checker.loopDepth;
    set checker.loopMarks[depth] = env.len;
    set checker.loopAvailable[depth] = env.available;
    set checker.loopExitAvailable[depth] = env.available;
    set checker.loopHasNaturalExit[depth] = false;
    set checker.loopBreakSeen[depth] = false;
    set checker.loopDepth += 1;
}

/// Require a repeated body's outer bindings to match its entry state.
fn checkLinearLoopBackEdge(
    checker: *mut LinearChecker,
    env: *LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    if env.terminated {
        return;
    }
    assert checker.loopDepth > 0, "linear loop back edge outside loop";
    let depth = checker.loopDepth - 1;
    let mark = checker.loopMarks[depth];
    let entryAvailable = checker.loopAvailable[depth];
    for i in 0..mark {
        let bit = (1 as u64) << (i as u64);
        if (env.available & bit) <> (entryAvailable & bit) {
            let sym = env.symbols[i] else panic "checkLinearLoopBackEdge: missing symbol";
            throw emitError(
                checker.resolver,
                node,
                ErrorKind::LinearBranchMismatch(sym.name),
            );
        }
    }
}

/// Record the ownership state of a loop's condition-false exit.
fn setLinearLoopNaturalExit(checker: *mut LinearChecker, env: *LinearEnv) {
    assert checker.loopDepth > 0, "linear loop exit outside loop";
    let depth = checker.loopDepth - 1;
    set checker.loopExitAvailable[depth] = env.available;
    set checker.loopHasNaturalExit[depth] = true;
}

/// Require a break exit to agree with every other exit from this loop.
fn checkLinearLoopBreak(
    checker: *mut LinearChecker,
    env: *LinearEnv,
    node: *ast::Node,
) throws (ResolveError) {
    assert checker.loopDepth > 0, "linear loop break outside loop";
    let depth = checker.loopDepth - 1;
    let mark = checker.loopMarks[depth];
    if checker.loopHasNaturalExit[depth] or checker.loopBreakSeen[depth] {
        let expected = checker.loopExitAvailable[depth];
        for i in 0..mark {
            let bit = (1 as u64) << (i as u64);
            if (env.available & bit) <> (expected & bit) {
                let sym = env.symbols[i] else panic "checkLinearLoopBreak: missing symbol";
                throw emitError(
                    checker.resolver,
                    node,
                    ErrorKind::LinearBranchMismatch(sym.name),
                );
            }
        }
    } else {
        set checker.loopExitAvailable[depth] = env.available;
    }
    set checker.loopBreakSeen[depth] = true;
}

/// Pop a repeated-control-flow boundary.
fn exitLinearLoop(checker: *mut LinearChecker) {
    assert checker.loopDepth > 0, "exitLinearLoop: not in loop";
    set checker.loopDepth -= 1;
}

/// Check a conditional and merge its ownership states.
fn checkLinearIf(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
    conditional: ast::If,
) throws (ResolveError) {
    try checkLinearNode(checker, env, conditional.condition, LinearUse::Consume);
    let base = *env;
    let mut thenEnv = base;
    try checkLinearNode(checker, &mut thenEnv, conditional.thenBranch, LinearUse::Discard);
    let mut elseEnv = base;
    if let branch = conditional.elseBranch {
        try checkLinearNode(checker, &mut elseEnv, branch, LinearUse::Discard);
    }
    try joinLinearBranches(checker, env, thenEnv, elseEnv, node);
}

/// Check an expression conditional and merge its ownership states.
fn checkLinearCondExpr(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
    conditional: ast::CondExpr,
    usage: LinearUse,
) throws (ResolveError) {
    try checkLinearNode(checker, env, conditional.condition, LinearUse::Consume);
    let base = *env;
    let mut thenEnv = base;
    try checkLinearNode(checker, &mut thenEnv, conditional.thenExpr, usage);
    let mut elseEnv = base;
    try checkLinearNode(checker, &mut elseEnv, conditional.elseExpr, usage);
    try joinLinearBranches(checker, env, thenEnv, elseEnv, node);
}

/// Check a match expression, including ownership transferred into patterns.
fn checkLinearMatch(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
    matchExpr: ast::Match,
) throws (ResolveError) {
    try checkLinearNode(checker, env, matchExpr.subject, LinearUse::Consume);
    let base = *env;
    let mut haveResult = false;
    let mut result = base;
    for prongNode in matchExpr.prongs {
        let case ast::NodeValue::MatchProng(prong) = prongNode.value
            else panic "checkLinearMatch: expected prong";
        let mut branch = base;
        let bindingsStart = branch.len;
        match prong.arm {
            case ast::ProngArm::Case(patterns) => {
                for pattern in patterns {
                    try addLinearPatternBindings(checker, &mut branch, pattern);
                }
            }
            case ast::ProngArm::Binding(binding) => {
                try addLinearPatternBindings(checker, &mut branch, binding);
            }
            case ast::ProngArm::Else => {}
        }
        if prong.guard <> nil and branch.len > bindingsStart {
            throw emitError(checker.resolver, prongNode, ErrorKind::LinearDiscard);
        }
        if let guard = prong.guard {
            try checkLinearNode(checker, &mut branch, guard, LinearUse::Consume);
        }
        try checkLinearNode(checker, &mut branch, prong.body, LinearUse::Discard);
        try finishLinearScope(checker, &mut branch, bindingsStart);
        if haveResult {
            try joinLinearBranches(checker, &mut result, result, branch, node);
        } else {
            set result = branch;
            set haveResult = true;
        }
    }
    if haveResult {
        set *env = result;
    }
}

/// Check call-scoped loans and argument ownership transfers.
fn checkLinearCall(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
    call: ast::Call,
) throws (ResolveError) {
    try checkLinearNode(checker, env, call.callee, LinearUse::Observe);
    let calleeTy = typeFor(checker.resolver, call.callee) else {
        throw emitError(checker.resolver, call.callee, ErrorKind::Internal);
    };
    let case Type::Fn(info) = calleeTy else {
        for arg in call.args {
            try checkLinearNode(checker, env, arg, LinearUse::Consume);
        }
        return;
    };
    let mut roots: [?*mut Symbol; MAX_FN_PARAMS + 1] = undefined;
    let mut exclusive: [bool; MAX_FN_PARAMS + 1] = undefined;
    let mut rootsLen: u32 = 0;

    // Method function types exclude their implicit receiver. Account for it
    // explicitly so owning receivers are consumed and reference receivers
    // participate in call-scoped loan conflict checks.
    if let case ast::NodeValue::FieldAccess(access) = call.callee.value {
        let mut receiverClass = types::PointerClass::Unsafe;
        let mut receiverMutable = false;
        let mut haveReceiver = false;
        match checker.resolver.nodeData.entries[node.id].extra {
            case NodeExtra::TraitMethodCall { traitInfo, methodIndex } => {
                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;
            }
            else => {}
        }
        if haveReceiver {
            if receiverClass <> types::PointerClass::Unsafe {
                let root = linearRootSymbol(checker.resolver, access.parent);
                if let rootSym = root {
                    set roots[rootsLen] = rootSym;
                    set exclusive[rootsLen] =
                        receiverClass == types::PointerClass::Owned or receiverMutable;
                    set rootsLen += 1;
                }
            }
            if receiverClass == types::PointerClass::Ref {
                try checkLinearNode(checker, env, access.parent, LinearUse::Borrow);
            } else if receiverClass == types::PointerClass::Owned {
                try checkLinearNode(checker, env, access.parent, LinearUse::Consume);
            }
        }
    }

    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 {
            set argExclusive = mutable;
        } else if let case Type::Slice { class: types::PointerClass::Ref, mutable, .. } = expected {
            set argExclusive = mutable;
        } else if let case Type::TraitObject {
            class: types::PointerClass::Ref, mutable, ..
        } = expected {
            set argExclusive = mutable;
        }
        if not isUnsafePointerType(expected) {
            if let rootSym = root {
                for j in 0..rootsLen {
                    if let previous = roots[j] {
                        if previous == rootSym and (exclusive[j] or argExclusive) {
                            throw emitError(
                                checker.resolver,
                                arg,
                                ErrorKind::BorrowConflict(rootSym.name),
                            );
                        }
                    }
                }
                set roots[rootsLen] = rootSym;
                set exclusive[rootsLen] = argExclusive;
                set rootsLen += 1;
            }
        }
        if isRefType(expected) {
            try checkLinearNode(checker, env, arg, LinearUse::Borrow);
        } else {
            try checkLinearNode(checker, env, arg, LinearUse::Consume);
        }
    }
}

/// Check a pattern conditional. Linear scrutinees require an exhaustive match.
fn checkLinearIfLet(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
    conditional: ast::IfLet,
) throws (ResolveError) {
    if let subjectTy = typeFor(checker.resolver, conditional.pattern.scrutinee);
        isLinear(subjectTy)
    {
        throw emitError(
            checker.resolver,
            conditional.pattern.scrutinee,
            ErrorKind::LinearPartialMove,
        );
    }
    try checkLinearNode(
        checker,
        env,
        conditional.pattern.scrutinee,
        LinearUse::Consume,
    );
    let base = *env;
    let mut thenEnv = base;
    let bindingsStart = thenEnv.len;
    try addLinearPatternBindings(checker, &mut thenEnv, conditional.pattern.pattern);
    if let guard = conditional.pattern.guard {
        try checkLinearNode(checker, &mut thenEnv, guard, LinearUse::Consume);
    }
    try checkLinearNode(checker, &mut thenEnv, conditional.thenBranch, LinearUse::Discard);
    try finishLinearScope(checker, &mut thenEnv, bindingsStart);
    let mut elseEnv = base;
    if let branch = conditional.elseBranch {
        try checkLinearNode(checker, &mut elseEnv, branch, LinearUse::Discard);
    }
    try joinLinearBranches(checker, env, thenEnv, elseEnv, node);
}

/// Check one expression or statement under an ownership-use context.
fn checkLinearNode(
    checker: *mut LinearChecker,
    env: *mut LinearEnv,
    node: *ast::Node,
    usage: LinearUse,
) throws (ResolveError) {
    if env.terminated {
        return;
    }
    match node.value {
        case ast::NodeValue::Ident(_) => {
            if usage == LinearUse::Consume {
                try consumeLinearIdent(checker, env, node);
            }
        }
        case ast::NodeValue::ExprStmt(expr) => {
            if let exprTy = typeFor(checker.resolver, expr) {
                if isLinear(exprTy) {
                    throw emitError(checker.resolver, expr, ErrorKind::LinearDiscard);
                }
            }
            try checkLinearNode(checker, env, expr, LinearUse::Consume);
        }
        case ast::NodeValue::Block(_) => try checkLinearBlock(checker, env, node),
        case ast::NodeValue::Let(binding) => {
            if let case ast::NodeValue::Undef = binding.value.value {
                if let bindingTy = typeFor(checker.resolver, binding.ident);
                    isLinear(bindingTy)
                {
                    throw emitError(
                        checker.resolver,
                        binding.value,
                        ErrorKind::LinearUndefined,
                    );
                }
            }
            try checkLinearNode(checker, env, binding.value, LinearUse::Consume);
            try addLinearBinding(checker, env, node);
        }
        case ast::NodeValue::Assign(assign) => {
            let mut target: ?u32 = nil;
            if let leftTy = typeFor(checker.resolver, assign.left) {
                if isLinear(leftTy) {
                    if let case ast::NodeValue::Ident(_) = assign.left.value {
                        if let sym = symbolFor(checker.resolver, assign.left) {
                            set target = findLinearBinding(env, sym);
                        }
                    }
                    if target == nil {
                        throw emitError(
                            checker.resolver,
                            assign.left,
                            ErrorKind::LinearOverwrite,
                        );
                    }
                }
            }
            try checkLinearNode(checker, env, assign.left, LinearUse::Place);
            try checkLinearNode(checker, env, assign.right, LinearUse::Consume);
            if let index = target {
                if linearBindingAvailable(env, index) {
                    throw emitError(
                        checker.resolver,
                        assign.left,
                        ErrorKind::LinearOverwrite,
                    );
                }
                set env.available |= (1 as u64) << (index as u64);
            }
        }
        case ast::NodeValue::Call(call) => try checkLinearCall(checker, env, node, call),
        case ast::NodeValue::AddressOf(addr) => {
            try checkLinearNode(checker, env, addr.target, LinearUse::Borrow);
        }
        case ast::NodeValue::Deref(target) => {
            if let resultTy = typeFor(checker.resolver, node) {
                if isLinear(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, target, LinearUse::Observe);
        }
        case ast::NodeValue::FieldAccess(access) => {
            if let resultTy = typeFor(checker.resolver, node) {
                if isLinear(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, access.parent, LinearUse::Observe);
        }
        case ast::NodeValue::ScopeAccess(_) => {}
        case ast::NodeValue::Subscript { container, index } => {
            if let resultTy = typeFor(checker.resolver, node) {
                if isLinear(resultTy) and usage == LinearUse::Consume {
                    throw emitError(checker.resolver, node, ErrorKind::LinearPartialMove);
                }
            }
            try checkLinearNode(checker, env, container, LinearUse::Observe);
            try checkLinearNode(checker, env, index, LinearUse::Consume);
        }
        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);
            }
        }
        case ast::NodeValue::ArrayLit(items) => {
            for item in items {
                try checkLinearNode(checker, env, item, LinearUse::Consume);
            }
        }
        case ast::NodeValue::ArrayRepeatLit(repeat) => {
            if let itemTy = typeFor(checker.resolver, repeat.item) {
                if isLinear(itemTy) {
                    throw emitError(
                        checker.resolver,
                        repeat.item,
                        ErrorKind::LinearDiscard,
                    );
                }
            }
            try checkLinearNode(checker, env, repeat.item, LinearUse::Consume);
            try checkLinearNode(checker, env, repeat.count, LinearUse::Consume);
        }
        case ast::NodeValue::BinOp(op) => {
            try checkLinearNode(checker, env, op.left, LinearUse::Consume);
            try checkLinearNode(checker, env, op.right, LinearUse::Consume);
        }
        case ast::NodeValue::UnOp(op) => {
            try checkLinearNode(checker, env, op.value, LinearUse::Consume);
        }
        case ast::NodeValue::As(expr) => {
            try checkLinearNode(checker, env, expr.value, LinearUse::Consume);
        }
        case ast::NodeValue::Range(range) => {
            if let start = range.start {
                try checkLinearNode(checker, env, start, LinearUse::Consume);
            }
            if let end = range.end {
                try checkLinearNode(checker, env, end, LinearUse::Consume);
            }
        }
        case ast::NodeValue::BuiltinCall { args, .. } => {
            for arg in args {
                try checkLinearNode(checker, env, arg, LinearUse::Consume);
            }
        }
        case ast::NodeValue::If(conditional) => {
            try checkLinearIf(checker, env, node, conditional);
        }
        case ast::NodeValue::CondExpr(conditional) => {
            try checkLinearCondExpr(checker, env, node, conditional, usage);
        }
        case ast::NodeValue::IfLet(conditional) => {
            try checkLinearIfLet(checker, env, node, conditional);
        }
        case ast::NodeValue::LetElse(binding) => {
            if let subjectTy = typeFor(checker.resolver, binding.pattern.scrutinee);
                isLinear(subjectTy)
            {
                throw emitError(
                    checker.resolver,
                    binding.pattern.scrutinee,
                    ErrorKind::LinearPartialMove,
                );
            }
            try checkLinearNode(
                checker,
                env,
                binding.pattern.scrutinee,
                LinearUse::Consume,
            );
            let base = *env;
            let mut guardedEnv = base;
            if let guard = binding.pattern.guard {
                try checkLinearNode(checker, &mut guardedEnv, guard, LinearUse::Consume);
            }
            let mut successEnv = guardedEnv;
            try addLinearPatternBindings(
                checker,
                &mut successEnv,
                binding.pattern.pattern,
            );
            let mut fallbackEnv = base;
            try checkLinearNode(
                checker,
                &mut fallbackEnv,
                binding.elseBranch,
                LinearUse::Consume,
            );
            if binding.pattern.guard <> nil {
                let mut guardFallbackEnv = guardedEnv;
                try checkLinearNode(
                    checker,
                    &mut guardFallbackEnv,
                    binding.elseBranch,
                    LinearUse::Consume,
                );
                try joinLinearBranches(
                    checker,
                    &mut fallbackEnv,
                    fallbackEnv,
                    guardFallbackEnv,
                    binding.elseBranch,
                );
            }
            if let case ast::PatternKind::Binding = binding.pattern.kind {
                try addLinearPatternBindings(
                    checker,
                    &mut fallbackEnv,
                    binding.pattern.pattern,
                );
            }
            try joinLinearBranches(checker, env, successEnv, fallbackEnv, node);
        }
        case ast::NodeValue::Match(matchExpr) => {
            try checkLinearMatch(checker, env, node, matchExpr);
        }
        case ast::NodeValue::Try(tryExpr) => {
            try checkLinearNode(checker, env, tryExpr.expr, usage);
            let success = *env;
            for catchNode in tryExpr.catches {
                let case ast::NodeValue::CatchClause(catchClause) = catchNode.value
                    else panic "checkLinearNode: expected catch";
                let mut branch = success;
                let start = branch.len;
                if let binding = catchClause.binding {
                    try addLinearBinding(checker, &mut branch, binding);
                }
                try checkLinearNode(checker, &mut branch, catchClause.body, usage);
                try finishLinearScope(checker, &mut branch, start);
                try joinLinearBranches(checker, env, *env, branch, node);
            }
        }
        case ast::NodeValue::While(whileStmt) => {
            enterLinearLoop(checker, env);
            try checkLinearNode(checker, env, whileStmt.condition, LinearUse::Consume);
            let conditionExit = *env;
            setLinearLoopNaturalExit(checker, &conditionExit);
            let mut bodyEnv = conditionExit;
            try checkLinearNode(checker, &mut bodyEnv, whileStmt.body, LinearUse::Discard);
            try checkLinearLoopBackEdge(checker, &bodyEnv, whileStmt.body);
            exitLinearLoop(checker);
            set *env = conditionExit;
            if let elseBranch = whileStmt.elseBranch {
                let mut elseEnv = conditionExit;
                try checkLinearNode(
                    checker,
                    &mut elseEnv,
                    elseBranch,
                    LinearUse::Discard,
                );
                try joinLinearBranches(checker, env, conditionExit, elseEnv, node);
            }
        }
        case ast::NodeValue::WhileLet(whileStmt) => {
            if let subjectTy = typeFor(checker.resolver, whileStmt.pattern.scrutinee);
                isLinear(subjectTy)
            {
                throw emitError(
                    checker.resolver,
                    whileStmt.pattern.scrutinee,
                    ErrorKind::LinearPartialMove,
                );
            }
            let base = *env;
            enterLinearLoop(checker, env);
            let mut bodyEnv = base;
            try checkLinearNode(
                checker,
                &mut bodyEnv,
                whileStmt.pattern.scrutinee,
                LinearUse::Consume,
            );
            let mut conditionExit = bodyEnv;
            let start = bodyEnv.len;
            try addLinearPatternBindings(checker, &mut bodyEnv, whileStmt.pattern.pattern);
            if let guard = whileStmt.pattern.guard {
                try checkLinearNode(checker, &mut bodyEnv, guard, LinearUse::Consume);
                let mut guardExit = bodyEnv;
                try finishLinearScope(checker, &mut guardExit, start);
                try joinLinearBranches(
                    checker,
                    &mut conditionExit,
                    conditionExit,
                    guardExit,
                    guard,
                );
            }
            setLinearLoopNaturalExit(checker, &conditionExit);
            try checkLinearNode(checker, &mut bodyEnv, whileStmt.body, LinearUse::Discard);
            try finishLinearScope(checker, &mut bodyEnv, start);
            try checkLinearLoopBackEdge(checker, &bodyEnv, whileStmt.body);
            exitLinearLoop(checker);
            set *env = conditionExit;
            if let elseBranch = whileStmt.elseBranch {
                let mut elseEnv = conditionExit;
                try checkLinearNode(
                    checker,
                    &mut elseEnv,
                    elseBranch,
                    LinearUse::Discard,
                );
                try joinLinearBranches(checker, env, conditionExit, elseEnv, node);
            }
        }
        case ast::NodeValue::For(forStmt) => {
            if let iterableTy = typeFor(checker.resolver, forStmt.iterable) {
                if isLinear(iterableTy) {
                    throw emitError(
                        checker.resolver,
                        forStmt.iterable,
                        ErrorKind::LinearPartialMove,
                    );
                }
            }
            try checkLinearNode(checker, env, forStmt.iterable, LinearUse::Consume);
            let base = *env;
            enterLinearLoop(checker, env);
            setLinearLoopNaturalExit(checker, &base);
            let mut bodyEnv = base;
            let start = bodyEnv.len;
            try addLinearBinding(checker, &mut bodyEnv, forStmt.binding);
            if let index = forStmt.index {
                try addLinearBinding(checker, &mut bodyEnv, index);
            }
            try checkLinearNode(checker, &mut bodyEnv, forStmt.body, LinearUse::Discard);
            try finishLinearScope(checker, &mut bodyEnv, start);
            try checkLinearLoopBackEdge(checker, &bodyEnv, forStmt.body);
            exitLinearLoop(checker);
            set *env = base;
            if let elseBranch = forStmt.elseBranch {
                let mut elseEnv = base;
                try checkLinearNode(
                    checker,
                    &mut elseEnv,
                    elseBranch,
                    LinearUse::Discard,
                );
                try joinLinearBranches(checker, env, base, elseEnv, node);
            }
        }
        case ast::NodeValue::Loop { body } => {
            let base = *env;
            enterLinearLoop(checker, env);
            let mut bodyEnv = base;
            try checkLinearNode(checker, &mut bodyEnv, body, LinearUse::Discard);
            try checkLinearLoopBackEdge(checker, &bodyEnv, body);
            let depth = checker.loopDepth - 1;
            let breakSeen = checker.loopBreakSeen[depth];
            let exitAvailable = checker.loopExitAvailable[depth];
            exitLinearLoop(checker);
            set *env = base;
            if breakSeen {
                set env.available = exitAvailable;
            } else {
                set env.terminated = true;
            }
        }
        case ast::NodeValue::Break => {
            assert checker.loopDepth > 0, "linear loop control outside loop";
            let start = checker.loopMarks[checker.loopDepth - 1];
            try finishLinearScope(checker, env, start);
            try checkLinearLoopBreak(checker, env, node);
            set env.terminated = true;
        }
        case ast::NodeValue::Continue => {
            assert checker.loopDepth > 0, "linear loop control outside loop";
            let start = checker.loopMarks[checker.loopDepth - 1];
            try finishLinearScope(checker, env, start);
            try checkLinearLoopBackEdge(checker, env, node);
            set env.terminated = true;
        }
        case ast::NodeValue::Return { value } => {
            if let expr = value {
                try checkLinearNode(checker, env, expr, LinearUse::Consume);
            }
            try finishLinearExit(checker, env);
        }
        case ast::NodeValue::Throw { expr } => {
            try checkLinearNode(checker, env, expr, LinearUse::Consume);
            try finishLinearExit(checker, env);
        }
        case ast::NodeValue::Panic { message } => {
            if let expr = message {
                try checkLinearNode(checker, env, expr, LinearUse::Consume);
            }
            set env.terminated = true;
        }
        case ast::NodeValue::Assert { condition, message } => {
            try checkLinearNode(checker, env, condition, LinearUse::Consume);
            if let expr = message {
                try checkLinearNode(checker, env, expr, LinearUse::Consume);
            }
        }
        else => {}
    }
}

/// Check exact-use ownership for one resolved function.
fn checkLinearFn(
    self: *mut Resolver,
    receiver: ?*ast::Node,
    params: *mut [*ast::Node],
    body: *ast::Node,
) throws (ResolveError) {
    let mut checker = LinearChecker {
        resolver: self,
        loopMarks: [0; MAX_LINEAR_LOOP_DEPTH],
        loopAvailable: [0; MAX_LINEAR_LOOP_DEPTH],
        loopExitAvailable: [0; MAX_LINEAR_LOOP_DEPTH],
        loopHasNaturalExit: [false; MAX_LINEAR_LOOP_DEPTH],
        loopBreakSeen: [false; MAX_LINEAR_LOOP_DEPTH],
        loopDepth: 0,
    };
    let mut env = LinearEnv {
        symbols: [nil; MAX_LINEAR_BINDINGS],
        available: 0,
        len: 0,
        terminated: false,
    };
    if let receiverNode = receiver {
        try addLinearBinding(&mut checker, &mut env, receiverNode);
    }
    for paramNode in params {
        let case ast::NodeValue::FnParam(_) = paramNode.value
            else panic "checkLinearFn: expected parameter";
        try addLinearBinding(&mut checker, &mut env, paramNode);
    }
    try checkLinearNode(&mut checker, &mut env, body, LinearUse::Discard);
    try finishLinearScope(&mut checker, &mut env, 0);
}

/// Analyze module definitions. This pass analyzes function bodies, recursing into sub-modules.
fn resolveModuleDefs(self: *mut Resolver, block: *ast::Block) throws (ResolveError) {
    for stmt in block.statements {
        try visitDef(self, stmt);
    }

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

//! Resolver scope printer.
use std::io;
use std::lang::ast;
use std::lang::types;
use std::lang::scanner;
use std::lang::module;

/// Print a span in `@offset:length` form.
fn printSpan(span: ast::Span) {

    io::print(prefix);
    io::print(name);
    io::print("'");
}

/// Print `*` or `*mut ` depending on mutability.
fn printPtrPrefix(mutable: bool) {
    io::print("*");
/// Print a pointer-like type prefix.
fn printPtrPrefix(class: types::PointerClass, mutable: bool) {
    match class {
        case types::PointerClass::Owned => io::print("*"),
        case types::PointerClass::Ref => io::print("&"),
        case types::PointerClass::Unsafe => io::print("*unsafe "),
    }
    if mutable {
        io::print("mut ");
    }
}


            io::print("i32");
        }
        case super::Type::I64 => {
            io::print("i64");
        }
        case super::Type::Pointer { target, mutable, .. } => {
            printPtrPrefix(mutable);
        case super::Type::Pointer { class, target, mutable } => {
            printPtrPrefix(class, mutable);
            printTypeBody(*target, brief);
        }
        case super::Type::Slice { item, mutable, .. } => {
            printPtrPrefix(mutable);
        case super::Type::Slice { class, item, mutable } => {
            printPtrPrefix(class, mutable);
            io::print("[");
            printTypeBody(*item, brief);
            io::print("]");
        }
        case super::Type::Array(array) => {

        case super::Type::Optional(inner) => {
            io::print("?");
            printTypeBody(*inner, brief);
        }
        case super::Type::Fn(fnType) => {
            if fnType.isUnsafe {
                io::print("unsafe ");
            }
            io::print("fn(");
            for paramType, i in fnType.paramTypes {
                if i > 0 {
                    io::print(", ");
                }

                printNominalTypeName(info);
            } else {
                printNominalType(info);
            }
        }
        case super::Type::TraitObject { traitInfo, mutable, .. } => {
            printPtrPrefix(mutable);
        case super::Type::TraitObject { class, traitInfo, mutable } => {
            printPtrPrefix(class, mutable);
            io::print("opaque ");
            io::print(traitInfo.name);
        }
        case super::Type::Range { start, end } => {
            if let s = start {

            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::TraitMethodSafetyMismatch => {
            io::print("trait method implementation has mismatched unsafe requirement");
        }
        case super::ErrorKind::FnParamOverflow(m) =>
            printMismatch("too many function parameters", "maximum", m),
        case super::ErrorKind::FnThrowOverflow(m) =>
            printMismatch("too many function throws", "maximum", m),
        case super::ErrorKind::TraitMethodOverflow(m) =>
            printMismatch("too many trait methods", "maximum", m),
        case super::ErrorKind::MissingSupertraitInstance(name) => {
            printQuoted("missing instance for supertrait '", name);
        }
        case super::ErrorKind::LinearUseAfterConsume(name) => {
            printQuoted("linear value used after consumption: '", name);
        }
        case super::ErrorKind::LinearNotConsumed(name) => {
            printQuoted("linear value is not consumed: '", name);
        }
        case super::ErrorKind::LinearLetElseMustTerminate => {
            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::LinearPartialMove => {
            io::print("cannot move a field out of a linear value");
        }
        case super::ErrorKind::LinearDiscard => {
            io::print("linear value cannot be discarded");
        }
        case super::ErrorKind::LinearOverwrite => {
            io::print("assignment would overwrite a linear value");
        }
        case super::ErrorKind::LinearUndefined => {
            io::print("linear values cannot be undefined");
        }
        case super::ErrorKind::InvalidRefPosition => {
            io::print("reference type is only allowed as a function parameter");
        }
        case super::ErrorKind::RefBinding => {
            io::print("references cannot be bound to locals");
        }
        case super::ErrorKind::BorrowConflict(name) => {
            printQuoted("conflicting call-scoped loans of '", name);
        }
        case super::ErrorKind::UnsafeOperation => {
            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::Internal => {
            io::print("internal compiler error");
        }
        case super::ErrorKind::RecordFieldOutOfOrder { .. } => {
            io::print("record field out of order");

lib/std/lang/resolver/tests.rad +324 -4


use std::mem;
use std::testing;
use std::lang::alloc;
use std::lang::ast;
use std::lang::types;
use std::lang::parser;
use std::lang::scanner;
use std::lang::module;
use std::lang::strings;

/// Synthetic file path used for resolver tests.
constant MODULE_PATH: *[u8] = "/dev/test.rad";

/// AST arena storage used by resolver tests.
static AST_ARENA: [u8; 2097152] = undefined;

/// Resolver arena storage used by resolver tests.
static ARENA_STORAGE: [u8; 2097152] = undefined;

/// Node metadata storage used by resolver tests.
static NODE_DATA_STORAGE: [super::NodeData; 256] = undefined;

/// Diagnostic storage used by resolver tests.
static ERROR_STORAGE: [super::Error; 16] = undefined;

/// Package scope used by resolver tests.
static PKG_SCOPE: super::Scope = undefined;

/// Module entries used by resolver tests.
static MODULE_ENTRIES: [module::ModuleEntry; 8] = undefined;

/// Module graph used by resolver tests.
static MODULE_GRAPH: module::ModuleGraph = undefined;

/// Module AST arena storage used by resolver tests.
static MODULE_ARENA_STORAGE: [u8; 4096] = undefined;

/// Module AST arena used by resolver tests.
static MODULE_ARENA: ast::NodeArena = undefined;

/// Interned string pool used by resolver tests.
static STRING_POOL: strings::Pool = strings::Pool { table: undefined, count: 0 };

/// String literals used in tests.
constant LITERALS: [*[u8]; 15] = [
    "Ok", "Error", "R", "S",

        if let case super::ErrorKind::MissingSupertraitInstance(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::LinearUseAfterConsume(expectedName) = expected {
        if let case super::ErrorKind::LinearUseAfterConsume(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::LinearNotConsumed(expectedName) = expected {
        if let case super::ErrorKind::LinearNotConsumed(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::LinearBranchMismatch(expectedName) = expected {
        if let case super::ErrorKind::LinearBranchMismatch(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    if let case super::ErrorKind::BorrowConflict(expectedName) = expected {
        if let case super::ErrorKind::BorrowConflict(actualName) = *actual {
            return mem::eq(actualName, expectedName);
        }
        return false;
    }
    return *actual == expected;
}

/// Extract the first error and ensure it has the expected kind.
fn expectErrorKind(result: *TestResult, kind: super::ErrorKind) -> *super::Error

        else throw testing::TestError::Failed;
    try testing::expect(mismatch.expected == expected);
    try testing::expect(mismatch.actual == actual);
}

/// Resolve a program and require successful analysis.
fn expectAnalyzeOk(program: *[u8]) throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Require an inferred integer type mismatch.
fn expectIntMismatch(program: *[u8], expected: super::Type)
    throws (testing::TestError)
{
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, program);

    let case super::SymbolData::Type(ty) = sym.data
        else throw testing::TestError::Failed;
    return ty;
}

/// Return the resolved type of a syntax node.
fn typeOf(a: *super::Resolver, node: *ast::Node) -> super::Type
    throws (testing::TestError)
{
    let ty = super::typeFor(a, node)
        else throw testing::TestError::Failed;
    return ty;
}

/// Require an array type and return its element type.
fn expectArrayType(ty: super::Type, length: u32) -> super::Type
    throws (testing::TestError)
{
    let case super::Type::Array(info) = ty
        else throw testing::TestError::Failed;
    try testing::expect(info.length == length);

    return *info.item;
}

/// 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
        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
        else throw testing::TestError::Failed;

        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 target = try expectPointerType(payloadValType, false);
    try testing::expect(target == super::Type::I32);
    let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
        else throw testing::TestError::Failed;
    try testing::expect(not mutable);
    try testing::expect(*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 target = try expectPointerType(payloadValType, true);
    try testing::expect(target == super::Type::I32);
    let case super::Type::Pointer { class: types::PointerClass::Ref, target, mutable } = payloadValType
        else throw testing::TestError::Failed;
    try testing::expect(mutable);
    try testing::expect(*target == super::Type::I32);
}

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

    try expectConstFold("constant B: u32 = 10; constant C: u32 = B * 2;", 1, 20);
    try expectConstFold("constant D: u32 = 3 + 7;", 0, 10);
    try expectConstFold("constant E: u32 = 2 * 3 + 4;", 0, 10);
    try expectConstFold("constant F: i32 = -(3 + 4);", 0, 7);
}

/// References cannot escape through return types.
@test fn testRefReturnRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} fn bad(value: &u32) -> &u32 { return value; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Case-pattern fallbacks must terminate instead of synthesizing bindings.
@test fn testCaseLetElseFallbackMustTerminate() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else value; item; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearLetElseMustTerminate);
}

/// Case bindings are unavailable on the pattern-failure path.
@test fn testCaseLetElseFallbackCannotUseBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Value { Item(u32) } fn run(value: Value) { let case Value::Item(item) = value else item; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnresolvedSymbol("item"));
}

/// Unsafe pointer dereference requires an unsafe declaration.
@test fn testUnsafePointerOperationRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} fn load(pointer: *unsafe u32) -> u32 { return *pointer; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
}

/// Unsafe pointers remain freely copyable inside an unsafe declaration.
@test fn testUnsafePointerOperationAllowed() throws (testing::TestError) {
    let program = "record Marker: Linear {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; }";
    try expectAnalyzeOk(program);
}

/// Safe code cannot call a function that accepts unsafe operations.
@test fn testUnsafeFunctionCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } fn run(pointer: *unsafe u32) -> u32 { return load(pointer); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// Unsafe function values retain their call-site safety requirement.
@test fn testUnsafeFunctionAliasCallRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "unsafe fn dangerous() -> u32 { return 42; } fn run() -> u32 { let alias = dangerous; return alias(); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::UnsafeCall);
}

/// References cannot be embedded in aggregate fields.
@test fn testRefFieldRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} record Bad { value: &u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
}

/// Trait methods may use reference receivers.
@test fn testTraitRefReceiver() throws (testing::TestError) {
    let program = "record Marker: Linear {} record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: &Value) get() -> i32 { return value.number; } } fn inspect(object: &opaque Read) -> i32 { return object.get(); } fn call(value: &Value) -> i32 { return inspect(value); }";
    try expectAnalyzeOk(program);
}

/// Trait implementations must preserve the receiver pointer class.
@test fn testTraitReceiverClassMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value { number: i32 } trait Read { fn (&Read) get() -> i32; } instance Read for Value { fn (value: *Value) get() -> i32 { return value.number; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitReceiverMismatch);
}

/// The compiler-known marker cannot be derived more than once.
@test fn testDuplicateLinearMarkerRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Token: Linear + Linear { value: u32 }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::DuplicateBinding("Linear"));
}

/// A `Linear` marker does not change legacy pointer inference.
@test fn testLinearMarkerKeepsLegacyPointerInference() throws (testing::TestError) {
    let program = "record Marker: Linear {} fn run() { let value: u32 = 0; let pointer: *u32 = &value; pointer; }";
    try expectAnalyzeOk(program);
}

/// References are rejected from every nested or storable type position.
@test fn testNestedRefPositionsRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Linear {} union Bad { Value(&u32) }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn bad(value: ?&u32) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn bad(value: [&u32; 1]) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn bad(value: *&u32) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} static BAD: &u32 = undefined;";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn bad(callback: fn() -> &u32) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::InvalidRefPosition);
    }
}

/// Function pointer parameter references remain call-scoped and valid.
@test fn testFunctionPointerRefParameterAllowed() throws (testing::TestError) {
    let program = "record Marker: Linear {} fn invoke(callback: fn(&u32), value: &u32) { callback(value); }";
    try expectAnalyzeOk(program);
}

/// Pointer and slice casts cannot change reference ownership.
@test fn testRefCastClassPreserved() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn cast(value: &u32) { value as *u32; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn cast(values: &[u32]) { values as *[u32]; }";
        let result = try resolveProgramStr(&mut a, program);
        let err = try expectError(&result);
        let case super::ErrorKind::InvalidAsCast(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Every operation that interprets an unsafe address requires an unsafe declaration.
@test fn testUnsafePointerOperationsRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn cast(pointer: *unsafe u32) -> u64 { return pointer as u64; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn compare(pointer: *unsafe u32) -> bool { return pointer == pointer; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn offset(pointer: *unsafe u32) -> *unsafe u32 { return pointer + 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn index(values: *unsafe [u32]) -> u32 { return values[0]; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} record Cell { value: u32 } fn field(cell: *unsafe Cell) -> u32 { return cell.value; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn store(pointer: *unsafe mut u32) { set *pointer = 1; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    } {
        let mut a = testResolver();
        let program = "record Marker: Linear {} fn cast() { let value: u32 = 0; let pointer = &value as *unsafe u32; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::UnsafeOperation);
    }
}

/// Unsafe declarations may compose unsafe operations and calls.
@test fn testUnsafePointerOperationsAllowed() throws (testing::TestError) {
    let program = "record Marker: Linear {} unsafe fn load(pointer: *unsafe u32) -> u32 { return *pointer; } unsafe fn run(pointer: *unsafe u32) -> u32 { let next = pointer + 1; let same = pointer == next; return load(pointer); }";
    try expectAnalyzeOk(program);
}

/// Unsafe code may drop a checked reference to an unsafe pointer.
@test fn testUnsafePointerFromReference() throws (testing::TestError) {
    let program = "record Marker: Linear {} unsafe fn store(pointer: *unsafe mut u32) { set *pointer = 42; } unsafe fn run() { let mut value: u32 = 0; store(&mut value as *unsafe mut u32); }";
    try expectAnalyzeOk(program);
}

/// Dropping a reference to an unsafe pointer cannot add mutability.
@test fn testUnsafePointerCastCannotAddMutability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} unsafe fn run(value: &u32) { value as *unsafe mut u32; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Recursive cast validation cannot hide a checked-to-unsafe transition.
@test fn testNestedUnsafePointerCastRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} fn run(value: **u32) { value as **unsafe u32; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Unsafe code may drop a checked slice reference to an unsafe slice.
@test fn testUnsafeSliceFromReference() throws (testing::TestError) {
    let program = "record Marker: Linear {} unsafe fn run(values: &[u32]) { let raw: *unsafe [u32] = values as *unsafe [u32]; }";
    try expectAnalyzeOk(program);
}

/// Slice casts cannot add mutability.
@test fn testSliceCastCannotAddMutability() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} fn run(values: &[u32]) { values as &mut [u32]; }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::InvalidAsCast(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Mutable unsafe receivers do not create checked exclusive loans.
@test fn testUnsafeReceiverDoesNotBorrowExclusively() throws (testing::TestError) {
    let program = "record Marker: Linear {} record Value { number: u32 } unsafe fn (value: *unsafe mut Value) update(other: *unsafe mut Value) {} unsafe fn run(value: *unsafe mut Value) { value.update(value); }";
    try expectAnalyzeOk(program);
}

/// Unsafe instance-method attributes enable unsafe operations in the body.
@test fn testUnsafeInstanceMethodBody() throws (testing::TestError) {
    let program = "record Marker: Linear {} record Value { number: u32 } trait Read { unsafe fn (*unsafe Read) get() -> u32; } instance Read for Value { unsafe fn (value: *unsafe Value) get() -> u32 { return value.number; } }";
    try expectAnalyzeOk(program);
}

/// Unsafe instance methods cannot implement safe trait contracts.
@test fn testUnsafeInstanceMethodSafetyMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Value {} trait Read { fn (&Read) get(); } instance Read for Value { unsafe fn (value: &Value) get() {} }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::TraitMethodSafetyMismatch);
}

/// Unsafe trait methods retain their call-site requirement through dispatch.
@test fn testUnsafeTraitMethodCallRejected() 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);
}

94	100		name: *[u8],
95	101		/// Function type excluding the receiver.
96	102		fnType: *FnType,
97	103		/// Whether the receiver is mutable.
98	104		mutable: bool,
	105	+	/// Pointer-like class used by the receiver.
	106	+	receiverClass: types::PointerClass,
99	107		/// Symbol for the method.
100	108		symbol: *mut Symbol,
101	109		}
102	110
103	111		/// Identifier for the synthetic `len` field.

160	168		export record RecordType {
161	169		fields: *[RecordField],
162	170		labeled: bool,
163	171		/// Cached layout.
164	172		layout: Layout,
	173	+	/// Whether the declaration explicitly carries the `Linear` marker.
	174	+	declaredLinear: bool,
165	175		}
166	176
167	177		/// Union nominal type.
168	178		export record UnionType {
169	179		variants: *[UnionVariant],

171	181		layout: Layout,
172	182		/// Cached payload offset within the union aggregate.
173	183		valOffset: u32,
174	184		/// If all variants have void payloads.
175	185		isAllVoid: bool,
	186	+	/// Whether the declaration explicitly carries the `Linear` marker.
	187	+	declaredLinear: bool,
176	188		}
177	189
178	190		/// Metadata for user-defined types.
179	191		export union NominalType {
180	192		/// Placeholder for a type that hasn't been fully resolved yet.

259	271		/// Resolved function signature details.
260	272		export record FnType {
261	273		paramTypes: [Type],
262	274		returnType: *Type,
263	275		throwList: [Type],
	276	+	/// Whether calling this function requires an unsafe context.
	277	+	isUnsafe: bool,
264	278		localCount: u32,
265	279		}
266	280
267	281		/// Describes a type computed during semantic analysis.
268	282		export union Type {

277	291		/// Range types, eg. `start..end`.
278	292		Range {
279	293		start: ?*Type,
280	294		end: ?*Type,
281	295		},
282		-	/// Pointer-like address.
	296	+	/// Owning pointer-like address.
283	297		Pointer {
284	298		class: types::PointerClass,
285	299		target: *Type,
286	300		mutable: bool,
287	301		},
288		-	/// Pointer-like slice.
	302	+	/// Owning slice.
289	303		Slice {
290	304		class: types::PointerClass,
291	305		item: *Type,
292	306		mutable: bool,
293	307		},

37	37
38	38		/// AST arena size (32 MB) - retains parsed nodes throughout compilation.
39	39		constant TEMP_ARENA_SIZE: u32 = 33554432;
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 (96 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 = 100663296;
45	45
46	46		/// AST storage arena.
47	47		static TEMP_ARENA: [u8; TEMP_ARENA_SIZE] = undefined;
48	48		/// Scratch storage reclaimed after each generated function.
49	49		static FN_ARENA: [u8; FN_ARENA_SIZE] = undefined;

45	45		export constant MAX_LOOP_DEPTH: u32 = 16;
46	46		/// Maximum trait instances.
47	47		export constant MAX_INSTANCES: u32 = 128;
48	48		/// Maximum standalone methods (across all types).
49	49		export constant MAX_METHODS: u32 = 256;
	50	+	/// Maximum number of linear bindings active in one function.
	51	+	constant MAX_LINEAR_BINDINGS: u32 = 32;
	52	+	/// Maximum nesting depth tracked for loops.
	53	+	constant MAX_LINEAR_LOOP_DEPTH: u32 = 16;
50	54
51	55		/// Trait definition stored in the resolver.
52	56		export record TraitType {
53	57		/// Trait name.
54	58		name: *[u8],

64	68		name: *[u8],
65	69		/// Function type for the method, excluding the receiver.
66	70		fnType: *FnType,
67	71		/// Whether the receiver is mutable.
68	72		mutable: bool,
	73	+	/// Pointer-like class used by the receiver.
	74	+	receiverClass: types::PointerClass,
69	75		/// V-table slot index.
70	76		index: u32,
71	77		}
72	78
73	79		/// An entry in the trait instance registry.

297	311		Optional(*Type),
298	312		/// Eg. `fn id(i32) -> i32`.
299	313		Fn(*FnType),
300	314		/// Named, ie. user-defined types, includes union variants.
301	315		Nominal(*NominalType),
302		-	/// An erased pointer-like type with a v-table.
	316	+	/// Owning trait object. An erased type with v-table.
303	317		TraitObject {
304	318		/// Ownership and safety class.
305	319		class: types::PointerClass,
306	320		/// Trait definition.
307	321		traitInfo: *TraitType,

569	583		MissingTraitMethod(*[u8]),
570	584		/// Trait name used as a value expression.
571	585		UnexpectedTraitName,
572	586		/// Trait method receiver does not point to the declaring trait.
573	587		TraitReceiverMismatch,
	588	+	/// Trait declaration and instance disagree about unsafe call requirements.
	589	+	TraitMethodSafetyMismatch,
574	590		/// Function declaration has too many parameters.
575	591		FnParamOverflow(CountMismatch),
576	592		/// Function declaration has too many throws.
577	593		FnThrowOverflow(CountMismatch),
578	594		/// Trait declaration has too many methods.
579	595		TraitMethodOverflow(CountMismatch),
580	596		/// Instance declaration is missing a required supertrait instance.
581	597		MissingSupertraitInstance(*[u8]),
	598	+	/// Linear binding was consumed more than once.
	599	+	LinearUseAfterConsume(*[u8]),
	600	+	/// Linear binding remains available at an exit.
	601	+	LinearNotConsumed(*[u8]),
	602	+	/// A case-pattern `let-else` fallback must terminate control flow.
	603	+	LinearLetElseMustTerminate,
	604	+	/// Branches disagree about a linear binding's state.
	605	+	LinearBranchMismatch(*[u8]),
	606	+	/// A linear field cannot be moved independently.
	607	+	LinearPartialMove,
	608	+	/// A linear value cannot be discarded.
	609	+	LinearDiscard,
	610	+	/// Assignment would overwrite a live linear value.
	611	+	LinearOverwrite,
	612	+	/// `undefined` cannot initialize a linear type.
	613	+	LinearUndefined,
	614	+	/// A reference appears in a storable or escaping position.
	615	+	InvalidRefPosition,
	616	+	/// A reference cannot be bound to a local.
	617	+	RefBinding,
	618	+	/// Call arguments contain overlapping incompatible loans.
	619	+	BorrowConflict(*[u8]),
	620	+	/// Unsafe pointer operation outside an `unsafe` declaration.
	621	+	UnsafeOperation,
	622	+	/// Safe code cannot call an `unsafe` function.
	623	+	UnsafeCall,
582	624		/// Internal error.
583	625		Internal,
584	626		}
585	627
586	628		/// Diagnostics returned by the analyzer.

728	770		effectiveTy: Type,
729	771		/// How bindings should be created.
730	772		by: MatchBy,
731	773		}
732	774
	775	+	/// How an expression uses a linear result.
	776	+	union LinearUse {
	777	+	/// Consume the value and end its availability.
	778	+	Consume,
	779	+	/// Read the value without consuming it.
	780	+	Observe,
	781	+	/// Borrow the value through a reference.
	782	+	Borrow,
	783	+	/// Discard an unused expression result.
	784	+	Discard,
	785	+	/// Use the value as an assignment target.
	786	+	Place,
	787	+	}
	788	+
	789	+	/// Per-control-flow-path ownership state.
	790	+	record LinearEnv {
	791	+	/// Symbols tracked on this control-flow path.
	792	+	symbols: [?*mut Symbol; MAX_LINEAR_BINDINGS],
	793	+	/// Bit set for each binding that remains available.
	794	+	available: u64,
	795	+	/// Number of entries in `symbols`.
	796	+	len: u32,
	797	+	/// Whether this control-flow path has terminated.
	798	+	terminated: bool,
	799	+	}
	800	+
	801	+	/// Function-local exact-use checker state.
	802	+	record LinearChecker {
	803	+	/// Resolver that owns the symbols and diagnostics.
	804	+	resolver: *mut Resolver,
	805	+	/// Binding count at entry to each active loop.
	806	+	loopMarks: [u32; MAX_LINEAR_LOOP_DEPTH],
	807	+	/// Available bindings at entry to each active loop.
	808	+	loopAvailable: [u64; MAX_LINEAR_LOOP_DEPTH],
	809	+	/// Available bindings shared by the exits from each active loop.
	810	+	loopExitAvailable: [u64; MAX_LINEAR_LOOP_DEPTH],
	811	+	/// Whether each active loop can exit without `break`.
	812	+	loopHasNaturalExit: [bool; MAX_LINEAR_LOOP_DEPTH],
	813	+	/// Whether each active loop contains a reachable `break`.
	814	+	loopBreakSeen: [bool; MAX_LINEAR_LOOP_DEPTH],
	815	+	/// Number of active loops.
	816	+	loopDepth: u32,
	817	+	}
	818	+
733	819		/// Unwrap a pointer type for pattern matching.
734	820		export fn unwrapMatchSubject(ty: Type) -> MatchSubject {
735	821		if let case Type::Pointer { target, mutable, .. } = ty {
736	822		let by = MatchBy::MutRef if mutable else MatchBy::Ref;
737	823		return MatchSubject { effectiveTy: *target, by };

751	837		loopDepth: u32,
752	838		/// Signature of the function currently being analyzed.
753	839		currentFn: ?*FnType,
754	840		/// Current module being analyzed.
755	841		currentMod: u16,
	842	+	/// Nesting depth of unsafe modules and function bodies.
	843	+	unsafeDepth: u32,
756	844		/// Configuration for semantic analysis.
757	845		config: Config,
758	846		/// Unified arena for symbols, scopes, and nominal type.
759	847		arena: alloc::Arena,
760	848		/// Combined semantic metadata table indexed by node ID.

908	996		pkgScope: storage.pkgScope,
909	997		loopStack: undefined,
910	998		loopDepth: 0,
911	999		currentFn: nil,
912	1000		currentMod: 0,
	1001	+	unsafeDepth: 0,
913	1002		config,
914	1003		arena,
915	1004		nodeData: NodeDataTable { entries: storage.nodeData },
916	1005		types: nil,
917	1006		errors: @sliceOf(storage.errors.ptr, 0, storage.errors.len),

1350	1439		}
1351	1440
1352	1441		/// Get the layout of a type.
1353	1442		export fn getTypeLayout(ty: Type) -> Layout {
1354	1443		match ty {
	1444	+	case Type::Pointer { .. } => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
	1445	+	case Type::Slice { .. }, Type::TraitObject { .. } =>
	1446	+	return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
1355	1447		case Type::Void, Type::Never => return Layout { size: 0, alignment: 0 },
1356	1448		case Type::Bool, Type::U8, Type::I8 => return Layout { size: 1, alignment: 1 },
1357	1449		case Type::U16, Type::I16 => return Layout { size: 2, alignment: 2 },
1358	1450		case Type::U32, Type::I32 => return Layout { size: 4, alignment: 4 },
1359	1451		case Type::Int => return Layout { size: 8, alignment: 8 },
1360	1452		case Type::U64, Type::I64 => return Layout { size: 8, alignment: 8 },
1361		-	case Type::Pointer { .. },
1362		-	Type::Fn(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
1363		-	case Type::Slice { .. },
1364		-	Type::TraitObject { .. } => return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
	1453	+	case Type::Fn(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
1365	1454		case Type::Array(arr) => return getArrayLayout(arr),
1366	1455		case Type::Optional(inner) => return getOptionalLayout(*inner),
1367	1456		case Type::Nominal(info) => return getNominalLayout(*info),
1368	1457		else => {
1369	1458		panic "getTypeLayout: the given type cannot be layed out";

1528	1617		return unionType.isAllVoid;
1529	1618		}
1530	1619
1531	1620		/// Check if a type should be treated as an address-like value.
1532	1621		fn isAddressType(ty: Type) -> bool {
	1622	+	if isNullableType(ty) {
	1623	+	return true;
	1624	+	}
1533	1625		match ty {
1534		-	case Type::Pointer { .. }, Type::Slice { .. }, Type::Fn(_) => return true,
	1626	+	case Type::Fn(_) => return true,
1535	1627		else => return false,
1536	1628		}
1537	1629		}
1538	1630
1539	1631		/// Return the representable range for an integer type.

3335	3625		}
3336	3626		traitType.methods.append(TraitMethod {
3337	3627		name: inherited.name,
3338	3628		fnType: inherited.fnType,
3339	3629		mutable: inherited.mutable,
	3630	+	receiverClass: inherited.receiverClass,
3340	3631		index: traitType.methods.len as u32,
3341	3632		}, a);
3342	3633		}
3343	3634		traitType.supertraits.append(superTrait, a);
3344	3635		}

1602	1694
1603	1695		/// Ensure all nested nominal types in a type are resolved.
1604	1696		fn ensureTypeResolved(self: mut Resolver, ty: Type, site: ast::Node) throws (ResolveError) {
1605	1697		match ty {
1606	1698		case Type::Nominal(info) => try ensureNominalResolved(self, info, site),
1607		-	case Type::Array(arr) => try ensureTypeResolved(self, *arr.item, site),
1608	1699		case Type::Slice { item, .. } => try ensureTypeResolved(self, *item, site),
1609	1700		case Type::Pointer { .. } => {}, // Pointers have fixed layout, don't recurse.
	1701	+	case Type::Array(arr) => try ensureTypeResolved(self, *arr.item, site),
1610	1702		case Type::Optional(inner) => try ensureTypeResolved(self, *inner, site),
1611	1703		else => {},
1612	1704		}
1613	1705		}
1614	1706

1659	1751		}
1660	1752		}
1661	1753		return true;
1662	1754		}
1663	1755
	1756	+	/// Return whether pointer classes are compatible.
	1757	+	fn pointerClassesAssignable(
	1758	+	to: types::PointerClass,
	1759	+	from: types::PointerClass,
	1760	+	) -> bool {
	1761	+	return to == from or (
	1762	+	to == types::PointerClass::Owned
	1763	+	and from == types::PointerClass::Ref
	1764	+	);
	1765	+	}
	1766	+
1664	1767		/// Check if the `from` type is assignable to the `to` type, and return a
1665	1768		/// coercion plan if so.
1666	1769		fn isAssignable(self: mut Resolver, to: Type, from: Type, rval: ast::Node) -> ?Coercion {
1667	1770		if to == Type::Unknown or from == Type::Unknown {
1668	1771		return nil;

1678	1781		return Coercion::Identity;
1679	1782		}
1680	1783		if to == from {
1681	1784		return Coercion::Identity;
1682	1785		}
	1786	+	if let case Type::Pointer { class: lhsClass, target: lhsTarget, mutable: lhsMutable } = to {
	1787	+	let case Type::Pointer { class: rhsClass, target: rhsTarget, mutable: rhsMutable } = from
	1788	+	else return nil;
	1789	+	if not pointerClassesAssignable(lhsClass, rhsClass) {
	1790	+	return nil;
	1791	+	}
	1792	+	// Allow coercion from `T` to `opaque`, and mutable counterparts.
	1793	+	if *lhsTarget == Type::Opaque {
	1794	+	if lhsMutable and not rhsMutable {
	1795	+	return nil;
	1796	+	}
	1797	+	return Coercion::Identity;
	1798	+	}
	1799	+	if lhsMutable and not rhsMutable {
	1800	+	return nil;
	1801	+	}
	1802	+	return isAssignable(self, lhsTarget, rhsTarget, rval);
	1803	+	}
	1804	+	if let case Type::TraitObject { class: lhsClass, traitInfo: lhsTraitInfo, mutable: lhsMutable } = to {
	1805	+	if let case Type::Pointer { class: rhsClass, target: rhsTarget, mutable: rhsMutable } = from {
	1806	+	if not pointerClassesAssignable(lhsClass, rhsClass)
	1807	+	or (lhsMutable and not rhsMutable)
	1808	+	{
	1809	+	return nil;
	1810	+	}
	1811	+	if let inst = findInstance(self, lhsTraitInfo, *rhsTarget) {
	1812	+	return Coercion::TraitObject { traitInfo: lhsTraitInfo, inst };
	1813	+	}
	1814	+	}
	1815	+	if let case Type::TraitObject { class: rhsClass, traitInfo: rhsTraitInfo, mutable: rhsMutable } = from {
	1816	+	if not pointerClassesAssignable(lhsClass, rhsClass)
	1817	+	or lhsTraitInfo <> rhsTraitInfo
	1818	+	{
	1819	+	return nil;
	1820	+	}
	1821	+	if lhsMutable and not rhsMutable {
	1822	+	return nil;
	1823	+	}
	1824	+	return Coercion::Identity;
	1825	+	}
	1826	+	return nil;
	1827	+	}
	1828	+	if let case Type::Slice { class: lhsClass, item: lhsItem, mutable: lhsMutable } = to {
	1829	+	let case Type::Slice { class: rhsClass, item: rhsItem, mutable: rhsMutable } = from
	1830	+	else return nil;
	1831	+	if not pointerClassesAssignable(lhsClass, rhsClass)
	1832	+	or (lhsMutable and not rhsMutable)
	1833	+	{
	1834	+	return nil;
	1835	+	}
	1836	+	// Allow coercion from `[T]` to `[opaque]`, and mutable counterparts.
	1837	+	if *lhsItem == Type::Opaque {
	1838	+	return Coercion::Identity;
	1839	+	}
	1840	+	return isAssignable(self, lhsItem, rhsItem, rval);
	1841	+	}
1683	1842		match to {
1684	1843		case Type::Array(lhs) => {
1685	1844		let case Type::Array(rhs) = from
1686	1845		else return nil;
1687	1846

1712	1871		}
1713	1872		return nil;
1714	1873		}
1715	1874		}
1716	1875		}
1717		-	case Type::Pointer { target: lhsTarget, mutable: lhsMutable, .. } => {
1718		-	let case Type::Pointer { target: rhsTarget, mutable: rhsMutable, .. } = from
1719		-	else return nil;
1720	1876
1721		-	// Allow coercion from `T` to `opaque`, and `mut T` to `mut opaque`.
1722		-	if *lhsTarget == Type::Opaque {
1723		-	if lhsMutable and not rhsMutable {
1724		-	return nil;
1725		-	}
1726		-	return Coercion::Identity;
1727		-	}
1728		-	if lhsMutable and not rhsMutable {
1729		-	return nil;
1730		-	}
1731		-	return isAssignable(self, lhsTarget, rhsTarget, rval);
1732		-	}
1733	1877		case Type::Optional(inner) => {
1734	1878		if from == Type::Nil {
1735	1879		return Coercion::OptionalLift(to);
1736	1880		}
1737	1881		if let _ = isAssignable(self, *inner, from, rval) {

1740	1884		if let case Type::Optional(fromInner) = from {
1741	1885		return isAssignable(self, inner, fromInner, rval);
1742	1886		}
1743	1887		return nil;
1744	1888		}
1745		-	case Type::TraitObject {
1746		-	class: lhsClass, traitInfo, mutable: lhsMutable,
1747		-	} => {
1748		-	// Coerce `T` or `mut T` where `T` implements the trait.
1749		-	if let case Type::Pointer { target, mutable: rhsMutable, .. } = from {
1750		-	if lhsMutable and not rhsMutable {
1751		-	return nil;
1752		-	}
1753		-	// Look up instance registry.
1754		-	if let inst = findInstance(self, traitInfo, *target) {
1755		-	return Coercion::TraitObject { traitInfo, inst };
1756		-	}
1757		-	}
1758		-	// Identity: same trait object.
1759		-	if let case Type::TraitObject {
1760		-	class: rhsClass, traitInfo: rhsTrait, mutable: rhsMutable,
1761		-	} = from {
1762		-	if lhsClass <> rhsClass or traitInfo <> rhsTrait {
1763		-	return nil;
1764		-	}
1765		-	if lhsMutable and not rhsMutable {
1766		-	return nil;
1767		-	}
1768		-	return Coercion::Identity;
1769		-	}
1770		-	return nil;
1771		-	}
1772		-	case Type::Slice { class: lhsClass, item: lhsItem, mutable: lhsMutable } => {
1773		-	match from {
1774		-	case Type::Slice { class: rhsClass, item: rhsItem, mutable: rhsMutable } => {
1775		-	if lhsClass <> rhsClass {
1776		-	return nil;
1777		-	}
1778		-	if lhsMutable and not rhsMutable {
1779		-	return nil;
1780		-	}
1781		-	// Allow coercion from `[T]` to `[opaque]`, and `mut [T]` to `mut [opaque]`.
1782		-	if *lhsItem == Type::Opaque {
1783		-	return Coercion::Identity;
1784		-	}
1785		-	return isAssignable(self, lhsItem, rhsItem, rval);
1786		-	}
1787		-	else => return nil,
1788		-	}
1789		-	}
	1889	+
1790	1890		case Type::Fn(toInfo) => {
1791	1891		// Allow function type structural matching.
1792	1892		if let case Type::Fn(fromInfo) = from {
1793	1893		if fnTypeEqual(toInfo, fromInfo) {
1794	1894		return Coercion::Identity;

1829	1929		return nil;
1830	1930		}
1831	1931
1832	1932		/// Check if two function type descriptors are structurally equivalent.
1833	1933		fn fnTypeEqual(a: FnType, b: FnType) -> bool {
	1934	+	if a.isUnsafe <> b.isUnsafe {
	1935	+	return false;
	1936	+	}
1834	1937		if a.paramTypes.len <> b.paramTypes.len {
1835	1938		return false;
1836	1939		}
1837	1940		if a.throwList.len <> b.throwList.len {
1838	1941		return false;

1856	1959		/// Check if two types are structurally equal.
1857	1960		export fn typesEqual(a: Type, b: Type) -> bool {
1858	1961		if a == b {
1859	1962		return true;
1860	1963		}
	1964	+	if let case Type::Pointer { class: aClass, target: aTarget, mutable: aMutable } = a {
	1965	+	let case Type::Pointer { class: bClass, target: bTarget, mutable: bMutable } = b
	1966	+	else return false;
	1967	+	return aClass == bClass and aMutable == bMutable
	1968	+	and typesEqual(aTarget, bTarget);
	1969	+	}
	1970	+	if let case Type::Slice { class: aClass, item: aItem, mutable: aMutable } = a {
	1971	+	let case Type::Slice { class: bClass, item: bItem, mutable: bMutable } = b
	1972	+	else return false;
	1973	+	return aClass == bClass and aMutable == bMutable
	1974	+	and typesEqual(aItem, bItem);
	1975	+	}
	1976	+	if let case Type::TraitObject { class: aClass, traitInfo: aTraitInfo, mutable: aMutable } = a {
	1977	+	let case Type::TraitObject { class: bClass, traitInfo: bTraitInfo, mutable: bMutable } = b
	1978	+	else return false;
	1979	+	return aClass == bClass and aMutable == bMutable
	1980	+	and aTraitInfo == bTraitInfo;
	1981	+	}
1861	1982		match a {
1862		-	case Type::Pointer { class: aClass, target: aTarget, mutable: aMutable } => {
1863		-	let case Type::Pointer { class: bClass, target: bTarget, mutable: bMutable } = b
1864		-	else return false;
1865		-	return aClass == bClass and aMutable == bMutable and typesEqual(aTarget, bTarget);
1866		-	}
1867		-	case Type::Slice { class: aClass, item: aItem, mutable: aMutable } => {
1868		-	let case Type::Slice { class: bClass, item: bItem, mutable: bMutable } = b
1869		-	else return false;
1870		-	return aClass == bClass and aMutable == bMutable and typesEqual(aItem, bItem);
1871		-	}
1872	1983		case Type::Array(aa) => {
1873	1984		let case Type::Array(ab) = b else return false;
1874	1985		return aa.length == ab.length and typesEqual(aa.item, ab.item);
1875	1986		}
1876	1987		case Type::Optional(oa) => {

1883	1994		}
1884	1995		else => return false,
1885	1996		}
1886	1997		}
1887	1998
	1999	+	/// Return whether `ty` is a direct reference.
	2000	+	export fn isRefType(ty: Type) -> bool {
	2001	+	match ty {
	2002	+	case Type::Pointer { class: types::PointerClass::Ref, .. },
	2003	+	Type::Slice { class: types::PointerClass::Ref, .. },
	2004	+	Type::TraitObject { class: types::PointerClass::Ref, .. } => return true,
	2005	+	else => return false,
	2006	+	}
	2007	+	}
	2008	+
	2009	+	/// Return whether a type contains a reference.
	2010	+	fn containsRef(ty: Type) -> bool {
	2011	+	if isRefType(ty) {
	2012	+	return true;
	2013	+	}
	2014	+	if let case Type::Pointer { target, .. } = ty {
	2015	+	return containsRef(*target);
	2016	+	}
	2017	+	if let case Type::Slice { item, .. } = ty {
	2018	+	return containsRef(*item);
	2019	+	}
	2020	+	match ty {
	2021	+	case Type::Array(array) => return containsRef(*array.item),
	2022	+	case Type::Optional(inner) => return containsRef(*inner),
	2023	+	// Nominal declarations validate their own fields and variants.
	2024	+	// Treating them as leaves also terminates recursive pointer types.
	2025	+	case Type::Nominal(_) => return false,
	2026	+	else => return false,
	2027	+	}
	2028	+	}
	2029	+
	2030	+	/// Return whether a type is exact-linear.
	2031	+	export fn isLinear(ty: Type) -> bool {
	2032	+	match ty {
	2033	+	case Type::Pointer { class: types::PointerClass::Owned, .. },
	2034	+	Type::Slice { class: types::PointerClass::Owned, .. },
	2035	+	Type::TraitObject { class: types::PointerClass::Owned, .. } => return true,
	2036	+	case Type::Pointer { class: types::PointerClass::Ref, .. },
	2037	+	Type::Pointer { class: types::PointerClass::Unsafe, .. },
	2038	+	Type::Slice { class: types::PointerClass::Ref, .. },
	2039	+	Type::Slice { class: types::PointerClass::Unsafe, .. },
	2040	+	Type::TraitObject { class: types::PointerClass::Ref, .. },
	2041	+	Type::TraitObject { class: types::PointerClass::Unsafe, .. } => return false,
	2042	+
	2043	+	case Type::Array(array) => return isLinear(*array.item),
	2044	+	case Type::Optional(inner) => return isLinear(*inner),
	2045	+	case Type::Nominal(NominalType::Record(recInfo)) => {
	2046	+	if recInfo.declaredLinear {
	2047	+	return true;
	2048	+	}
	2049	+	for field in recInfo.fields {
	2050	+	if isLinear(field.fieldType) {
	2051	+	return true;
	2052	+	}
	2053	+	}
	2054	+	return false;
	2055	+	}
	2056	+	case Type::Nominal(NominalType::Union(unionType)) => {
	2057	+	if unionType.declaredLinear {
	2058	+	return true;
	2059	+	}
	2060	+	for variant in unionType.variants {
	2061	+	if isLinear(variant.valueType) {
	2062	+	return true;
	2063	+	}
	2064	+	}
	2065	+	return false;
	2066	+	}
	2067	+	else => return false,
	2068	+	}
	2069	+	}
	2070	+
	2071	+	/// Return whether `ty` is a direct unsafe pointer-like value.
	2072	+	fn isUnsafePointerType(ty: Type) -> bool {
	2073	+	match ty {
	2074	+	case Type::Pointer { class: types::PointerClass::Unsafe, .. },
	2075	+	Type::Slice { class: types::PointerClass::Unsafe, .. },
	2076	+	Type::TraitObject { class: types::PointerClass::Unsafe, .. } => return true,
	2077	+	else => return false,
	2078	+	}
	2079	+	}
	2080	+
1888	2081		/// Get the record info from a record type.
1889	2082		export fn getRecord(ty: Type) -> ?RecordType {
1890	2083		let case Type::Nominal(NominalType::Record(recInfo)) = ty else return nil;
1891	2084		return recInfo;
1892	2085		}

1899	2092		return ty;
1900	2093		}
1901	2094
1902	2095		/// Get field info for a record-like type (records, slices) by field index.
1903	2096		export fn getRecordField(ty: Type, index: u32) -> ?RecordField {
1904		-	match ty {
1905		-	case Type::Nominal(NominalType::Record(recInfo)) => {
1906		-	if index >= recInfo.fields.len {
1907		-	return nil;
1908		-	}
1909		-	return recInfo.fields[index];
1910		-	}
1911		-	case Type::Slice { item, mutable, .. } => {
1912		-	match index {
1913		-	case 0 => return RecordField {
1914		-	name: PTR_FIELD,
1915		-	fieldType: Type::Pointer {
1916		-	class: types::PointerClass::Owned, target: item, mutable,
1917		-	},
1918		-	offset: 0,
1919		-	},
1920		-	case 1 => return RecordField {
1921		-	name: LEN_FIELD,
1922		-	fieldType: Type::U32,
1923		-	offset: PTR_SIZE as i32,
1924		-	},
1925		-	case 2 => return RecordField {
1926		-	name: CAP_FIELD,
1927		-	fieldType: Type::U32,
1928		-	offset: PTR_SIZE as i32 + 4,
1929		-	},
1930		-	else => return nil,
1931		-	}
1932		-	}
1933		-	else => return nil,
	2097	+	if let case Type::Slice { class, item, mutable } = ty {
	2098	+	match index {
	2099	+	case 0 => return RecordField {
	2100	+	name: PTR_FIELD,
	2101	+	fieldType: Type::Pointer { class, target: item, mutable },
	2102	+	offset: 0,
	2103	+	},
	2104	+	case 1 => return RecordField {
	2105	+	name: LEN_FIELD,
	2106	+	fieldType: Type::U32,
	2107	+	offset: PTR_SIZE as i32,
	2108	+	},
	2109	+	case 2 => return RecordField {
	2110	+	name: CAP_FIELD,
	2111	+	fieldType: Type::U32,
	2112	+	offset: PTR_SIZE as i32 + 4,
	2113	+	},
	2114	+	else => return nil,
	2115	+	}
	2116	+	}
	2117	+	if let case Type::Nominal(NominalType::Record(recInfo)) = ty;
	2118	+	index < recInfo.fields.len
	2119	+	{
	2120	+	return recInfo.fields[index];
1934	2121		}
	2122	+	return nil;
1935	2123		}
1936	2124
1937	2125		/// Check if the two types can be compared for equality.
1938	2126		fn isComparable(left: Type, right: Type) -> bool {
1939	2127		if left == Type::Unknown or right == Type::Unknown {

2330	2518		scope: *Scope
2331	2519		) -> *mut Symbol throws (ResolveError) {
2332	2520		assert path.len <> 0, "resolvePath: empty path";
2333	2521		// Start by finding the root of the path.
2334	2522		let root = path[0];
2335		-	let sym = findInScopeRecursive(scope, root, isAnySymbol) else
2336		-	throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));
	2523	+	let sym = findInScopeRecursive(scope, root, isAnySymbol)
	2524	+	else throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));
2337	2525		let suffix = &path[1..];
2338	2526
2339	2527		// Check visibility for symbol.
2340	2528		if not isSymbolVisible(sym, scope, self.scope) {
2341	2529		throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));

2484	2672		// Ignore non-declaration nodes.
2485	2673		}
2486	2674		}
2487	2675		}
2488	2676
	2677	+	/// Require the current declaration to be unsafe.
	2678	+	fn requireUnsafe(self: mut Resolver, node: ast::Node) throws (ResolveError) {
	2679	+	if self.unsafeDepth == 0 {
	2680	+	throw emitError(self, node, ErrorKind::UnsafeOperation);
	2681	+	}
	2682	+	}
	2683	+
	2684	+	/// Reject calls from safe code through unsafe function types.
	2685	+	fn checkUnsafeCall(self: mut Resolver, node: ast::Node, info: *FnType)
	2686	+	throws (ResolveError)
	2687	+	{
	2688	+	if info.isUnsafe and self.unsafeDepth == 0 {
	2689	+	throw emitError(self, node, ErrorKind::UnsafeCall);
	2690	+	}
	2691	+	}
	2692	+
2489	2693		/// Visit a top-level definition, recursing into sub-modules.
2490	2694		fn visitDef(self: mut Resolver, node: ast::Node) throws (ResolveError) {
2491	2695		match node.value {
2492	2696		case ast::NodeValue::FnDecl(decl) => {
2493	2697		try resolveFnDeclBody(self, node, decl) catch {

2500	2704		}
2501	2705		let modName = try nodeName(self, decl.name);
2502	2706		let submod = try enterSubModule(self, modName, node);
2503	2707		let case ast::NodeValue::Block(block) = submod.root.value
2504	2708		else panic "visitDef: expected block for module root";
2505		-	try resolveModuleDefs(self, &block);
	2709	+	let mut isUnsafe = false;
	2710	+	if let attrs = decl.attrs {
	2711	+	set isUnsafe = ast::attributesContains(&attrs, ast::Attribute::Unsafe);
	2712	+	}
	2713	+	if isUnsafe {
	2714	+	set self.unsafeDepth += 1;
	2715	+	}
	2716	+	try resolveModuleDefs(self, &block) catch e {
	2717	+	if isUnsafe { set self.unsafeDepth -= 1; }
	2718	+	exitModuleScope(self, submod);
	2719	+	throw e;
	2720	+	};
	2721	+	if isUnsafe {
	2722	+	set self.unsafeDepth -= 1;
	2723	+	}
2506	2724		exitModuleScope(self, submod);
2507	2725		}
2508	2726		case ast::NodeValue::RecordDecl(_),
2509	2727		ast::NodeValue::UnionDecl(_),
2510	2728		ast::NodeValue::Use(_),

2532	2750		/// Try to infer a node's type.
2533	2751		fn infer(self: mut Resolver, node: ast::Node) -> Type throws (ResolveError) {
2534	2752		return try visit(self, node, Type::Unknown);
2535	2753		}
2536	2754
	2755	+	/// Reject nested references while allowing a direct parameter reference.
	2756	+	fn validateValueTypeReferences(self: mut Resolver, node: ast::Node, ty: Type)
	2757	+	throws (ResolveError)
	2758	+	{
	2759	+	if isRefType(ty) {
	2760	+	if let case Type::Pointer { target, .. } = ty {
	2761	+	if containsRef(*target) {
	2762	+	throw emitError(self, node, ErrorKind::InvalidRefPosition);
	2763	+	}
	2764	+	} else if let case Type::Slice { item, .. } = ty {
	2765	+	if containsRef(*item) {
	2766	+	throw emitError(self, node, ErrorKind::InvalidRefPosition);
	2767	+	}
	2768	+	}
	2769	+	} else if containsRef(ty) {
	2770	+	throw emitError(self, node, ErrorKind::InvalidRefPosition);
	2771	+	}
	2772	+	}
	2773	+
	2774	+	/// Require a type that may be stored or escape a call.
	2775	+	fn ensureStorableType(self: mut Resolver, node: ast::Node, ty: Type)
	2776	+	throws (ResolveError)
	2777	+	{
	2778	+	if containsRef(ty) {
	2779	+	throw emitError(self, node, ErrorKind::InvalidRefPosition);
	2780	+	}
	2781	+	}
	2782	+
2537	2783		/// Resolve a type signature node.
2538	2784		fn resolveValueType(self: mut Resolver, node: ast::Node) -> Type throws (ResolveError) {
2539	2785		let ty = try visit(self, node, Type::Unknown);
2540	2786		// Opaque value types are not allowed.
2541	2787		if ty == Type::Opaque {
2542	2788		throw emitError(self, node, ErrorKind::OpaqueTypeNotAllowed);
2543	2789		}
	2790	+	try validateValueTypeReferences(self, node, ty);
2544	2791		return ty;
2545	2792		}
2546	2793
2547	2794		/// Analyze a node's type and check that it can be assigned to the expected type.
2548	2795		fn checkAssignable(self: mut Resolver, node: ast::Node, expected: Type) -> Type throws (ResolveError) {

2636	2883		case ast::NodeValue::Throw { expr } => return try resolveThrow(self, node, expr),
2637	2884		case ast::NodeValue::Panic { message } => {
2638	2885		try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.
2639	2886		class: types::PointerClass::Owned,
2640	2887		item: allocType(self, Type::U8),
2641		-	mutable: false
	2888	+	mutable: false,
2642	2889		});
2643	2890		return setNodeType(self, node, Type::Never);
2644	2891		},
2645	2892		case ast::NodeValue::Assert { condition, message } => {
2646	2893		try visit(self, condition, Type::Bool);
2647	2894		try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.
2648	2895		class: types::PointerClass::Owned,
2649	2896		item: allocType(self, Type::U8),
2650		-	mutable: false
	2897	+	mutable: false,
2651	2898		});
2652	2899		return setNodeType(self, node, Type::Void);
2653	2900		},
2654	2901		case ast::NodeValue::UnOp(unop) => return try resolveUnOp(self, node, unop),
2655	2902		case ast::NodeValue::ExprStmt(expr) => {

2792	3039		if not isTypeInferrable(bindingTy) {
2793	3040		throw emitError(self, decl.value, ErrorKind::CannotInferType);
2794	3041		}
2795	3042		}
2796	3043		// Variables cannot have void type.
	3044	+	if containsRef(bindingTy) {
	3045	+	throw emitError(self, node, ErrorKind::RefBinding);
	3046	+	}
2797	3047		if bindingTy == Type::Void {
2798	3048		throw emitError(self, decl.value, ErrorKind::CannotAssignVoid);
2799	3049		}
2800	3050		// Variables cannot have opaque type directly.
2801	3051		if bindingTy == Type::Opaque {

3029	3279		attrList: ?ast::Attributes,
3030	3280		isConst: bool
3031	3281		) -> Type throws (ResolveError) {
3032	3282		let attrs = resolveAttributes(self, attrList);
3033	3283		let bindingTy = try infer(self, typeNode);
	3284	+	try ensureStorableType(self, typeNode, bindingTy);
3034	3285		let valueTy = try checkAssignable(self, valueNode, bindingTy);
3035	3286
3036	3287		if isConst {
3037	3288		let mut constVal = constValueEntry(self, valueNode);
3038	3289		if constVal == nil and not isConstExpr(self, valueNode) {

3061	3312		{
3062	3313		let attrMask = resolveAttributes(self, decl.attrs);
3063	3314		let mut retTy = Type::Void;
3064	3315		if let retNode = decl.sig.returnType {
3065	3316		set retTy = try infer(self, retNode);
	3317	+	try ensureStorableType(self, retNode, retTy);
3066	3318		}
3067	3319		let a = alloc::arenaAllocator(&mut self.arena);
3068	3320		let mut paramTypes: mut [Type] = &mut [];
3069	3321		let mut throwList: mut [Type] = &mut [];
3070	3322		let mut fnType = FnType {
3071	3323		paramTypes: &[],
3072	3324		returnType: allocType(self, retTy),
3073	3325		throwList: &[],
	3326	+	isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
3074	3327		localCount: 0,
3075	3328		};
3076	3329		// Enter the function scope to process parameters.
3077	3330		enterFn(self, node, &fnType);
3078	3331

3102	3355		let throwTy = try infer(self, throwNode) catch e {
3103	3356		exitFn(self);
3104	3357		throw e;
3105	3358		};
3106	3359		throwList.append(allocType(self, throwTy), a);
	3360	+	try ensureStorableType(self, throwNode, throwTy);
3107	3361		}
3108	3362		exitFn(self);
3109	3363		set fnType.paramTypes = &paramTypes[..];
3110	3364		set fnType.throwList = &throwList[..];
3111	3365

3128	3382		panic "resolveFnDeclBody: unexpected symbol data for function";
3129	3383		};
3130	3384		let retTy = *fnType.returnType;
3131	3385		let isExtern = ast::hasAttribute(sym.attrs, ast::Attribute::Extern);
3132	3386		let isIntrinsic = ast::hasAttribute(sym.attrs, ast::Attribute::Intrinsic);
	3387	+	let isUnsafe = fnType.isUnsafe;
3133	3388
3134	3389		if let body = decl.body {
3135	3390		if isIntrinsic {
3136	3391		throw emitError(self, node, ErrorKind::IntrinsicUnexpectedBody);
3137	3392		}
3138	3393		if isExtern {
3139	3394		throw emitError(self, node, ErrorKind::FnUnexpectedBody);
3140	3395		}
	3396	+	if isUnsafe {
	3397	+	set self.unsafeDepth += 1;
	3398	+	}
3141	3399		enterFn(self, node, fnType); // Enter function scope for body analysis.
3142	3400
3143	3401		let bodyTy = try checkAssignable(self, body, Type::Void) catch e {
3144	3402		exitFn(self);
	3403	+	if isUnsafe { set self.unsafeDepth -= 1; }
3145	3404		throw e;
3146	3405		};
3147	3406		if retTy <> Type::Void and bodyTy <> Type::Never {
3148	3407		exitFn(self);
	3408	+	if isUnsafe { set self.unsafeDepth -= 1; }
3149	3409		throw emitError(self, body, ErrorKind::FnMissingReturn);
3150	3410		}
3151	3411		exitFn(self);
	3412	+	if isUnsafe {
	3413	+	set self.unsafeDepth -= 1;
	3414	+	}
3152	3415		} else if not isExtern {
3153	3416		throw emitError(self, node, ErrorKind::FnMissingBody);
3154	3417		}
3155	3418		}
3156	3419

3162	3425		let _ = try bindValueIdent(self, param.name, node, ty, false, 0, 0);
3163	3426
3164	3427		return ty;
3165	3428		}
3166	3429
	3430	+	/// Resolve the compiler-known `Linear` marker from a derive list.
	3431	+	fn resolveLinearDerive(self: mut Resolver, derives: mut [*ast::Node]) -> bool
	3432	+	throws (ResolveError)
	3433	+	{
	3434	+	let mut linear = false;
	3435	+	for derive in derives {
	3436	+	let name = try nodeName(self, derive);
	3437	+	if mem::eq(name, "Linear") {
	3438	+	if linear {
	3439	+	throw emitError(self, derive, ErrorKind::DuplicateBinding(name));
	3440	+	}
	3441	+	set linear = true;
	3442	+	} else {
	3443	+	// Resolve an ordinary trait derive.
	3444	+	try infer(self, derive);
	3445	+	}
	3446	+	}
	3447	+	return linear;
	3448	+	}
	3449	+
3167	3450		/// Resolve record fields from a node list.
3168	3451		fn resolveRecordFields(self: mut Resolver, node: ast::Node, fields: mut [ast::Node], labeled: bool) -> RecordType
3169	3452		throws (ResolveError)
3170	3453		{
3171	3454		let a = alloc::arenaAllocator(&mut self.arena);