radiance · commit

lang: Enforce linear ownership

7e3db9f1f3eb8ae75aa36c065a2a4b7187a496daef061dc7039bb89531d12827

Alexis Sellier committed 1 month ago 1 parent 3c8a74bf

lib/std/lang/resolver.rad +1653 -289

    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.

    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,
    /// Whether this compilation contains explicitly linear declarations.
    linearEnabled: bool,
    /// 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,
        linearEnabled: false,
        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;
}

/// Preserve legacy address-of coercions until a package opts into linearity.
fn pointerClassesAssignable(
    self: *Resolver,
    to: types::PointerClass,
    from: types::PointerClass,
) -> bool {
    return to == from or (
        not self.linearEnabled
        and 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(self, 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(self, 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(self, 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(self, 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;
        }
        if self.linearEnabled {
            try checkLinearFn(self, nil, decl.sig.params, body);
        }
    } 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;
            set self.linearEnabled = true;
        } else {
            // Other derives retain their existing trait-name validation.
            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;
    }
    if self.linearEnabled {
        try checkLinearFn(self, receiverName, sig.params, body);
    }
}

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


        if let case Type::TraitObject { traitInfo, mutable: objMutable, .. } = subjectTy {
            let methodName = try nodeName(self, access.child);
            let method = findTraitMethod(traitInfo, methodName)
                else throw emitError(self, access.child, ErrorKind::RecordFieldUnknown(methodName));

            // Reject mutable-receiver methods called on immutable trait objects.
            if method.mutable and not objMutable {
                throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
            }
            try checkCallArgs(self, node, call, method.fnType, ctx);
            setTraitMethodCall(self, node, traitInfo, method.index);

            return setNodeType(self, node, *method.fnType.returnType);
        }

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

            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)) => {
    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, 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)
{
    // Linear source treats every address expression as a call-scoped reference.
    // Legacy packages keep their historical owning-address inference.
    let class = types::PointerClass::Ref
        if self.linearEnabled or isRefType(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);

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


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

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

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

/// How an expression uses a linear result.
union LinearUse {
    Consume,
    Observe,
    Borrow,
    Discard,
    Place,
}

/// Per-control-flow-path ownership state.
record LinearEnv {
    symbols: [?*mut Symbol; MAX_LINEAR_BINDINGS],
    available: u64,
    len: u32,
    terminated: bool,
}

/// Function-local exact-use checker state.
record LinearChecker {
    resolver: *mut Resolver,
    loopMarks: [u32; MAX_LINEAR_LOOP_DEPTH],
    loopAvailable: [u64; MAX_LINEAR_LOOP_DEPTH],
    loopExitAvailable: [u64; MAX_LINEAR_LOOP_DEPTH],
    loopHasNaturalExit: [bool; MAX_LINEAR_LOOP_DEPTH],
    loopBreakSeen: [bool; MAX_LINEAR_LOOP_DEPTH],
    loopDepth: u32,
}

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

/// Explicit `Linear` markers enable exact-use checking.
@test fn testLinearValueConsumedOnce() throws (testing::TestError) {
    let program = "union Token: Linear { Value(u32) } fn consume(token: Token) { match token { case Token::Value(_) => {} } } fn run(token: Token) { consume(token); }";
    try expectAnalyzeOk(program);
}

/// A linear binding must be consumed before its scope exits.
@test fn testLinearValueNotConsumed() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Token: Linear { value: u32 } fn run(token: Token) {}";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("token"));
}

/// A second by-value use of a linear binding is rejected.
@test fn testLinearValueConsumedTwice() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn run(token: Token) { consume(token); consume(token); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearUseAfterConsume("token"));
}

/// Both live branches must leave an outer linear binding in the same state.
@test fn testLinearBranchMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn run(token: Token, flag: bool) { if flag { consume(token); } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearBranchMismatch("token"));
}

/// A loop cannot consume a binding created outside the repeated body.
@test fn testLinearLoopConsume() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn run(token: Token, flag: bool) { while flag { consume(token); } consume(token); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearBranchMismatch("token"));
}

/// Effects from the condition remain on the condition-false loop exit.
@test fn testLinearWhileConditionConsumptionPreserved() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn take(token: Token) -> bool { consume(token); return false; } fn run(token: Token) { while take(token) { return; } consume(token); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearUseAfterConsume("token"));
}

/// A break exit agrees with ownership effects already applied by the condition.
@test fn testLinearWhileBreakUsesConditionExit() throws (testing::TestError) {
    let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn take(token: Token) -> bool { consume(token); return true; } fn run(token: Token) { while take(token) { break; } }";
    try expectAnalyzeOk(program);
}

/// Guard-failure effects must agree with the pattern-failure loop exit.
@test fn testLinearWhileLetGuardExitMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } union Opt { Some(u32), None } fn consume(token: Token) { match token { case Token::Value => {} } } fn take(token: Token) -> bool { consume(token); return false; } fn run(value: Opt, token: Token) { while let case Opt::Some(_) = value; take(token) { return; } consume(token); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearBranchMismatch("token"));
}

/// A linear field cannot be moved out independently of its container.
@test fn testLinearPartialMove() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } record Wrapper { token: Token } fn consume(token: Token) { match token { case Token::Value => {} } } fn run(wrapper: Wrapper) { consume(wrapper.token); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearPartialMove);
}

/// Assignment cannot discard the previous value of a linear place.
@test fn testLinearOverwrite() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } fn run() { let mut token = Token::Value; set token = Token::Value; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearOverwrite);
}

/// A consumed linear binding may be initialized with a new owning value.
@test fn testLinearReinitializeConsumedBinding() throws (testing::TestError) {
    let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn run() { let mut token = Token::Value; consume(token); set token = Token::Value; consume(token); }";
    try expectAnalyzeOk(program);
}

/// Assignment may consume and replace the same live linear binding.
@test fn testLinearTransformAssignment() throws (testing::TestError) {
    let program = "union Token: Linear { Value } fn transform(token: Token) -> Token { return token; } fn consume(token: Token) { match token { case Token::Value => {} } } fn run(token: Token) { let mut current = token; set current = transform(current); consume(current); }";
    try expectAnalyzeOk(program);
}

/// A loop back edge cannot change an outer binding's availability.
@test fn testLinearLoopReinitializeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn run(token: Token) { let mut current = token; consume(current); loop { set current = Token::Value; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearBranchMismatch("current"));
}

/// A break propagates its ownership state to the loop exit.
@test fn testLinearBreakReinitializeMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn run(token: Token) { let mut current = token; consume(current); loop { set current = Token::Value; break; } }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("current"));
}

/// `undefined` cannot manufacture a linear value.
@test fn testLinearUndefined() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Token: Linear { value: u32 } fn run() { let token: Token = undefined; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearUndefined);
}

/// Owning pointers are structurally linear regardless of pointee type.
@test fn testOwningPointerIsLinear() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} fn run(pointer: *u32) {}";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("pointer"));
}

/// A call-scoped reference may borrow a linear value without consuming it.
@test fn testLinearRefBorrow() throws (testing::TestError) {
    let program = "union Token: Linear { Value } fn inspect(token: &Token) {} fn consume(token: Token) { match token { case Token::Value => {} } } fn run(token: Token) { inspect(&token); consume(token); }";
    try expectAnalyzeOk(program);
}

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

/// Address expressions cannot be captured in local bindings.
@test fn testRefBindingRejected() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} fn bad() { let value: u32 = 1; let saved = &value; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::RefBinding);
}

/// An exclusive loan cannot overlap another loan of the same root.
@test fn testLinearBorrowConflict() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } fn borrow(first: &mut Token, second: &Token) {} fn consume(token: Token) { match token { case Token::Value => {} } } fn run() { let mut token = Token::Value; borrow(&mut token, &token); consume(token); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("token"));
}

/// Mutable slice references rooted at the same local conflict.
@test fn testLinearSliceRefBorrowConflict() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} fn borrow(first: &mut [u32], second: &[u32]) {} fn run() { let mut values: [u32; 2] = [1, 2]; borrow(&mut values[..], &values[..]); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("values"));
}

/// Linear checking preserves value-producing `let-else` fallbacks.
@test fn testLinearLetElseFallbackValue() throws (testing::TestError) {
    let program = "record Marker: Linear {} fn run(value: ?u32) { let item = value else 1; item; }";
    try expectAnalyzeOk(program);
}

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

/// `let-else` fallback effects must agree with the success path.
@test fn testLinearLetElseFallbackBranchMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } fn consumeValue(token: Token) -> u32 { match token { case Token::Value => {} } return 1; } fn consume(token: Token) { match token { case Token::Value => {} } } fn run(value: ?u32, token: Token) { let item = value else consumeValue(token); consume(token); item; }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearBranchMismatch("token"));
}

/// Guard effects remain visible on the successful continuation.
@test fn testLinearLetElseGuardFailureMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Token: Linear { Value } union Opt { Some(u32), None } fn consume(token: Token) { match token { case Token::Value => {} } } fn take(token: Token) -> bool { consume(token); return false; } fn run(value: Opt, token: Token) { let case Opt::Some(_) = value if take(token) else panic; consume(token); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::LinearUseAfterConsume("token"));
}

/// Differing guard and pattern failure states are valid when both terminate.
@test fn testLinearLetElseGuardTerminatingFallback() throws (testing::TestError) {
    let program = "union Token: Linear { Value } union Opt { Some(u32), None } fn consume(token: Token) { match token { case Token::Value => {} } } fn take(token: Token) -> bool { consume(token); return false; } fn run(value: Opt, token: Token) { let case Opt::Some(_) = value if take(token) else panic; }";
    try expectAnalyzeOk(program);
}

/// Mutable trait-object references rooted at the same local conflict.
@test fn testLinearTraitObjectRefBorrowConflict() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "record Marker: Linear {} record Value { number: u32 } trait Read { fn (&Read) get() -> u32; } instance Read for Value { fn (value: &Value) get() -> u32 { return value.number; } } fn borrow(first: &mut opaque Read, second: &opaque Read) {} fn run(value: &mut Value) { borrow(value, value); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectErrorKind(&result, super::ErrorKind::BorrowConflict("value"));
}

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

/// Matching branch consumption is accepted on every live path.
@test fn testLinearBranchConsumption() throws (testing::TestError) {
    let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn run(token: Token, flag: bool) { if flag { consume(token); } else { consume(token); } }";
    try expectAnalyzeOk(program);
}

/// Arrays and optionals inherit linearity from their elements.
@test fn testStructuralLinearContainers() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn run(values: [Token; 1]) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("values"));
    } {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn run(value: ?Token) {}";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearNotConsumed("value"));
    }
}

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

/// Linear temporaries cannot be discarded or duplicated by array repetition.
@test fn testLinearDiscardRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn run() { Token::Value; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearDiscard);
    } {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn run() { let values = [Token::Value; 2]; }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearDiscard);
    }
}

/// Partial conditional and repeated destructuring cannot consume a linear scrutinee.
@test fn testLinearPartialControlFlowRejected() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn run(token: Token) { if let case Token::Value = token {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearPartialMove);
    } {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn run(token: Token) { while let case Token::Value = token {} }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearPartialMove);
    } {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn run(tokens: [Token; 1]) { for token in tokens { match token { case Token::Value => {} } } }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::LinearPartialMove);
    }
}

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

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

/// Shared loans may overlap, while exclusive and consuming uses may not.
@test fn testBorrowLoanCombinations() throws (testing::TestError) {
    {
        let program = "union Token: Linear { Value } fn inspect(first: &Token, second: &Token) {} fn consume(token: Token) { match token { case Token::Value => {} } } fn run(token: Token) { inspect(&token, &token); consume(token); }";
        try expectAnalyzeOk(program);
    } {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn inspect(first: &mut Token, second: &mut Token) {} fn consume(token: Token) { match token { case Token::Value => {} } } fn run() { let mut token = Token::Value; inspect(&mut token, &mut token); consume(token); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("token"));
    } {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn consume(token: Token) { match token { case Token::Value => {} } } fn inspect(first: &Token, second: Token) { consume(second); } fn run(token: Token) { inspect(&token, token); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("token"));
    } {
        let program = "union Token: Linear { Value } fn inspect(first: &mut Token, second: &mut Token) {} fn consume(token: Token) { match token { case Token::Value => {} } } fn run() { let mut first = Token::Value; let mut second = Token::Value; inspect(&mut first, &mut second); consume(first); consume(second); }";
        try expectAnalyzeOk(program);
    }
}

/// Implicit method receivers participate in ownership and loan accounting.
@test fn testLinearMethodReceiverAccounting() throws (testing::TestError) {
    {
        let program = "union Token: Linear { Value } fn (token: *Token) pass() -> *Token { return token; } fn run(token: Token) -> *Token { return token.pass(); }";
        try expectAnalyzeOk(program);
    } {
        let mut a = testResolver();
        let program = "union Token: Linear { Value } fn (token: &mut Token) inspect(other: &Token) {} fn consume(token: Token) { match token { case Token::Value => {} } } fn run() { let mut token = Token::Value; token.inspect(&token); consume(token); }";
        let result = try resolveProgramStr(&mut a, program);
        try expectErrorKind(&result, super::ErrorKind::BorrowConflict("token"));
    }
}

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

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

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

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

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

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

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

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

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

751	789		loopDepth: u32,
752	790		/// Signature of the function currently being analyzed.
753	791		currentFn: ?*FnType,
754	792		/// Current module being analyzed.
755	793		currentMod: u16,
	794	+	/// Nesting depth of unsafe modules and function bodies.
	795	+	unsafeDepth: u32,
	796	+	/// Whether this compilation contains explicitly linear declarations.
	797	+	linearEnabled: bool,
756	798		/// Configuration for semantic analysis.
757	799		config: Config,
758	800		/// Unified arena for symbols, scopes, and nominal type.
759	801		arena: alloc::Arena,
760	802		/// Combined semantic metadata table indexed by node ID.

908	950		pkgScope: storage.pkgScope,
909	951		loopStack: undefined,
910	952		loopDepth: 0,
911	953		currentFn: nil,
912	954		currentMod: 0,
	955	+	unsafeDepth: 0,
	956	+	linearEnabled: false,
913	957		config,
914	958		arena,
915	959		nodeData: NodeDataTable { entries: storage.nodeData },
916	960		types: nil,
917	961		errors: @sliceOf(storage.errors.ptr, 0, storage.errors.len),

1350	1394		}
1351	1395
1352	1396		/// Get the layout of a type.
1353	1397		export fn getTypeLayout(ty: Type) -> Layout {
1354	1398		match ty {
	1399	+	case Type::Pointer { .. } => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
	1400	+	case Type::Slice { .. }, Type::TraitObject { .. } =>
	1401	+	return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
1355	1402		case Type::Void, Type::Never => return Layout { size: 0, alignment: 0 },
1356	1403		case Type::Bool, Type::U8, Type::I8 => return Layout { size: 1, alignment: 1 },
1357	1404		case Type::U16, Type::I16 => return Layout { size: 2, alignment: 2 },
1358	1405		case Type::U32, Type::I32 => return Layout { size: 4, alignment: 4 },
1359	1406		case Type::Int => return Layout { size: 8, alignment: 8 },
1360	1407		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 },
	1408	+	case Type::Fn(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
1365	1409		case Type::Array(arr) => return getArrayLayout(arr),
1366	1410		case Type::Optional(inner) => return getOptionalLayout(*inner),
1367	1411		case Type::Nominal(info) => return getNominalLayout(*info),
1368	1412		else => {
1369	1413		panic "getTypeLayout: the given type cannot be layed out";

1528	1572		return unionType.isAllVoid;
1529	1573		}
1530	1574
1531	1575		/// Check if a type should be treated as an address-like value.
1532	1576		fn isAddressType(ty: Type) -> bool {
	1577	+	if isNullableType(ty) {
	1578	+	return true;
	1579	+	}
1533	1580		match ty {
1534		-	case Type::Pointer { .. }, Type::Slice { .. }, Type::Fn(_) => return true,
	1581	+	case Type::Fn(_) => return true,
1535	1582		else => return false,
1536	1583		}
1537	1584		}
1538	1585
1539	1586		/// Return the representable range for an integer type.

1602	1649
1603	1650		/// Ensure all nested nominal types in a type are resolved.
1604	1651		fn ensureTypeResolved(self: mut Resolver, ty: Type, site: ast::Node) throws (ResolveError) {
1605	1652		match ty {
1606	1653		case Type::Nominal(info) => try ensureNominalResolved(self, info, site),
1607		-	case Type::Array(arr) => try ensureTypeResolved(self, *arr.item, site),
1608	1654		case Type::Slice { item, .. } => try ensureTypeResolved(self, *item, site),
1609	1655		case Type::Pointer { .. } => {}, // Pointers have fixed layout, don't recurse.
	1656	+	case Type::Array(arr) => try ensureTypeResolved(self, *arr.item, site),
1610	1657		case Type::Optional(inner) => try ensureTypeResolved(self, *inner, site),
1611	1658		else => {},
1612	1659		}
1613	1660		}
1614	1661

1659	1706		}
1660	1707		}
1661	1708		return true;
1662	1709		}
1663	1710
	1711	+	/// Preserve legacy address-of coercions until a package opts into linearity.
	1712	+	fn pointerClassesAssignable(
	1713	+	self: *Resolver,
	1714	+	to: types::PointerClass,
	1715	+	from: types::PointerClass,
	1716	+	) -> bool {
	1717	+	return to == from or (
	1718	+	not self.linearEnabled
	1719	+	and to == types::PointerClass::Owned
	1720	+	and from == types::PointerClass::Ref
	1721	+	);
	1722	+	}
	1723	+
1664	1724		/// Check if the `from` type is assignable to the `to` type, and return a
1665	1725		/// coercion plan if so.
1666	1726		fn isAssignable(self: mut Resolver, to: Type, from: Type, rval: ast::Node) -> ?Coercion {
1667	1727		if to == Type::Unknown or from == Type::Unknown {
1668	1728		return nil;

1678	1738		return Coercion::Identity;
1679	1739		}
1680	1740		if to == from {
1681	1741		return Coercion::Identity;
1682	1742		}
	1743	+	if let case Type::Pointer { class: lhsClass, target: lhsTarget, mutable: lhsMutable } = to {
	1744	+	let case Type::Pointer { class: rhsClass, target: rhsTarget, mutable: rhsMutable } = from
	1745	+	else return nil;
	1746	+	if not pointerClassesAssignable(self, lhsClass, rhsClass) {
	1747	+	return nil;
	1748	+	}
	1749	+	// Allow coercion from `T` to `opaque`, and mutable counterparts.
	1750	+	if *lhsTarget == Type::Opaque {
	1751	+	if lhsMutable and not rhsMutable {
	1752	+	return nil;
	1753	+	}
	1754	+	return Coercion::Identity;
	1755	+	}
	1756	+	if lhsMutable and not rhsMutable {
	1757	+	return nil;
	1758	+	}
	1759	+	return isAssignable(self, lhsTarget, rhsTarget, rval);
	1760	+	}
	1761	+	if let case Type::TraitObject { class: lhsClass, traitInfo: lhsTraitInfo, mutable: lhsMutable } = to {
	1762	+	if let case Type::Pointer { class: rhsClass, target: rhsTarget, mutable: rhsMutable } = from {
	1763	+	if not pointerClassesAssignable(self, lhsClass, rhsClass)
	1764	+	or (lhsMutable and not rhsMutable)
	1765	+	{
	1766	+	return nil;
	1767	+	}
	1768	+	if let inst = findInstance(self, lhsTraitInfo, *rhsTarget) {
	1769	+	return Coercion::TraitObject { traitInfo: lhsTraitInfo, inst };
	1770	+	}
	1771	+	}
	1772	+	if let case Type::TraitObject { class: rhsClass, traitInfo: rhsTraitInfo, mutable: rhsMutable } = from {
	1773	+	if not pointerClassesAssignable(self, lhsClass, rhsClass)
	1774	+	or lhsTraitInfo <> rhsTraitInfo
	1775	+	{
	1776	+	return nil;
	1777	+	}
	1778	+	if lhsMutable and not rhsMutable {
	1779	+	return nil;
	1780	+	}
	1781	+	return Coercion::Identity;
	1782	+	}
	1783	+	return nil;
	1784	+	}
	1785	+	if let case Type::Slice { class: lhsClass, item: lhsItem, mutable: lhsMutable } = to {
	1786	+	let case Type::Slice { class: rhsClass, item: rhsItem, mutable: rhsMutable } = from
	1787	+	else return nil;
	1788	+	if not pointerClassesAssignable(self, lhsClass, rhsClass)
	1789	+	or (lhsMutable and not rhsMutable)
	1790	+	{
	1791	+	return nil;
	1792	+	}
	1793	+	// Allow coercion from `[T]` to `[opaque]`, and mutable counterparts.
	1794	+	if *lhsItem == Type::Opaque {
	1795	+	return Coercion::Identity;
	1796	+	}
	1797	+	return isAssignable(self, lhsItem, rhsItem, rval);
	1798	+	}
1683	1799		match to {
1684	1800		case Type::Array(lhs) => {
1685	1801		let case Type::Array(rhs) = from
1686	1802		else return nil;
1687	1803

3335	3586		}
3336	3587		traitType.methods.append(TraitMethod {
3337	3588		name: inherited.name,
3338	3589		fnType: inherited.fnType,
3339	3590		mutable: inherited.mutable,
	3591	+	receiverClass: inherited.receiverClass,
3340	3592		index: traitType.methods.len as u32,
3341	3593		}, a);
3342	3594		}
3343	3595		traitType.supertraits.append(superTrait, a);
3344	3596		}

3406	3661		}
3407	3662		let fnType = FnType {
3408	3663		paramTypes: &paramTypes[..],
3409	3664		returnType: retType,
3410	3665		throwList: &throwList[..],
	3666	+	isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
3411	3667		localCount: 0,
3412	3668		};
3413	3669		traitType.methods.append(TraitMethod {
3414	3670		name: methodName,
3415	3671		fnType: allocFnType(self, fnType),
3416	3672		mutable,
	3673	+	receiverClass,
3417	3674		index: traitType.methods.len as u32,
3418	3675		}, a);
3419	3676
3420	3677		setNodeType(self, methodNode, Type::Void);
3421	3678		}

1712	1828		}
1713	1829		return nil;
1714	1830		}
1715	1831		}
1716	1832		}
1717		-	case Type::Pointer { target: lhsTarget, mutable: lhsMutable, .. } => {
1718		-	let case Type::Pointer { target: rhsTarget, mutable: rhsMutable, .. } = from
1719		-	else return nil;
1720	1833
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	1834		case Type::Optional(inner) => {
1734	1835		if from == Type::Nil {
1735	1836		return Coercion::OptionalLift(to);
1736	1837		}
1737	1838		if let _ = isAssignable(self, *inner, from, rval) {

1740	1841		if let case Type::Optional(fromInner) = from {
1741	1842		return isAssignable(self, inner, fromInner, rval);
1742	1843		}
1743	1844		return nil;
1744	1845		}
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		-	}
	1846	+
1790	1847		case Type::Fn(toInfo) => {
1791	1848		// Allow function type structural matching.
1792	1849		if let case Type::Fn(fromInfo) = from {
1793	1850		if fnTypeEqual(toInfo, fromInfo) {
1794	1851		return Coercion::Identity;

1829	1886		return nil;
1830	1887		}
1831	1888
1832	1889		/// Check if two function type descriptors are structurally equivalent.
1833	1890		fn fnTypeEqual(a: FnType, b: FnType) -> bool {
	1891	+	if a.isUnsafe <> b.isUnsafe {
	1892	+	return false;
	1893	+	}
1834	1894		if a.paramTypes.len <> b.paramTypes.len {
1835	1895		return false;
1836	1896		}
1837	1897		if a.throwList.len <> b.throwList.len {
1838	1898		return false;

1856	1916		/// Check if two types are structurally equal.
1857	1917		export fn typesEqual(a: Type, b: Type) -> bool {
1858	1918		if a == b {
1859	1919		return true;
1860	1920		}
	1921	+	if let case Type::Pointer { class: aClass, target: aTarget, mutable: aMutable } = a {
	1922	+	let case Type::Pointer { class: bClass, target: bTarget, mutable: bMutable } = b
	1923	+	else return false;
	1924	+	return aClass == bClass and aMutable == bMutable
	1925	+	and typesEqual(aTarget, bTarget);
	1926	+	}
	1927	+	if let case Type::Slice { class: aClass, item: aItem, mutable: aMutable } = a {
	1928	+	let case Type::Slice { class: bClass, item: bItem, mutable: bMutable } = b
	1929	+	else return false;
	1930	+	return aClass == bClass and aMutable == bMutable
	1931	+	and typesEqual(aItem, bItem);
	1932	+	}
	1933	+	if let case Type::TraitObject { class: aClass, traitInfo: aTraitInfo, mutable: aMutable } = a {
	1934	+	let case Type::TraitObject { class: bClass, traitInfo: bTraitInfo, mutable: bMutable } = b
	1935	+	else return false;
	1936	+	return aClass == bClass and aMutable == bMutable
	1937	+	and aTraitInfo == bTraitInfo;
	1938	+	}
1861	1939		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	1940		case Type::Array(aa) => {
1873	1941		let case Type::Array(ab) = b else return false;
1874	1942		return aa.length == ab.length and typesEqual(aa.item, ab.item);
1875	1943		}
1876	1944		case Type::Optional(oa) => {

1883	1951		}
1884	1952		else => return false,
1885	1953		}
1886	1954		}
1887	1955
	1956	+	/// Return whether `ty` is a direct reference.
	1957	+	export fn isRefType(ty: Type) -> bool {
	1958	+	match ty {
	1959	+	case Type::Pointer { class: types::PointerClass::Ref, .. },
	1960	+	Type::Slice { class: types::PointerClass::Ref, .. },
	1961	+	Type::TraitObject { class: types::PointerClass::Ref, .. } => return true,
	1962	+	else => return false,
	1963	+	}
	1964	+	}
	1965	+
	1966	+	/// Return whether a type contains a reference.
	1967	+	fn containsRef(ty: Type) -> bool {
	1968	+	if isRefType(ty) {
	1969	+	return true;
	1970	+	}
	1971	+	if let case Type::Pointer { target, .. } = ty {
	1972	+	return containsRef(*target);
	1973	+	}
	1974	+	if let case Type::Slice { item, .. } = ty {
	1975	+	return containsRef(*item);
	1976	+	}
	1977	+	match ty {
	1978	+	case Type::Array(array) => return containsRef(*array.item),
	1979	+	case Type::Optional(inner) => return containsRef(*inner),
	1980	+	// Nominal declarations validate their own fields and variants.
	1981	+	// Treating them as leaves also terminates recursive pointer types.
	1982	+	case Type::Nominal(_) => return false,
	1983	+	else => return false,
	1984	+	}
	1985	+	}
	1986	+
	1987	+	/// Return whether a type is exact-linear.
	1988	+	export fn isLinear(ty: Type) -> bool {
	1989	+	match ty {
	1990	+	case Type::Pointer { class: types::PointerClass::Owned, .. },
	1991	+	Type::Slice { class: types::PointerClass::Owned, .. },
	1992	+	Type::TraitObject { class: types::PointerClass::Owned, .. } => return true,
	1993	+	case Type::Pointer { class: types::PointerClass::Ref, .. },
	1994	+	Type::Pointer { class: types::PointerClass::Unsafe, .. },
	1995	+	Type::Slice { class: types::PointerClass::Ref, .. },
	1996	+	Type::Slice { class: types::PointerClass::Unsafe, .. },
	1997	+	Type::TraitObject { class: types::PointerClass::Ref, .. },
	1998	+	Type::TraitObject { class: types::PointerClass::Unsafe, .. } => return false,
	1999	+
	2000	+	case Type::Array(array) => return isLinear(*array.item),
	2001	+	case Type::Optional(inner) => return isLinear(*inner),
	2002	+	case Type::Nominal(NominalType::Record(recInfo)) => {
	2003	+	if recInfo.declaredLinear {
	2004	+	return true;
	2005	+	}
	2006	+	for field in recInfo.fields {
	2007	+	if isLinear(field.fieldType) {
	2008	+	return true;
	2009	+	}
	2010	+	}
	2011	+	return false;
	2012	+	}
	2013	+	case Type::Nominal(NominalType::Union(unionType)) => {
	2014	+	if unionType.declaredLinear {
	2015	+	return true;
	2016	+	}
	2017	+	for variant in unionType.variants {
	2018	+	if isLinear(variant.valueType) {
	2019	+	return true;
	2020	+	}
	2021	+	}
	2022	+	return false;
	2023	+	}
	2024	+	else => return false,
	2025	+	}
	2026	+	}
	2027	+
	2028	+	/// Return whether `ty` is a direct unsafe pointer-like value.
	2029	+	fn isUnsafePointerType(ty: Type) -> bool {
	2030	+	match ty {
	2031	+	case Type::Pointer { class: types::PointerClass::Unsafe, .. },
	2032	+	Type::Slice { class: types::PointerClass::Unsafe, .. },
	2033	+	Type::TraitObject { class: types::PointerClass::Unsafe, .. } => return true,
	2034	+	else => return false,
	2035	+	}
	2036	+	}
	2037	+
1888	2038		/// Get the record info from a record type.
1889	2039		export fn getRecord(ty: Type) -> ?RecordType {
1890	2040		let case Type::Nominal(NominalType::Record(recInfo)) = ty else return nil;
1891	2041		return recInfo;
1892	2042		}

1899	2049		return ty;
1900	2050		}
1901	2051
1902	2052		/// Get field info for a record-like type (records, slices) by field index.
1903	2053		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,
	2054	+	if let case Type::Slice { class, item, mutable } = ty {
	2055	+	match index {
	2056	+	case 0 => return RecordField {
	2057	+	name: PTR_FIELD,
	2058	+	fieldType: Type::Pointer { class, target: item, mutable },
	2059	+	offset: 0,
	2060	+	},
	2061	+	case 1 => return RecordField {
	2062	+	name: LEN_FIELD,
	2063	+	fieldType: Type::U32,
	2064	+	offset: PTR_SIZE as i32,
	2065	+	},
	2066	+	case 2 => return RecordField {
	2067	+	name: CAP_FIELD,
	2068	+	fieldType: Type::U32,
	2069	+	offset: PTR_SIZE as i32 + 4,
	2070	+	},
	2071	+	else => return nil,
	2072	+	}
	2073	+	}
	2074	+	if let case Type::Nominal(NominalType::Record(recInfo)) = ty;
	2075	+	index < recInfo.fields.len
	2076	+	{
	2077	+	return recInfo.fields[index];
1934	2078		}
	2079	+	return nil;
1935	2080		}
1936	2081
1937	2082		/// Check if the two types can be compared for equality.
1938	2083		fn isComparable(left: Type, right: Type) -> bool {
1939	2084		if left == Type::Unknown or right == Type::Unknown {

2330	2475		scope: *Scope
2331	2476		) -> *mut Symbol throws (ResolveError) {
2332	2477		assert path.len <> 0, "resolvePath: empty path";
2333	2478		// Start by finding the root of the path.
2334	2479		let root = path[0];
2335		-	let sym = findInScopeRecursive(scope, root, isAnySymbol) else
2336		-	throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));
	2480	+	let sym = findInScopeRecursive(scope, root, isAnySymbol)
	2481	+	else throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));
2337	2482		let suffix = &path[1..];
2338	2483
2339	2484		// Check visibility for symbol.
2340	2485		if not isSymbolVisible(sym, scope, self.scope) {
2341	2486		throw emitError(self, node, ErrorKind::UnresolvedSymbol(root));

2484	2629		// Ignore non-declaration nodes.
2485	2630		}
2486	2631		}
2487	2632		}
2488	2633
	2634	+	/// Require the current declaration to be unsafe.
	2635	+	fn requireUnsafe(self: mut Resolver, node: ast::Node) throws (ResolveError) {
	2636	+	if self.unsafeDepth == 0 {
	2637	+	throw emitError(self, node, ErrorKind::UnsafeOperation);
	2638	+	}
	2639	+	}
	2640	+
	2641	+	/// Reject calls from safe code through unsafe function types.
	2642	+	fn checkUnsafeCall(self: mut Resolver, node: ast::Node, info: *FnType)
	2643	+	throws (ResolveError)
	2644	+	{
	2645	+	if info.isUnsafe and self.unsafeDepth == 0 {
	2646	+	throw emitError(self, node, ErrorKind::UnsafeCall);
	2647	+	}
	2648	+	}
	2649	+
2489	2650		/// Visit a top-level definition, recursing into sub-modules.
2490	2651		fn visitDef(self: mut Resolver, node: ast::Node) throws (ResolveError) {
2491	2652		match node.value {
2492	2653		case ast::NodeValue::FnDecl(decl) => {
2493	2654		try resolveFnDeclBody(self, node, decl) catch {

2500	2661		}
2501	2662		let modName = try nodeName(self, decl.name);
2502	2663		let submod = try enterSubModule(self, modName, node);
2503	2664		let case ast::NodeValue::Block(block) = submod.root.value
2504	2665		else panic "visitDef: expected block for module root";
2505		-	try resolveModuleDefs(self, &block);
	2666	+	let mut isUnsafe = false;
	2667	+	if let attrs = decl.attrs {
	2668	+	set isUnsafe = ast::attributesContains(&attrs, ast::Attribute::Unsafe);
	2669	+	}
	2670	+	if isUnsafe {
	2671	+	set self.unsafeDepth += 1;
	2672	+	}
	2673	+	try resolveModuleDefs(self, &block) catch e {
	2674	+	if isUnsafe { set self.unsafeDepth -= 1; }
	2675	+	exitModuleScope(self, submod);
	2676	+	throw e;
	2677	+	};
	2678	+	if isUnsafe {
	2679	+	set self.unsafeDepth -= 1;
	2680	+	}
2506	2681		exitModuleScope(self, submod);
2507	2682		}
2508	2683		case ast::NodeValue::RecordDecl(_),
2509	2684		ast::NodeValue::UnionDecl(_),
2510	2685		ast::NodeValue::Use(_),

2532	2707		/// Try to infer a node's type.
2533	2708		fn infer(self: mut Resolver, node: ast::Node) -> Type throws (ResolveError) {
2534	2709		return try visit(self, node, Type::Unknown);
2535	2710		}
2536	2711
	2712	+	/// Reject nested references while allowing a direct parameter reference.
	2713	+	fn validateValueTypeReferences(self: mut Resolver, node: ast::Node, ty: Type)
	2714	+	throws (ResolveError)
	2715	+	{
	2716	+	if isRefType(ty) {
	2717	+	if let case Type::Pointer { target, .. } = ty {
	2718	+	if containsRef(*target) {
	2719	+	throw emitError(self, node, ErrorKind::InvalidRefPosition);
	2720	+	}
	2721	+	} else if let case Type::Slice { item, .. } = ty {
	2722	+	if containsRef(*item) {
	2723	+	throw emitError(self, node, ErrorKind::InvalidRefPosition);
	2724	+	}
	2725	+	}
	2726	+	} else if containsRef(ty) {
	2727	+	throw emitError(self, node, ErrorKind::InvalidRefPosition);
	2728	+	}
	2729	+	}
	2730	+
	2731	+	/// Require a type that may be stored or escape a call.
	2732	+	fn ensureStorableType(self: mut Resolver, node: ast::Node, ty: Type)
	2733	+	throws (ResolveError)
	2734	+	{
	2735	+	if containsRef(ty) {
	2736	+	throw emitError(self, node, ErrorKind::InvalidRefPosition);
	2737	+	}
	2738	+	}
	2739	+
2537	2740		/// Resolve a type signature node.
2538	2741		fn resolveValueType(self: mut Resolver, node: ast::Node) -> Type throws (ResolveError) {
2539	2742		let ty = try visit(self, node, Type::Unknown);
2540	2743		// Opaque value types are not allowed.
2541	2744		if ty == Type::Opaque {
2542	2745		throw emitError(self, node, ErrorKind::OpaqueTypeNotAllowed);
2543	2746		}
	2747	+	try validateValueTypeReferences(self, node, ty);
2544	2748		return ty;
2545	2749		}
2546	2750
2547	2751		/// Analyze a node's type and check that it can be assigned to the expected type.
2548	2752		fn checkAssignable(self: mut Resolver, node: ast::Node, expected: Type) -> Type throws (ResolveError) {

2636	2840		case ast::NodeValue::Throw { expr } => return try resolveThrow(self, node, expr),
2637	2841		case ast::NodeValue::Panic { message } => {
2638	2842		try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.
2639	2843		class: types::PointerClass::Owned,
2640	2844		item: allocType(self, Type::U8),
2641		-	mutable: false
	2845	+	mutable: false,
2642	2846		});
2643	2847		return setNodeType(self, node, Type::Never);
2644	2848		},
2645	2849		case ast::NodeValue::Assert { condition, message } => {
2646	2850		try visit(self, condition, Type::Bool);
2647	2851		try visitOptional(self, message, Type::Slice { // TODO: Have easy access to string type.
2648	2852		class: types::PointerClass::Owned,
2649	2853		item: allocType(self, Type::U8),
2650		-	mutable: false
	2854	+	mutable: false,
2651	2855		});
2652	2856		return setNodeType(self, node, Type::Void);
2653	2857		},
2654	2858		case ast::NodeValue::UnOp(unop) => return try resolveUnOp(self, node, unop),
2655	2859		case ast::NodeValue::ExprStmt(expr) => {

2792	2996		if not isTypeInferrable(bindingTy) {
2793	2997		throw emitError(self, decl.value, ErrorKind::CannotInferType);
2794	2998		}
2795	2999		}
2796	3000		// Variables cannot have void type.
	3001	+	if containsRef(bindingTy) {
	3002	+	throw emitError(self, node, ErrorKind::RefBinding);
	3003	+	}
2797	3004		if bindingTy == Type::Void {
2798	3005		throw emitError(self, decl.value, ErrorKind::CannotAssignVoid);
2799	3006		}
2800	3007		// Variables cannot have opaque type directly.
2801	3008		if bindingTy == Type::Opaque {

3029	3236		attrList: ?ast::Attributes,
3030	3237		isConst: bool
3031	3238		) -> Type throws (ResolveError) {
3032	3239		let attrs = resolveAttributes(self, attrList);
3033	3240		let bindingTy = try infer(self, typeNode);
	3241	+	try ensureStorableType(self, typeNode, bindingTy);
3034	3242		let valueTy = try checkAssignable(self, valueNode, bindingTy);
3035	3243
3036	3244		if isConst {
3037	3245		let mut constVal = constValueEntry(self, valueNode);
3038	3246		if constVal == nil and not isConstExpr(self, valueNode) {

3061	3269		{
3062	3270		let attrMask = resolveAttributes(self, decl.attrs);
3063	3271		let mut retTy = Type::Void;
3064	3272		if let retNode = decl.sig.returnType {
3065	3273		set retTy = try infer(self, retNode);
	3274	+	try ensureStorableType(self, retNode, retTy);
3066	3275		}
3067	3276		let a = alloc::arenaAllocator(&mut self.arena);
3068	3277		let mut paramTypes: mut [Type] = &mut [];
3069	3278		let mut throwList: mut [Type] = &mut [];
3070	3279		let mut fnType = FnType {
3071	3280		paramTypes: &[],
3072	3281		returnType: allocType(self, retTy),
3073	3282		throwList: &[],
	3283	+	isUnsafe: ast::hasAttribute(attrMask, ast::Attribute::Unsafe),
3074	3284		localCount: 0,
3075	3285		};
3076	3286		// Enter the function scope to process parameters.
3077	3287		enterFn(self, node, &fnType);
3078	3288

3102	3312		let throwTy = try infer(self, throwNode) catch e {
3103	3313		exitFn(self);
3104	3314		throw e;
3105	3315		};
3106	3316		throwList.append(allocType(self, throwTy), a);
	3317	+	try ensureStorableType(self, throwNode, throwTy);
3107	3318		}
3108	3319		exitFn(self);
3109	3320		set fnType.paramTypes = &paramTypes[..];
3110	3321		set fnType.throwList = &throwList[..];
3111	3322

3128	3339		panic "resolveFnDeclBody: unexpected symbol data for function";
3129	3340		};
3130	3341		let retTy = *fnType.returnType;
3131	3342		let isExtern = ast::hasAttribute(sym.attrs, ast::Attribute::Extern);
3132	3343		let isIntrinsic = ast::hasAttribute(sym.attrs, ast::Attribute::Intrinsic);
	3344	+	let isUnsafe = fnType.isUnsafe;
3133	3345
3134	3346		if let body = decl.body {
3135	3347		if isIntrinsic {
3136	3348		throw emitError(self, node, ErrorKind::IntrinsicUnexpectedBody);
3137	3349		}
3138	3350		if isExtern {
3139	3351		throw emitError(self, node, ErrorKind::FnUnexpectedBody);
3140	3352		}
	3353	+	if isUnsafe {
	3354	+	set self.unsafeDepth += 1;
	3355	+	}
3141	3356		enterFn(self, node, fnType); // Enter function scope for body analysis.
3142	3357
3143	3358		let bodyTy = try checkAssignable(self, body, Type::Void) catch e {
3144	3359		exitFn(self);
	3360	+	if isUnsafe { set self.unsafeDepth -= 1; }
3145	3361		throw e;
3146	3362		};
3147	3363		if retTy <> Type::Void and bodyTy <> Type::Never {
3148	3364		exitFn(self);
	3365	+	if isUnsafe { set self.unsafeDepth -= 1; }
3149	3366		throw emitError(self, body, ErrorKind::FnMissingReturn);
3150	3367		}
3151	3368		exitFn(self);
	3369	+	if isUnsafe {
	3370	+	set self.unsafeDepth -= 1;
	3371	+	}
	3372	+	if self.linearEnabled {
	3373	+	try checkLinearFn(self, nil, decl.sig.params, body);
	3374	+	}
3152	3375		} else if not isExtern {
3153	3376		throw emitError(self, node, ErrorKind::FnMissingBody);
3154	3377		}
3155	3378		}
3156	3379

3162	3385		let _ = try bindValueIdent(self, param.name, node, ty, false, 0, 0);
3163	3386
3164	3387		return ty;
3165	3388		}
3166	3389
	3390	+	/// Resolve the compiler-known `Linear` marker from a derive list.
	3391	+	fn resolveLinearDerive(self: mut Resolver, derives: mut [*ast::Node]) -> bool
	3392	+	throws (ResolveError)
	3393	+	{
	3394	+	let mut linear = false;
	3395	+	for derive in derives {
	3396	+	let name = try nodeName(self, derive);
	3397	+	if mem::eq(name, "Linear") {
	3398	+	if linear {
	3399	+	throw emitError(self, derive, ErrorKind::DuplicateBinding(name));
	3400	+	}
	3401	+	set linear = true;
	3402	+	set self.linearEnabled = true;
	3403	+	} else {
	3404	+	// Other derives retain their existing trait-name validation.
	3405	+	try infer(self, derive);
	3406	+	}
	3407	+	}
	3408	+	return linear;
	3409	+	}
	3410	+
3167	3411		/// Resolve record fields from a node list.
3168	3412		fn resolveRecordFields(self: mut Resolver, node: ast::Node, fields: mut [ast::Node], labeled: bool) -> RecordType
3169	3413		throws (ResolveError)
3170	3414		{
3171	3415		let a = alloc::arenaAllocator(&mut self.arena);

3182	3426		field: fieldNode,
3183	3427		type: typeNode,
3184	3428		value: valueNode
3185	3429		} = field.value else panic "resolveRecordFields: invalid record field";
3186	3430		let fieldTy = try resolveValueType(self, typeNode);
	3431	+	try ensureStorableType(self, typeNode, fieldTy);
3187	3432
3188	3433		if let v = valueNode {
3189	3434		let _valTy = try checkAssignable(self, v, fieldTy);
3190	3435		}
3191	3436		// Get field name for labeled records.

3216	3461		// Compute cached layout.
3217	3462		let recordLayout = Layout {
3218	3463		size: mem::alignUp(currentOffset, maxAlignment),
3219	3464		alignment: maxAlignment
3220	3465		};
3221		-	return RecordType { fields: &result[..], labeled, layout: recordLayout };
	3466	+	return RecordType {
	3467	+	fields: &result[..],
	3468	+	labeled,
	3469	+	layout: recordLayout,
	3470	+	declaredLinear: false,
	3471	+	};
3222	3472		}
3223	3473
3224	3474		/// Resolve record field types for a named record declaration.
3225	3475		fn resolveRecordBody(self: mut Resolver, node: ast::Node, decl: ast::RecordDecl)
3226	3476		throws (ResolveError)

3234	3484
3235	3485		// Skip if already resolved.
3236	3486		if let case NominalType::Record(_) = *nominalTy {
3237	3487		return;
3238	3488		}
3239		-	try visitList(self, decl.derives);
3240		-	let recordType = try resolveRecordFields(self, node, decl.fields, decl.labeled);
	3489	+	let declaredLinear = try resolveLinearDerive(self, decl.derives);
	3490	+	let mut recordType = try resolveRecordFields(self, node, decl.fields, decl.labeled);
	3491	+	set recordType.declaredLinear = declaredLinear;
3241	3492
3242	3493		set *nominalTy = NominalType::Record(recordType);
3243	3494		}
3244	3495
3245	3496		/// Bind a type name.