radiance · commit

refactor(lang): unify core type representation

364e23465dec9c6886f404a4f1a71c7399f10485f207ea32830e57c4308cd5cb

Represent pointers, slices, arrays, and optionals as core type
applications. Share pointer shape and properties, and centralize argument
traversal, substitution, layout checks, equality, printing, and lowering.

Preserve nullable pointer representations and typed relocation checks while
reducing duplicated type-specific branches.

Alexis Sellier committed 18 days ago 1 parent b5fc83f3

lib/std/lang/lower.rad +223 -210

/// Trait object v-table pointer offset.
constant TRAIT_OBJ_VTABLE_OFFSET: i32 = resolver::PTR_SIZE as i32;

// Tagged Value Layout (optionals, tagged unions)
//
// Optionals and unions use 1-byte tags. Results use 8-byte tags.
// Tagged optionals and unions use 1-byte tags. Results use 8-byte tags.
//
// `{ tag: u8, [padding], payload: T }`
//
// Optionals use `tag: 0` for `nil` and `tag: 1` otherwise.
// When `T` is a pointer, the entire optional is stored as a single pointer.
// Nullable pointer-like payloads use their null data pointer as the nil niche.
//
// Tagged unions have a payload the size of the maximum variant size.

/// Offset of tag in tagged value data structure.
constant TVAL_TAG_OFFSET: i32 = 0;


/// Classifies a match subject by how it should be compared and destructured.
union MatchSubjectKind {
    /// Regular value: direct equality comparison.
    Regular,
    /// Optional with null pointer optimization: `?*T`, `?*[T]`.
    /// Optional with null pointer optimization.
    OptionalPtr,
    /// Optional aggregate `?T`: tagged union with payload.
    /// Tagged optional aggregate.
    OptionalAggregate,
    /// Union type: tag compared against variant indices.
    Union(resolver::UnionType),
}

/// Determine the kind of a match subject from its type.
fn matchSubjectKind(type: resolver::Type) -> MatchSubjectKind {
    if resolver::isOptionalPointer(type) {
        return MatchSubjectKind::OptionalPtr;
    }
    if resolver::isOptionalAggregate(type) {
        return MatchSubjectKind::OptionalAggregate;
    if let payload = resolver::optionalTypeArgument(type) {
        return MatchSubjectKind::OptionalPtr
            if resolver::isNullableType(*payload)
            else MatchSubjectKind::OptionalAggregate;
    }
    if let info = unionInfoFromType(type) {
        return MatchSubjectKind::Union(info);
    }
    return MatchSubjectKind::Regular;

        case resolver::Type::U64 => namePush(builder, "u64"),
        case resolver::Type::I8 => namePush(builder, "i8"),
        case resolver::Type::I16 => namePush(builder, "i16"),
        case resolver::Type::I32 => namePush(builder, "i32"),
        case resolver::Type::I64 => namePush(builder, "i64"),
        case resolver::Type::Pointer(pointer) => {
            match pointer.class {
                case types::PointerClass::Owned => namePush(builder, "*"),
                case types::PointerClass::Ref => namePush(builder, "&"),
                case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
            }
            if pointer.mutable { namePush(builder, "mut "); }
            namePushType(self, builder, *pointer.target);
        }
        case resolver::Type::Slice(slice) => {
            match slice.class {
                case types::PointerClass::Owned => namePush(builder, "*"),
                case types::PointerClass::Ref => namePush(builder, "&"),
                case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
        case resolver::Type::Core(core) => {
            match core {
                case resolver::CoreType::Pointer { shape, properties, target } => {
                    match properties.class {
                        case types::PointerClass::Owned => namePush(builder, "*"),
                        case types::PointerClass::Ref => namePush(builder, "&"),
                        case types::PointerClass::Unsafe =>
                            namePush(builder, "*unsafe "),
                    }
                    if properties.mutable { namePush(builder, "mut "); }
                    match shape {
                        case resolver::PointerShape::Thin =>
                            namePushType(self, builder, *target),
                        case resolver::PointerShape::Slice => {
                            namePush(builder, "[");
                            namePushType(self, builder, *target);
                            namePush(builder, "]");
                        }
                    }
                }
                case resolver::CoreType::Array { item, length } => {
                    namePush(builder, "[");
                    namePushType(self, builder, *item);
                    namePush(builder, "; ");
                    namePushType(self, builder, *length);
                    namePush(builder, "]");
                }
                case resolver::CoreType::Optional { payload } => {
                    namePush(builder, "?");
                    namePushType(self, builder, *payload);
                }
            }
            if slice.mutable { namePush(builder, "mut "); }
            namePush(builder, "[");
            namePushType(self, builder, *slice.item);
            namePush(builder, "]");
        }
        case resolver::Type::Array(array) => {
            namePush(builder, "[");
            namePushType(self, builder, *array.item);
            namePush(builder, "; ");
            namePushType(self, builder, *array.length);
            namePush(builder, "]");
        }
        case resolver::Type::ConstArgument { value, .. } => {
            if value.negative { namePush(builder, "-"); }
            namePushU64(builder, value.magnitude);
        }
        case resolver::Type::Optional(inner) => {
            namePush(builder, "?");
            namePushType(self, builder, *inner);
        }
        case resolver::Type::Fn(info) => {
            if info.isUnsafe { namePush(builder, "unsafe "); }
            namePush(builder, "fn(");
            for param, i in info.paramTypes {
                if i > 0 { namePush(builder, ", "); }

                case resolver::NominalType::Placeholder(_) =>
                    panic "namePushType: unresolved nominal type",
            }
        }
        case resolver::Type::TraitObject(object) => {
            match object.class {
            match object.properties.class {
                case types::PointerClass::Owned => namePush(builder, "*"),
                case types::PointerClass::Ref => namePush(builder, "&"),
                case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
                case types::PointerClass::Unsafe =>
                    namePush(builder, "*unsafe "),
            }
            if object.mutable { namePush(builder, "mut "); }
            if object.properties.mutable { namePush(builder, "mut "); }
            namePush(builder, "opaque ");
            namePushTrait(self, builder, object.traitInfo);
        }
        else => panic "namePushType: non-concrete type",
    }

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

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

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

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

            set dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
        }
    } else {
        set dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
    }
    let length = resolver::concreteArrayLength(arrInfo.length)
    let concreteLength = resolver::concreteArrayLength(length)
        else throw LowerError::MissingMetadata;
    dataSliceHeader(b, dataName, length);
    dataSliceHeader(b, dataName, concreteLength);
}

/// Lower a constant expression payload into a builder without slot padding.
fn lowerConstDataPayloadInto(
    self: *mut Lowerer,

    elems: *mut [*ast::Node],
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
) throws (LowerError) {
    let case resolver::Type::Array(arrInfo) = ty
    let case resolver::Type::Core(resolver::CoreType::Array { item, .. }) = ty
        else throw LowerError::ExpectedArray;
    let elemTy = *arrInfo.item;
    let elemTy = *item;
    let elemLayout = resolver::getTypeLayout(elemTy);

    for elem in elems {
        try lowerConstDataInto(self, elem, elemTy, elemLayout.size, dataPrefix, b);
    }

    repeat: ast::ArrayRepeatLit,
    ty: resolver::Type,
    dataPrefix: *[u8],
    b: *mut DataValueBuilder
) throws (LowerError) {
    let case resolver::Type::Array(arrInfo) = ty
    let case resolver::Type::Core(resolver::CoreType::Array { item, length }) = ty
        else throw LowerError::ExpectedArray;
    let length = resolver::concreteArrayLength(arrInfo.length)
    let concreteLength = resolver::concreteArrayLength(length)
        else throw LowerError::MissingMetadata;
    let elemTy = *arrInfo.item;
    let elemTy = *item;
    let elemLayout = resolver::getTypeLayout(elemTy);

    if let case ast::NodeValue::Undef = repeat.item.value {
        dataBuilderPush(b, il::DataValue {
            item: il::DataItem::Undef,
            count: elemLayout.size * length
            count: elemLayout.size * concreteLength
        });
    } else if let val = resolver::constValueEntry(self.resolver, repeat.item) {
        if let case resolver::ConstValue::String(_) = val {
            // A string used as a slice is represented by a three-word slice
            // header, not by the bytes of the string itself.
            for _ in 0..length {
            for _ in 0..concreteLength {
                try lowerConstDataInto(self, repeat.item, elemTy, elemLayout.size, dataPrefix, b);
            }
        } else {
            dataBuilderPush(b, il::DataValue {
                item: constValueToDataItem(self, val, elemTy),
                count: length
                count: concreteLength
            });
        }
    } else {
        for _ in 0..length {
        for _ in 0..concreteLength {
            try lowerConstDataInto(self, repeat.item, elemTy, elemLayout.size, dataPrefix, b);
        }
    }
}


    }
    let isNil = pattern.value == ast::NodeValue::Nil;

    match subject.kind {
        case MatchSubjectKind::OptionalPtr if isNil => {
            // Null pointer optimization: branch on the data pointer being null.
            // Null pointer optimization branches on the niche data pointer.
            let nilReg = try optionalNilReg(self, subject.val, subject.type);
            try emitBrCmp(self, il::CmpOp::Eq, il::Type::W64, il::Val::Reg(nilReg), il::Val::Imm(0), matchBlock, fallthrough);
        }
        case MatchSubjectKind::OptionalAggregate => {
            let base = emitValToReg(self, subject.val);

            if isNil { // Optional aggregate: `nil` means tag is zero.
            if isNil {
                let tagReg = tvalTagReg(self, base);
                try emitBr(self, tagReg, fallthrough, matchBlock);
            } else {
                // `lowerExpr` applies the resolver's optional-lift coercion,
                // materializing the tagged representation for value patterns.
                // `lowerExpr` applies the optional-lift coercion and
                // materializes the tagged representation for value patterns.
                let pattVal = try lowerExpr(self, pattern);
                let pattReg = emitValToReg(self, pattVal);
                let eq = try lowerOptionalEq(self, subject.bindType, base, pattReg, 0);
                let eqReg = emitValToReg(self, eq);


            }
        }
        case MatchSubjectKind::Union(unionInfo) => {
            assert not isNil;

            let case resolver::NodeExtra::UnionVariant { tag: variantTag, .. } =
                resolver::nodeData(self.low.resolver, pattern).extra
            else {
            let case resolver::NodeExtra::UnionVariant {
                tag: variantTag,
                ..
            } = resolver::nodeData(self.low.resolver, pattern).extra else {
                throw LowerError::ExpectedVariant;
            };
            // Void unions are passed by value (the tag itself).
            // Non-void unions are passed by reference (need to load tag).
            // When matching by reference, always load from the pointer.
            if unionInfo.isAllVoid {
                let mut tagVal = subject.val;
                match subject.by {
                    case resolver::MatchBy::Ref, resolver::MatchBy::MutRef => {
                    case resolver::MatchBy::Ref,
                         resolver::MatchBy::MutRef => {
                        let base = emitValToReg(self, subject.val);
                        set tagVal = loadTag(self, base, 0, il::Type::W8);
                    }
                    case resolver::MatchBy::Value => {}
                }

                let tagReg = tvalTagReg(self, base);

                try emitBrCmp(self, il::CmpOp::Eq, il::Type::W8, il::Val::Reg(tagReg), il::Val::Imm(variantTag as i64), matchBlock, fallthrough);
            }
        }
        else => { // Value comparison.
        else => {
            assert not isNil;
            let pattVal = try lowerExpr(self, pattern);
            if isAggregateType(subject.type) {
                // Aggregate types need structural comparison rather than
                // scalar compare.

    for i in 0..(patterns.len - 1) {
        let pattern = patterns[i];
        let nextArm = try createBlock(self, "arm");
        try emitPatternMatch(self, subject, pattern, matchBlock, nextArm);

        // Seal the intermediate arm block: all predecessor edges are known
        // Seal the intermediate arm block: all predecessor edges are known.
        // This ensures SSA construction can resolve variable uses through
        // single-predecessor optimization instead of creating unresolved block
        // parameters.
        // single-predecessor optimization instead of creating unresolved
        // block parameters.
        try switchToAndSeal(self, nextArm);
    }
    // Handle last pattern: go to fallthrough block on failure.
    let last = patterns[patterns.len - 1];
    try emitPatternMatch(self, subject, last, matchBlock, fallthrough);
}

/// Emit a match binding pattern.
/// Binding patterns always match for regular values, but for optionals they
/// check for the presence of a value. Jumps to `valuePresent` on success,
/// `valueAbsent` on failure.
fn emitBindingTest(

    if unwrapped.by == resolver::MatchBy::Value and isAggregateType(unwrapped.effectiveTy) {
        set val = try emitStackVal(self, unwrapped.effectiveTy, val);
    }

    let mut bindType = unwrapped.effectiveTy;
    if let case resolver::Type::Optional(inner) = unwrapped.effectiveTy {
        set bindType = *inner;
    if let case resolver::Type::Core(
        resolver::CoreType::Optional { payload }
    ) = unwrapped.effectiveTy {
        set bindType = *payload;
    }
    let ilType = ilType(self.low, unwrapped.effectiveTy);
    let kind = matchSubjectKind(unwrapped.effectiveTy);

    return MatchSubject { val, type: unwrapped.effectiveTy, ilType, bindType, kind, by: unwrapped.by };

    let tagReg = nextReg(self);
    emitLoadW64At(self, tagReg, base, TVAL_TAG_OFFSET);
    return tagReg;
}

/// Get the register to compare against `0` for optional `nil` checking.
/// For null-ptr-optimized types, loads the data pointer, or returns it
/// directly for scalar pointers. For aggregates, returns the tag register.
/// Return the nil discriminator: thin pointers use their value, slices use their data pointer, and tagged optionals use their tag.
fn optionalNilReg(self: *mut FnLowerer, val: il::Val, typ: resolver::Type) -> il::Reg throws (LowerError) {
    let reg = emitValToReg(self, val);

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

        return il::Val::Imm(1) if isEq else il::Val::Imm(0);
    }
    let val = try lowerExpr(self, opt);
    let cmpReg = try optionalNilReg(self, val, optTy);

    // Null-pointer-optimized types compare a 64-bit pointer against zero.
    // Aggregate optionals compare an 8-bit tag byte against zero.
    let cmpType = il::Type::W64 if resolver::isOptionalPointer(optTy) else il::Type::W8;
    let inner = resolver::optionalTypeArgument(optTy)
        else throw LowerError::ExpectedOptional;
    let cmpType = il::Type::W64 if resolver::isNullableType(*inner) else il::Type::W8;

    let op = il::BinOp::Eq if isEq else il::BinOp::Ne;
    return emitTypedBinOp(self, op, cmpType, il::Val::Reg(cmpReg), il::Val::Imm(0));
}


/// tested against the subject element, branching to `failBlock` on mismatch.
fn bindArrayPatternElements(
    self: *mut FnLowerer,
    subject: *MatchSubject,
    items: *mut [*ast::Node],
    failBlock: BlockId
    failBlock: BlockId,
) throws (LowerError) {
    let case resolver::Type::Array(arrInfo) = subject.type
    let case resolver::Type::Core(resolver::CoreType::Array { item, .. }) = subject.type
        else throw LowerError::ExpectedSliceOrArray;

    let elemTy = *arrInfo.item;
    let elemTy = *item;
    let elemLayout = resolver::getTypeLayout(elemTy);
    let stride = elemLayout.size as i32;
    let base = emitValToReg(self, subject.val);

    for elem, i in items {

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

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


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

    return ty;
}

/// Check if a resolver type lowers to an aggregate in memory.
fn isAggregateType(typ: resolver::Type) -> bool {
    match typ {
        case resolver::Type::Optional(resolver::Type::Pointer(_)) => {
            // Optional pointers are scalar due to NPO.
    if let payload = resolver::optionalTypeArgument(typ) {
        if let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Thin, .. }) = *payload {
            // Optional thin pointers are scalar due to NPO.
            return false;
        }
        case resolver::Type::Optional(_) => {
            // All other optionals, including optional slices, are aggregates.
            return true;
        }
        case resolver::Type::Nominal(_) => {
        // All other optionals, including optional slices, are aggregates.
        return true;
    }
    match typ {
        case resolver::Type::Nominal(_) =>
            // Void unions are small enough to pass by value.
            return not resolver::isVoidUnion(typ);
        }
        case resolver::Type::Slice(_),
             resolver::Type::TraitObject(_),
             resolver::Type::Array(_),
             resolver::Type::Nil => return true,
            return not resolver::isVoidUnion(typ),
        case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, .. }) => return true,
        case resolver::Type::TraitObject(_) => return true,
        case resolver::Type::Nil => return true,
        case resolver::Type::Core(resolver::CoreType::Array { .. }) => return true,
        else => return false,
    }
}

/// Check if a resolver type is a small aggregate that can be

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

/// Wrap a value in an optional type.
///
/// For optional pointers (`?*T`), the value is returned as-is since pointers
/// use zero to represent `nil`. For other optionals, builds a tagged aggregate.
/// with the tag set to `1`, and the value as payload.
/// Wrap an optional payload: nullable pointers keep their representation, while other payloads use a present tag and stored value.
fn wrapInOptional(self: *mut FnLowerer, val: il::Val, optType: resolver::Type) -> il::Val throws (LowerError) {
    let case resolver::Type::Optional(inner) = optType else {
        throw LowerError::ExpectedOptional;
    };
    // Null-pointer-optimized (NPO) types are used as-is -- valid values are never null.
    let inner = resolver::optionalTypeArgument(optType)
        else throw LowerError::ExpectedOptional;
    if resolver::isNullableType(*inner) {
        return val;
    }
    let layout = resolver::getTypeLayout(optType);
    let valOffset = resolver::getOptionalValOffset(*inner) as i32;

    return try buildTagged(self, layout, 1, val, *inner, 1, valOffset);
    return try buildTagged(self, resolver::getTypeLayout(optType), 1, val, *inner, 1, resolver::getOptionalValOffset(*inner) as i32);
}

/// Build a `nil` value for an optional type.
///
/// For optional pointers (`?*T`), returns an immediate `0` (null pointer).
/// For other optionals, builds a tagged aggregate with tag set to `0` (absent).
/// Build nil: thin pointers use zero, slices use a zero data pointer and length, and tagged optionals use an absent tag.
fn buildNilOptional(self: *mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {
    let case resolver::Type::Optional(inner) = optType
    let inner = resolver::optionalTypeArgument(optType)
        else throw LowerError::ExpectedOptional;
    if let case resolver::Type::Pointer(_) = *inner {
        return il::Val::Imm(0);
    }
    if let case resolver::Type::Slice(slice) = *inner {
        return try buildSliceValue(
            self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0)
        );
    if let case resolver::Type::Core(resolver::CoreType::Pointer { shape, properties, target }) = *inner {
        match shape {
            case resolver::PointerShape::Thin => return il::Val::Imm(0),
            case resolver::PointerShape::Slice =>
                return try buildSliceValue(self, target, properties.mutable, il::Val::Imm(0), il::Val::Imm(0)),
        }
    }
    let valOffset = resolver::getOptionalValOffset(*inner) as i32;
    return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);
    return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, resolver::getOptionalValOffset(*inner) as i32);
}

/// Build a result value for throwing functions.
fn buildResult(
    self: *mut FnLowerer,

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

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

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

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

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


    // For simple inner types (no unions/nested optionals), use branchless comparison.
    // Unions and nested optionals may contain uninitialized payload bytes
    // when nil, so they need a guarded comparison.
    let isUnion = unionInfoFromType(inner) <> nil;
    let mut isOptional = false;
    if let case resolver::Type::Optional(_) = inner {
        set isOptional = true;
    }
    if not isUnion and not isOptional {
    if not isUnion and not resolver::isOptionalType(inner) {
        let tagEq = emitTypedBinOp(self, il::BinOp::Eq, il::Type::W8, tagA, tagB);
        let tagNil = emitTypedBinOp(self, il::BinOp::Eq, il::Type::W8, tagA, il::Val::Imm(0));
        let payloadEq = try emitEqAtOffset(self, a, b, offset + valOffset, inner);

        return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, tagEq,

}

/// Compare two array values for equality, element by element.
fn lowerArrayEq(
    self: *mut FnLowerer,
    arr: resolver::ArrayType,
    item: *resolver::Type,
    lengthArgument: *resolver::Type,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
    let elemLayout = resolver::getTypeLayout(*arr.item);
    let elemLayout = resolver::getTypeLayout(*item);
    let stride = elemLayout.size as i32;
    let mut result: ?il::Val = nil;
    let length = resolver::concreteArrayLength(arr.length)
    let length = resolver::concreteArrayLength(lengthArgument)
        else throw LowerError::MissingMetadata;

    for i in 0..length {
        let elemOffset = offset + (i as i32) * stride;
        let cmp = try emitEqAtOffset(self, a, b, elemOffset, *arr.item);
        let cmp = try emitEqAtOffset(self, a, b, elemOffset, *item);
        set result = emitLogicalAnd(self, result, cmp);
    }
    if let r = result {
        return r;
    }

    typ: resolver::Type,
    a: il::Reg,
    b: il::Reg,
    offset: i32
) -> il::Val throws (LowerError) {
    let mut effective = typ;
    if let payload = resolver::optionalTypeArgument(typ) {
        set effective = *payload;
    }
    if let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, properties, target }) = effective {
        return try lowerSliceEq(
            self, target, properties.mutable, a, b, offset
        );
    }
    match typ {
        case resolver::Type::Slice(slice) =>
            return try lowerSliceEq(self, slice.item, slice.mutable, a, b, offset),
        case resolver::Type::Optional(inner) => {
            if let case resolver::Type::Slice(slice) = *inner {
                // Optional slices use null pointer optimization.
                return try lowerSliceEq(self, slice.item, slice.mutable, a, b, offset);
            }
            return try lowerOptionalEq(self, *inner, a, b, offset);
        }
        case resolver::Type::Array(arr) =>
            return try lowerArrayEq(self, arr, a, b, offset),
        case resolver::Type::Core(
            resolver::CoreType::Optional { payload }
        ) => return try lowerOptionalEq(self, *payload, a, b, offset),
        case resolver::Type::Core(resolver::CoreType::Array { item, length }) =>
            return try lowerArrayEq(self, item, length, a, b, offset),
        case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) =>
            return try lowerRecordEq(self, recInfo, a, b, offset),
        case resolver::Type::Nominal(resolver::NominalType::Union(unionInfo)) =>
            return try lowerUnionEq(self, unionInfo, a, b, offset),
        else => {

/// Lower an array literal expression like `[1, 2, 3]`.
fn lowerArrayLit(self: *mut FnLowerer, node: *ast::Node, elements: *mut [*ast::Node]) -> il::Val
    throws (LowerError)
{
    let typ = try typeOf(self, node);
    let case resolver::Type::Array(arrInfo) = typ else {
        throw LowerError::ExpectedArray;
    };
    let elemTy = *arrInfo.item;
    let case resolver::Type::Core(resolver::CoreType::Array { item, .. }) = typ
        else throw LowerError::ExpectedArray;
    let elemTy = *item;
    let elemLayout = resolver::getTypeLayout(elemTy);
    let dst = try emitReserve(self, typ);

    for elemNode, i in elements {
        let elemVal = try lowerExpr(self, elemNode);

// TODO: Beyond a certain length, lower this to a loop.
fn lowerArrayRepeatLit(self: *mut FnLowerer, node: *ast::Node, repeat: ast::ArrayRepeatLit) -> il::Val
    throws (LowerError)
{
    let typ = try typeOf(self, node);
    let case resolver::Type::Array(arrInfo) = typ else {
        throw LowerError::ExpectedArray;
    };
    let elemTy = *arrInfo.item;
    let length = resolver::concreteArrayLength(arrInfo.length)
    let case resolver::Type::Core(resolver::CoreType::Array { item, length: lengthArgument }) = typ
        else throw LowerError::ExpectedArray;
    let elemTy = *item;
    let length = resolver::concreteArrayLength(lengthArgument)
        else throw LowerError::MissingMetadata;
    let elemLayout = resolver::getTypeLayout(elemTy);
    let dst = try emitReserve(self, typ);

    // Evaluate the repeated item once.

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

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

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


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

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

            set dataReg = loadSlicePtr(self, baseReg);
        }
        case resolver::Type::Array(arrInfo) => {
            set elemType = *arrInfo.item;
        case resolver::Type::Core(resolver::CoreType::Array { item, length: lengthArgument }) => {
            set elemType = *item;
            // Runtime safety check: index must be strictly less than array length.
            // Skip when the index is a compile-time constant, since we check
            // that in the resolver.
            if not resolver::isConstExpr(self.low.resolver, index) {
                let length = resolver::concreteArrayLength(arrInfo.length)
                let length = resolver::concreteArrayLength(lengthArgument)
                    else throw LowerError::MissingMetadata;
                let arrLen = il::Val::Imm(length as i64);
                try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, arrLen);
                try emitTrapUnlessCmp(
                    self, il::CmpOp::Ult, il::Type::W32, indexVal, arrLen
                );
            }
        }
        else => throw LowerError::ExpectedSliceOrArray,
    }
    let elemLayout = resolver::getTypeLayout(elemType);

    let r = try resolveSliceRangePtr(self, container, range, info);
    let itemType = try specializeType(self, *info.itemType);
    let elemSize = resolver::getTypeLayout(itemType).size;
    let rhsTy = try typeOf(self, rhs);

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


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

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

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

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

fn lowerSliceOf(self: *mut FnLowerer, node: *ast::Node, args: *mut [*ast::Node]) -> il::Val throws (LowerError) {
    if args.len <> 2 {
        throw LowerError::InvalidArgCount;
    }
    let sliceTy = try typeOf(self, node);
    let case resolver::Type::Slice(slice) = sliceTy
    let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, properties: slice, target: item }) = sliceTy
        else throw LowerError::ExpectedSliceOrArray;
    let ptrVal = try lowerExpr(self, args[0]);
    let lenVal = try lowerExpr(self, args[1]);
    return try buildSliceValue(self, slice.item, slice.mutable, ptrVal, lenVal);
    return try buildSliceValue(
        self, item, slice.mutable, ptrVal, lenVal
    );
}

/// Lower `@relocate(destination, source)` as an overlap-safe byte move.
/// Lower `@relocate(destination, source)` as an overlap-safe typed move.
fn lowerRelocate(
    self: *mut FnLowerer,
    args: *mut [*ast::Node],
) -> il::Val throws (LowerError) {
    if args.len <> 2 {
        throw LowerError::InvalidArgCount;
    }
    let destinationType = try typeOf(self, args[0]);
    let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, target: item, .. }) = destinationType
        else throw LowerError::ExpectedSliceOrArray;

    let destinationSlice = emitValToReg(self, try lowerExpr(self, args[0]));
    let destination = loadSlicePtr(self, destinationSlice);
    let destinationLen = loadSliceLen(self, destinationSlice);
    let sourceSlice = emitValToReg(self, try lowerExpr(self, args[1]));
    let source = loadSlicePtr(self, sourceSlice);
    let sourceLen = loadSliceLen(self, sourceSlice);

    // The destination must hold every source byte.
    // The destination must hold every source element.
    try emitTrapIfLt(self, il::Type::W32, destinationLen, sourceLen);
    let itemSize = resolver::getTypeLayout(*item).size;
    let mut byteLen = sourceLen;
    if itemSize <> 1 {
        set byteLen = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, sourceLen, il::Val::Imm(itemSize as i64));
    }

    let forwardBlock = try createBlock(self, "relocate.forward");
    let backwardBlock = try createBlock(self, "relocate.backward");
    let doneBlock = try createBlock(self, "relocate.done");
    try emitBrCmp(

    try switchToAndSeal(self, forwardBlock);
    try emitByteCopyLoop(
        self,
        destination,
        source,
        sourceLen,
        byteLen,
        "relocate.forward",
    );
    try emitJmp(self, doneBlock);

    // Moving toward a higher address must copy from the end for overlap safety.

        "relocate.backward",
        il::Param { value: remainingReg, type: il::Type::W32 },
    );
    let backwardBody = try createBlock(self, "relocate.backward");
    let backwardDone = try createBlock(self, "relocate.backward");
    try emitJmpWithArg(self, backwardHeader, sourceLen);
    try emitJmpWithArg(self, backwardHeader, byteLen);

    switchToBlock(self, backwardHeader);
    try emitBrCmp(
        self,
        il::CmpOp::Ult,

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

        case ast::NodeValue::Char(c) => {
            set val = il::Val::Imm(c as i64);
        }
        case ast::NodeValue::Nil => {
            let typ = try typeOf(self, node);
            if let case resolver::Type::Optional(_) = typ {
            if resolver::isOptionalType(typ) {
                set val = try buildNilOptional(self, typ);
            } else if let case resolver::Type::Nil = typ {
                // Standalone `nil` without a concrete optional type. We can't
                // generate a proper value representation.
                throw LowerError::MissingType(node);

                    else => set val = try lowerFieldAccess(self, access),
                }
            } else {
                let parentTy = try typeOf(self, access.parent);
                let mut handled = false;
                if let case resolver::Type::Array(array) = parentTy {
                if let case resolver::Type::Core(resolver::CoreType::Array { length: lengthArgument, .. }) = parentTy {
                    if let case ast::NodeValue::Ident(name) = access.child.value;
                       mem::eq(name, "len")
                    {
                        let length = resolver::concreteArrayLength(array.length)
                        let length = resolver::concreteArrayLength(lengthArgument)
                            else throw LowerError::MissingMetadata;
                        set val = il::Val::Imm(length as i64);
                        set handled = true;
                    }
                }

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

lib/std/lang/resolver.rad +706 -744

    name: *[u8],
    valueType: Type,
    symbol: *mut Symbol,
}

/// Array type payload.
export record ArrayType {
    /// Element type.
    item: *Type,
    /// Typed constant descriptor for the array length.
    length: *Type,
}

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

    args: *[*Type],
    /// Source node for the application.
    site: *ast::Node,
}

/// Pointer-like address payload.
export record PointerType {
/// Shared ownership, safety, and mutability metadata for pointer-like values.
export record PointerProperties {
    /// Ownership and safety class.
    class: types::PointerClass,
    /// Pointer target type.
    target: *Type,
    /// Whether the pointer is mutable.
    /// Whether the referenced value may be mutated.
    mutable: bool,
}

/// Pointer-like slice payload.
export record SliceType {
    /// Ownership and safety class.
    class: types::PointerClass,
    /// Slice element type.
    item: *Type,
    /// Whether the slice is mutable.
    mutable: bool,
/// Storage shape of an intrinsic pointer-like value.
export union PointerShape {
    /// One-word pointer to a single value.
    Thin,
    /// Two-word pointer and length pair.
    Slice,
}

/// Semantic application of an intrinsic core type.
export union CoreType {
    /// Pointer or slice application.
    Pointer {
        /// Storage shape and operation set.
        shape: PointerShape,
        /// Ownership, safety, and mutability metadata.
        properties: PointerProperties,
        /// Referenced value or slice element type.
        target: *Type,
    },
    /// Repeated element aggregate.
    Array {
        /// Element type.
        item: *Type,
        /// Typed constant descriptor for the array length.
        length: *Type,
    },
    /// Union-like value-or-nil application.
    Optional {
        /// Payload type.
        payload: *Type,
    },
}

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

/// Describes a type computed during semantic analysis.
export union Type {
    /// A type that couldn't be decided.

    /// Range types, eg. `start..end`.
    Range {
        start: ?*Type,
        end: ?*Type,
    },
    /// Pointer-like address.
    Pointer(PointerType),
    /// Pointer-like slice.
    Slice(SliceType),
    /// Eg. `[i32; 32]`.
    Array(ArrayType),
    /// Intrinsic pointer, slice, array, or optional application.
    Core(CoreType),
    /// Rigid integer constant parameter within a generic declaration.
    ConstParameter(*GenericParamType),
    /// Canonical typed integer generic argument.
    ConstArgument {
        type: *Type,

    /// Symbolic integer expression awaiting constant-parameter substitution.
    GenericConstExpr {
        type: *Type,
        expr: *ast::Node,
    },
    /// Eg. `?T`.
    Optional(*Type),
    /// Eg. `fn id(i32) -> i32`.
    Fn(*FnType),
    /// Named, ie. user-defined types, includes union variants.
    Nominal(*NominalType),
    /// Rigid type parameter within a generic declaration.

    GenericDataApply(*GenericDataApplyType),
    /// An erased pointer-like type with a v-table.
    TraitObject(TraitObjectType),
}

/// Construct a fixed-size intrinsic pointer application.
export fn pointerType(class: types::PointerClass, target: *Type, mutable: bool) -> Type {
    return Type::Core(CoreType::Pointer { shape: PointerShape::Thin, properties: PointerProperties { class, mutable }, target });
}

/// Construct a direct intrinsic slice application.
export fn sliceType(class: types::PointerClass, item: *Type, mutable: bool) -> Type {
    return Type::Core(CoreType::Pointer { shape: PointerShape::Slice, properties: PointerProperties { class, mutable }, target: item });
}

/// Construct an intrinsic repeated aggregate application.
export fn arrayType(item: *Type, length: *Type) -> Type {
    return Type::Core(CoreType::Array { item, length });
}

/// Construct an intrinsic value-or-nil application.
export fn optionalType(payload: *Type) -> Type {
    return Type::Core(CoreType::Optional { payload });
}

/// Return the value-type argument of a core application.
fn coreValueArgument(core: CoreType) -> *Type {
    match core {
        case CoreType::Pointer { target, .. } => return target,
        case CoreType::Array { item, .. } => return item,
        case CoreType::Optional { payload } => return payload,
    }
}

/// Return the constant argument of a core application, when present.
fn coreConstantArgument(core: CoreType) -> ?*Type {
    if let case CoreType::Array { length, .. } = core {
        return length;
    }
    return nil;
}

/// Reconstruct a core application with transformed generic arguments.
fn coreWithArguments(core: CoreType, valueArgument: *Type, constantArgument: ?*Type) -> CoreType {
    match core {
        case CoreType::Pointer { shape, properties, .. } =>
            return CoreType::Pointer { shape, properties, target: valueArgument },
        case CoreType::Array { .. } => {
            let length = constantArgument
                else panic "coreWithArguments: missing array length";
            return CoreType::Array { item: valueArgument, length };
        }
        case CoreType::Optional { .. } =>
            return CoreType::Optional { payload: valueArgument },
    }
}

/// Return a concrete `u32` array length from its typed descriptor.
export fn concreteArrayLength(length: *Type) -> ?u32 {
    let case Type::ConstArgument { type, value } = *length else return nil;
    if *type <> Type::U32 or value.negative
        or value.magnitude > parser::U32_MAX as u64

    loopDepth: u32,
}

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

/// Global resolver state.

}

/// Return whether a type contains a rigid generic parameter.
export fn containsGenericParameter(ty: Type) -> bool {
    match ty {
        case Type::Pointer(pointer) =>
            return containsGenericParameter(*pointer.target),
        case Type::Slice(slice) =>
            return containsGenericParameter(*slice.item),
        case Type::Core(core) => {
            if containsGenericParameter(*coreValueArgument(core)) {
                return true;
            }
            if let argument = coreConstantArgument(core) {
                return containsGenericParameter(*argument);
            }
            return false;
        }
        case Type::Parameter(_), Type::ConstParameter(_),
             Type::GenericConstExpr { .. } => return true,
        case Type::Array(array) =>
            return containsGenericParameter(*array.item)
                or containsGenericParameter(*array.length),
        case Type::Optional(inner) => return containsGenericParameter(*inner),
        // Symbolic anonymous records require materialization even when their
        // own fields happen not to mention a rigid parameter.
        case Type::GenericRecord(_) => return true,
        case Type::GenericDataApply(_) => return true,
        case Type::Fn(info) => {

        }
        else => return false,
    }
}

/// Return whether a by-value type reaches an in-progress nominal placeholder.
fn hasUnresolvedNominalLayout(ty: Type) -> bool {
/// Condition that prevents ordinary by-value layout.
union LayoutObstacle {
    /// A path reaches an in-progress nominal declaration.
    UnresolvedNominal,
    /// A path reaches an opaque value.
    Opaque,
    /// Layout depends on unresolved generic arguments.
    Symbolic,
}

/// Return whether a type reaches one layout obstacle by value.
fn hasLayoutObstacle(ty: Type, obstacle: LayoutObstacle) -> bool {
    match ty {
        case Type::Pointer(_), Type::Slice(_) => return false,
        case Type::Array(array) => return hasUnresolvedNominalLayout(*array.item),
        case Type::Optional(inner) => return hasUnresolvedNominalLayout(*inner),
        // Pointer and slice layouts do not depend on their targets.
        case Type::Core(CoreType::Pointer { .. }),
             Type::TraitObject(_),
             Type::Fn(_) => return false,
        case Type::Core(core) => {
            if hasLayoutObstacle(*coreValueArgument(core), obstacle) {
                return true;
            }
            if obstacle == LayoutObstacle::Symbolic {
                if let argument = coreConstantArgument(core) {
                    return containsGenericParameter(*argument);
                }
            }
            return false;
        }
        case Type::Nominal(info) => {
            if obstacle <> LayoutObstacle::UnresolvedNominal {
                return false;
            }
            if let case NominalType::Placeholder(_) = *info {
                return true;
            }
            return false;
        }
        case Type::GenericRecord(rec) => {
            if obstacle == LayoutObstacle::Symbolic {
                return true;
            }
            for field in rec.fields {
                if hasUnresolvedNominalLayout(field.fieldType) {
                if hasLayoutObstacle(field.fieldType, obstacle) {
                    return true;
                }
            }
            return false;
        }
        case Type::Opaque => return obstacle == LayoutObstacle::Opaque,
        case Type::Parameter(_), Type::ConstParameter(_),
             Type::GenericConstExpr { .. }, Type::GenericDataApply(_) =>
            return obstacle == LayoutObstacle::Symbolic,
        else => return false,
    }
}

/// Materialize concrete generic data applications within a type while

    self: *mut Resolver,
    ty: Type,
    site: *ast::Node,
) -> Type throws (ResolveError) {
    match ty {
        case Type::Pointer(pointer) => {
            let inner = try materializeConcreteGenericData(self, *pointer.target, site);
            return Type::Pointer(PointerType {
                class: pointer.class,
                target: allocType(self, inner),
                mutable: pointer.mutable,
            });
        }
        case Type::Slice(slice) => {
            let inner = try materializeConcreteGenericData(self, *slice.item, site);
            return Type::Slice(SliceType {
                class: slice.class,
                item: allocType(self, inner),
                mutable: slice.mutable,
            });
        }
        case Type::Array(array) => {
            let item = try materializeConcreteGenericData(self, *array.item, site);
            let length = try materializeConcreteGenericData(
                self, *array.length, site
        case Type::Core(core) => {
            let argument = try materializeConcreteGenericData(
                self, *coreValueArgument(core), site
            );
            return Type::Array(ArrayType {
                item: allocType(self, item),
                length: allocType(self, length),
            });
        }
        case Type::Optional(inner) => {
            let value = try materializeConcreteGenericData(self, *inner, site);
            return Type::Optional(allocType(self, value));
            let mut constantArgument: ?*Type = nil;
            if let descriptor = coreConstantArgument(core) {
                let concrete = try materializeConcreteGenericData(
                    self, *descriptor, site
                );
                set constantArgument = allocType(self, concrete);
            }
            return Type::Core(coreWithArguments(
                core,
                allocType(self, argument),
                constantArgument,
            ));
        }
        case Type::GenericDataApply(app) => {
            let a = alloc::arenaAllocator(&mut self.arena);
            let mut args = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            let mut concrete = true;

export fn copyStructuralTypeToArena(
    ty: Type,
    arena: *mut alloc::Arena,
) -> Type {
    match ty {
        case Type::Pointer(pointer) => {
            let target = copyStructuralTypeToArena(*pointer.target, arena);
            return Type::Pointer(PointerType {
                class: pointer.class,
                target: allocArenaType(arena, target),
                mutable: pointer.mutable,
            });
        }
        case Type::Slice(slice) => {
            let item = copyStructuralTypeToArena(*slice.item, arena);
            return Type::Slice(SliceType {
                class: slice.class,
                item: allocArenaType(arena, item),
                mutable: slice.mutable,
            });
        }
        case Type::Array(array) => {
            let item = copyStructuralTypeToArena(*array.item, arena);
            let length = copyStructuralTypeToArena(*array.length, arena);
            return Type::Array(ArrayType {
                item: allocArenaType(arena, item),
                length: allocArenaType(arena, length),
            });
        }
        case Type::Optional(inner) => {
            let stored = copyStructuralTypeToArena(*inner, arena);
            return Type::Optional(allocArenaType(arena, stored));
        case Type::Core(core) => {
            let argument = copyStructuralTypeToArena(
                *coreValueArgument(core), arena
            );
            let mut constantArgument: ?*Type = nil;
            if let descriptor = coreConstantArgument(core) {
                let stored = copyStructuralTypeToArena(*descriptor, arena);
                set constantArgument = allocArenaType(arena, stored);
            }
            return Type::Core(coreWithArguments(
                core,
                allocArenaType(arena, argument),
                constantArgument,
            ));
        }
        case Type::Fn(info) => {
            let a = alloc::arenaAllocator(arena);
            let mut params = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            let mut throwList = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };

                        else throw ResolveError::Failure;
                    return Type::ConstArgument { type, value };
                }
            }
        }
        case Type::Pointer(pointer) => {
            let inner = try substituteTypeWithContext(context, *pointer.target, sub);
            return Type::Pointer(PointerType {
                class: pointer.class,
                target: allocSubstitutedType(context, inner),
                mutable: pointer.mutable,
            });
        }
        case Type::Slice(slice) => {
            let inner = try substituteTypeWithContext(context, *slice.item, sub);
            return Type::Slice(SliceType {
                class: slice.class,
                item: allocSubstitutedType(context, inner),
                mutable: slice.mutable,
            });
        }
        case Type::Array(array) => {
            let item = try substituteTypeWithContext(context, *array.item, sub);
            let length = try substituteTypeWithContext(
                context, *array.length, sub
        case Type::Core(core) => {
            let argument = try substituteTypeWithContext(
                context, *coreValueArgument(core), sub
            );
            return Type::Array(ArrayType {
                item: allocSubstitutedType(context, item),
                length: allocSubstitutedType(context, length),
            });
        }
        case Type::Optional(inner) => {
            let value = try substituteTypeWithContext(context, *inner, sub);
            return Type::Optional(allocSubstitutedType(context, value));
            let mut constantArgument: ?*Type = nil;
            if let descriptor = coreConstantArgument(core) {
                let replacement = try substituteTypeWithContext(
                    context, *descriptor, sub
                );
                set constantArgument =
                    allocSubstitutedType(context, replacement);
            }
            return Type::Core(coreWithArguments(
                core,
                allocSubstitutedType(context, argument),
                constantArgument,
            ));
        }
        case Type::GenericDataApply(app) => {
            let a = alloc::arenaAllocator(substitutionArena(context));
            let mut args = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };
            let mut symbolic = false;

                    context, field.fieldType, sub
                );
                let mut storedFieldType = fieldType;
                match *context {
                    case TypeSubstitutionContext::Resolution { resolver, site } => {
                        if hasUnresolvedNominalLayout(fieldType) {
                        if hasLayoutObstacle(
                            fieldType, LayoutObstacle::UnresolvedNominal
                        ) {
                            throw emitError(
                                resolver, site, ErrorKind::GenericRecursiveLayout
                            );
                        }
                        try ensureStorableType(resolver, site, fieldType);

}

/// Get the layout of a type.
export fn getTypeLayout(ty: Type) -> Layout {
    match ty {
        case Type::Pointer(_) => return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
        case Type::Slice(_), Type::TraitObject(_) =>
        case Type::Core(CoreType::Pointer { shape, .. }) => {
            match shape {
                case PointerShape::Thin =>
                    return Layout { size: PTR_SIZE, alignment: PTR_SIZE },
                case PointerShape::Slice =>
                    return Layout { size: PTR_SIZE * 2, alignment: PTR_SIZE },
            }
        }
        case Type::Core(CoreType::Array { item, length }) =>
            return getArrayLayout(item, length),
        case Type::Core(CoreType::Optional { payload }) => {
            if isNullableType(*payload) {
                return getTypeLayout(*payload);
            }
            let payloadLayout = getTypeLayout(*payload);
            let payloadOffset = getOptionalValOffset(*payload);
            let alignment = max(payloadLayout.alignment, 1);
            return Layout {
                size: mem::alignUp(payloadOffset + payloadLayout.size, alignment),
                alignment,
            };
        }
        case 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::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 layout;
}

/// Get the layout of a concrete array type.
export fn getArrayLayout(arr: ArrayType) -> Layout {
    let length = concreteArrayLength(arr.length)
/// Get the layout of a concrete array application.
export fn getArrayLayout(item: *Type, lengthArgument: *Type) -> Layout {
    if hasLayoutObstacle(*lengthArgument, LayoutObstacle::Symbolic) {
        panic "getArrayLayout: symbolic array length";
    }
    let length = concreteArrayLength(lengthArgument)
        else panic "getArrayLayout: symbolic array length";
    let itemLayout = getTypeLayout(*arr.item);
    let itemLayout = getTypeLayout(*item);
    return Layout {
        size: itemLayout.size * length,
        alignment: itemLayout.alignment,
    };
}

/// Get the layout of an optional type.
export fn getOptionalLayout(inner: Type) -> Layout {
    // Nullable types use null pointer optimization -- no tag byte needed.
    if isNullableType(inner) {
        return getTypeLayout(inner);
    }
    let innerLayout = getTypeLayout(inner);
    let tagSize: u32 = 1;
    let valOffset = mem::alignUp(tagSize, innerLayout.alignment);
    let alignment = max(innerLayout.alignment, 1);

    return Layout {
        size: mem::alignUp(valOffset + innerLayout.size, alignment),
        alignment,
    };
/// Return the payload of an optional type.
export fn optionalTypeArgument(ty: Type) -> ?*Type {
    if let case Type::Core(CoreType::Optional { payload }) = ty {
        return payload;
    }
    return nil;
}

/// Get the payload offset within an optional aggregate.
export fn getOptionalValOffset(inner: Type) -> u32 {
    let innerLayout = getTypeLayout(inner);
    return mem::alignUp(1, innerLayout.alignment);
/// Get the byte offset of an optional payload.
export fn getOptionalValOffset(payload: Type) -> u32 {
    return mem::alignUp(1, getTypeLayout(payload).alignment);
}

/// Check if a type is optional.
export fn isOptionalType(ty: Type) -> bool {
    match ty {
        case Type::Optional(_) => return true,
        else => return false,
    }
}

/// Check if a type uses null pointer optimization.
/// This applies to optional pointers `?*T` and optional slices `?*[T]`,
/// where `nil` is represented as a null data pointer with no tag byte.
export fn isOptionalPointer(ty: Type) -> bool {
    if let case Type::Optional(inner) = ty {
        return isNullableType(*inner);
    }
    return false;
}

/// Check if a type uses the optional aggregate representation.
export fn isOptionalAggregate(ty: Type) -> bool {
    if let case Type::Optional(inner) = ty {
        return not isNullableType(*inner);
    }
    return false;
    return optionalTypeArgument(ty) <> nil;
}

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

/// Get the layout of a nominal type.
export fn getNominalLayout(info: NominalType) -> Layout {
    match info {

}

/// Check if a type should be treated as an address-like value.
fn isAddressType(ty: Type) -> bool {
    match ty {
        case Type::Pointer(_), Type::Slice(_), Type::Fn(_) => return true,
        case Type::Core(CoreType::Pointer { .. }) => 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::Slice(slice) => try ensureTypeResolved(self, *slice.item, site),
        case Type::Pointer(_) => {}, // Pointers have fixed layout, don't recurse.
        case Type::Array(arr) => try ensureTypeResolved(self, *arr.item, site),
        case Type::Optional(inner) => try ensureTypeResolved(self, *inner, site),
        // Pointer and slice layouts never depend on their targets, which also
        // cuts recursive nominal layout cycles.
        case Type::Core(CoreType::Pointer { .. }) => {},
        case Type::Core(core) =>
            try ensureTypeResolved(self, *coreValueArgument(core), site),
        else => {},
    }
}

/// Ensure a nominal type has its body resolved.

        to == types::PointerClass::Owned
        and from == types::PointerClass::Ref
    );
}

/// Return whether pointer properties permit assignment.
fn pointerPropertiesAssignable(
    to: PointerProperties,
    from: PointerProperties,
) -> bool {
    return pointerClassesAssignable(to.class, from.class)
        and (not to.mutable or from.mutable);
}

/// 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 typesEqual(to, from) {
        return Coercion::Identity;
    }
    if let case Type::Pointer(lhs) = to {
        let case Type::Pointer(rhs) = from else return nil;
        if not pointerClassesAssignable(lhs.class, rhs.class) {
            return nil;
        }
        // Allow coercion from `*T` to `*opaque`, and mutable counterparts.
        if *lhs.target == Type::Opaque {
            if lhs.mutable and not rhs.mutable {
    if let case Type::Core(lhs) = to {
        match lhs {
            case CoreType::Pointer { shape: lhsShape, properties: lhsProperties, target: lhsTarget } => {
                let case Type::Core(CoreType::Pointer { shape: rhsShape, properties: rhsProperties, target: rhsTarget }) = from else return nil;
                if lhsShape <> rhsShape
                    or not pointerPropertiesAssignable(
                        lhsProperties, rhsProperties
                    )
                {
                    return nil;
                }
                // Allow pointer-like coercion from `T` to `opaque`, including
                // mutable counterparts.
                if *lhsTarget == Type::Opaque {
                    return Coercion::Identity;
                }
                return isAssignable(self, *lhsTarget, *rhsTarget, rval);
            }
            case CoreType::Array { item: lhsItem, length: lhsLength } => {
                let case Type::Core(CoreType::Array {
                    item: rhsItem, length: rhsLength
                }) = from else return nil;
                if not typesEqual(*lhsLength, *rhsLength) {
                    return nil;
                }
                // For array literals, check each element individually for
                // assignability.
                match rval.value {
                    case ast::NodeValue::ArrayLit(items) => {
                        if let length = concreteArrayLength(lhsLength); length == 0 {
                            return Coercion::Identity;
                        }
                        // TODO: This won't work, because we should be setting
                        // coercions for every list item, but we don't. It's best
                        // to not have an `isAssignable` function and just have
                        // one that records coercions.
                        if isListAssignable(self, *lhsItem, items) {
                            return Coercion::Identity;
                        }
                        return nil;
                    }
                    case ast::NodeValue::ArrayRepeatLit(repeat) =>
                        return isAssignable(
                            self, *lhsItem, *rhsItem, repeat.item
                        ),
                    else => {
                        if typesEqual(*lhsItem, *rhsItem) {
                            return Coercion::Identity;
                        }
                        return nil;
                    }
                }
            }
            case CoreType::Optional { payload } => {
                if from == Type::Nil {
                    return Coercion::OptionalLift(to);
                }
                if let _ = isAssignable(self, *payload, from, rval) {
                    return Coercion::OptionalLift(to);
                }
                if let case Type::Core(CoreType::Optional {
                    payload: fromPayload
                }) = from {
                    return isAssignable(self, *payload, *fromPayload, rval);
                }
                return nil;
            }
            return Coercion::Identity;
        }
        if lhs.mutable and not rhs.mutable {
            return nil;
        }
        return isAssignable(self, *lhs.target, *rhs.target, rval);
    }
    if let case Type::TraitObject(lhs) = to {
        if let case Type::Pointer(rhs) = from {
            if not pointerClassesAssignable(lhs.class, rhs.class)
                or (lhs.mutable and not rhs.mutable)
            {
        if let case Type::Core(CoreType::Pointer { shape: PointerShape::Thin, properties, target }) = from {
            if not pointerPropertiesAssignable(lhs.properties, properties) {
                return nil;
            }
            if let inst = findInstance(self, lhs.traitInfo, *rhs.target) {
                return Coercion::TraitObject { traitInfo: lhs.traitInfo, inst };
            if let inst = findInstance(self, lhs.traitInfo, *target) {
                return Coercion::TraitObject {
                    traitInfo: lhs.traitInfo,
                    inst,
                };
            }
        }
        if let case Type::TraitObject(rhs) = from {
            if not pointerClassesAssignable(lhs.class, rhs.class)
                or lhs.traitInfo <> rhs.traitInfo
            {
                return nil;
            }
            if lhs.mutable and not rhs.mutable {
            if not pointerPropertiesAssignable(
                lhs.properties, rhs.properties
            ) or lhs.traitInfo <> rhs.traitInfo {
                return nil;
            }
            return Coercion::Identity;
        }
        return nil;
    }
    if let case Type::Slice(lhs) = to {
        let case Type::Slice(rhs) = from else return nil;
        if not pointerClassesAssignable(lhs.class, rhs.class)
            or (lhs.mutable and not rhs.mutable)
        {
            return nil;
        }
        // Allow coercion from `*[T]` to `*[opaque]`, and mutable counterparts.
        if *lhs.item == Type::Opaque {
            return Coercion::Identity;
        }
        return isAssignable(self, *lhs.item, *rhs.item, rval);
    }
    match to {
        case Type::Array(lhs) => {
            let case Type::Array(rhs) = from
                else return nil;

            if not typesEqual(*lhs.length, *rhs.length) {
                return nil;
            }
            // For array literals, check each element individually for
            // assignability.
            match rval.value {
                case ast::NodeValue::ArrayLit(items) => {
                    if let length = concreteArrayLength(lhs.length); length == 0 {
                        return Coercion::Identity;
                    }
                    // TODO: This won't work, because we should be setting coercions
                    // for every list item, but we don't. It's best to not have an
                    // `isAssignable` function and just have one that records coercions.
                    if isListAssignable(self, *lhs.item, items) {
                        return Coercion::Identity;
                    }
                    return nil;
                }
                case ast::NodeValue::ArrayRepeatLit(repeat) => {
                    return isAssignable(self, *lhs.item, *rhs.item, repeat.item);
                }
                else => {
                    if typesEqual(*lhs.item, *rhs.item) {
                        return Coercion::Identity;
                    }
                    return nil;
                }
            }
        }

        case Type::Optional(inner) => {
            if from == Type::Nil {
                return Coercion::OptionalLift(to);
            }
            if let _ = isAssignable(self, *inner, from, rval) {
                return Coercion::OptionalLift(to);
            }
            if let case Type::Optional(fromInner) = from {
                return isAssignable(self, *inner, *fromInner, rval);
            }
            return nil;
        }

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

        }
    }
    return true;
}

/// Return whether two core applications are structurally equal.
fn coreTypesEqual(left: CoreType, right: CoreType) -> bool {
    match left {
        case CoreType::Pointer { shape, properties, target } => {
            let case CoreType::Pointer {
                shape: rightShape, properties: rightProperties, target: rightTarget
            } = right else return false;
            return shape == rightShape and properties == rightProperties
                and typesEqual(*target, *rightTarget);
        }
        case CoreType::Array { item, length } => {
            let case CoreType::Array {
                item: rightItem, length: rightLength
            } = right else return false;
            return typesEqual(*item, *rightItem)
                and typesEqual(*length, *rightLength);
        }
        case CoreType::Optional { payload } => {
            let case CoreType::Optional { payload: rightPayload } = right
                else return false;
            return typesEqual(*payload, *rightPayload);
        }
    }
}

/// Check if two types are structurally equal.
export fn typesEqual(a: Type, b: Type) -> bool {
    if let case Type::Core(lhs) = a {
        let case Type::Core(rhs) = b else return false;
        return coreTypesEqual(lhs, rhs);
    }
    if a == b {
        return true;
    }
    if let case Type::Pointer(av) = a {
        let case Type::Pointer(bv) = b else return false;
        return av.class == bv.class and av.mutable == bv.mutable
            and typesEqual(*av.target, *bv.target);
    }
    if let case Type::Slice(av) = a {
        let case Type::Slice(bv) = b else return false;
        return av.class == bv.class and av.mutable == bv.mutable
            and typesEqual(*av.item, *bv.item);
    }
    if let case Type::TraitObject(av) = a {
        let case Type::TraitObject(bv) = b else return false;
        return av.class == bv.class and av.mutable == bv.mutable
        return av.properties == bv.properties
            and av.traitInfo == bv.traitInfo;
    }
    match a {
        case Type::Range { start: aStart, end: aEnd } => {
            let case Type::Range { start: bStart, end: bEnd } = b

                let bValue = bEnd else return false;
                return typesEqual(*aValue, *bValue);
            }
            return bEnd == nil;
        }
        case Type::Array(aa) => {
            let case Type::Array(ab) = b else return false;
            return typesEqual(*aa.length, *ab.length)
                and typesEqual(*aa.item, *ab.item);
        }
        case Type::Optional(oa) => {
            let case Type::Optional(ob) = b else return false;
            return typesEqual(*oa, *ob);
        }
        case Type::Fn(fa) => {
            let case Type::Fn(fb) = b else return false;
            return fnTypeEqual(fa, fb);
        }
        case Type::GenericDataApply(aa) => {

        }
        else => return false,
    }
}

/// Return whether `ty` is a direct reference.
export fn isRefType(ty: Type) -> bool {
/// Return the shared properties of a direct pointer-like value.
fn pointerProperties(ty: Type) -> ?PointerProperties {
    match ty {
        case Type::Pointer(PointerType { class: types::PointerClass::Ref, .. }),
             Type::Slice(SliceType { class: types::PointerClass::Ref, .. }),
             Type::TraitObject(TraitObjectType { class: types::PointerClass::Ref, .. }) => return true,
        else => return false,
        case Type::Core(CoreType::Pointer { properties, .. }) =>
            return properties,
        case Type::TraitObject(info) => return info.properties,
        else => return nil,
    }
}

/// Return whether `ty` is a direct reference.
export fn isRefType(ty: Type) -> bool {
    let properties = pointerProperties(ty) else return false;
    return properties.class == types::PointerClass::Ref;
}

/// Return whether a type contains a reference.
fn containsRef(ty: Type) -> bool {
    if isRefType(ty) {
        return true;
    }
    if let case Type::Pointer(pointer) = ty {
        return containsRef(*pointer.target);
    }
    if let case Type::Slice(slice) = ty {
        return containsRef(*slice.item);
    }
    match ty {
        case Type::Array(array) => return containsRef(*array.item),
        case Type::Optional(inner) => return containsRef(*inner),
        case Type::Core(core) =>
            return containsRef(*coreValueArgument(core)),
        case Type::GenericRecord(rec) => {
            for field in rec.fields {
                if containsRef(field.fieldType) {
                    return true;
                }

    }
}

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

        case Type::Array(array) => return isLinear(*array.item),
        case Type::Optional(inner) => return isLinear(*inner),
        case Type::Core(core) =>
            return isLinear(*coreValueArgument(core)),
        case Type::Nominal(NominalType::Record(recInfo)) => {
            if recInfo.declaredLinear {
                return true;
            }
            for field in recInfo.fields {

    }
}

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

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

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

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

    }
    if left == right {
        return true;
    }
    // Comparisons with optionals.
    if let case Type::Optional(l) = left {
        if let case Type::Optional(r) = right {
            return isComparable(*l, *r);
    if let case Type::Core(CoreType::Optional { payload: lhs }) = left {
        if let case Type::Core(CoreType::Optional { payload: rhs }) = right {
            return isComparable(*lhs, *rhs);
        } else if right == Type::Nil {
            return true;
        }
        return isComparable(*l, right);
    } else if let case Type::Optional(_) = right {
        return isComparable(right, left); // Flip order.
        return isComparable(*lhs, right);
    } else if isOptionalType(right) {
        return isComparable(right, left);
    }
    // Pointer comparisons ignore mutability.
    if let case Type::Pointer(l) = left {
        if let case Type::Pointer(r) = right {
            return typesEqual(*l.target, *r.target);
    if let case Type::Core(CoreType::Pointer { shape: PointerShape::Thin, target: lhs, .. }) = left {
        if let case Type::Core(CoreType::Pointer { shape: PointerShape::Thin, target: rhs, .. }) = right {
            return typesEqual(*lhs, *rhs);
        }
    }
    // Numeric types.
    if isNumericType(left) and isNumericType(right) {
        return true;


/// Check that a type is optional, otherwise throw an error.
fn checkOptional(self: *mut Resolver, node: *ast::Node) -> *Type
    throws (ResolveError)
{
    if let case Type::Optional(inner) = try infer(self, node) {
        return inner;
    if let case Type::Core(CoreType::Optional { payload }) =
        try infer(self, node)
    {
        return payload;
    }
    throw emitError(self, node, ErrorKind::ExpectedOptional);
}

/// Check that a node's type is equal to the expected type.

    self: *mut Resolver,
    ty: Type,
    visited: ?*GenericRootVisit,
) -> bool {
    match ty {
        case Type::Pointer(pointer) =>
            return markGenericDataTypeRootedInner(self, *pointer.target, visited),
        case Type::Slice(slice) =>
            return markGenericDataTypeRootedInner(self, *slice.item, visited),
        case Type::Array(array) =>
            return markGenericDataTypeRootedInner(self, *array.item, visited),
        case Type::Optional(inner) =>
            return markGenericDataTypeRootedInner(self, *inner, visited),
        case Type::Core(core) => {
            let mut changed = markGenericDataTypeRootedInner(
                self, *coreValueArgument(core), visited
            );
            if let argument = coreConstantArgument(core) {
                set changed = markGenericDataTypeRootedInner(
                    self, *argument, visited
                ) or changed;
            }
            return changed;
        }
        case Type::Fn(info) => {
            let mut changed = markGenericDataTypeRootedInner(
                self, *info.returnType, visited
            );
            for param in info.paramTypes {

                members, substitution
            } => {
                set fieldType = try substituteType(
                    self, *members[i], substitution, typeNode
                );
                if hasUnresolvedNominalLayout(fieldType) {
                if hasLayoutObstacle(
                    fieldType, LayoutObstacle::UnresolvedNominal
                ) {
                    throw emitError(
                        self, typeNode, ErrorKind::GenericRecursiveLayout
                    );
                }
                try ensureStorableType(self, typeNode, fieldType);

                members, substitution
            } => {
                set valueType = try substituteType(
                    self, *members[i], substitution, variantNode
                );
                if hasUnresolvedNominalLayout(valueType) {
                if hasLayoutObstacle(
                    valueType, LayoutObstacle::UnresolvedNominal
                ) {
                    throw emitError(
                        self, variantNode, ErrorKind::GenericRecursiveLayout
                    );
                }
                if let typeNode = variantDecl.type {

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

        case ast::NodeValue::Try(expr) => return try resolveTry(self, node, expr, hint),
        case ast::NodeValue::Return { value } => return try resolveReturn(self, node, value),
        case ast::NodeValue::Throw { expr } => return try resolveThrow(self, node, expr),
        case ast::NodeValue::Panic { message } => {
            // TODO: Have easy access to string type.
            try visitOptional(self, message, Type::Slice(SliceType {
                class: types::PointerClass::Owned,
                item: allocType(self, Type::U8),
                mutable: false,
            }));
            try visitOptional(self, message, sliceType(types::PointerClass::Owned, allocType(self, Type::U8), false));
            return setNodeType(self, node, Type::Never);
        },
        case ast::NodeValue::Assert { condition, message } => {
            try visit(self, condition, Type::Bool);
            // TODO: Have easy access to string type.
            try visitOptional(self, message, Type::Slice(SliceType {
                class: types::PointerClass::Owned,
                item: allocType(self, Type::U8),
                mutable: false,
            }));
            try visitOptional(self, message, sliceType(types::PointerClass::Owned, allocType(self, Type::U8), false));
            return setNodeType(self, node, Type::Void);
        },
        case ast::NodeValue::UnOp(unop) => return try resolveUnOp(self, node, unop),
        case ast::NodeValue::ExprStmt(expr) => {
            // Pass `Void` as expected type to indicate value is discarded.

            // `super` by itself is invalid, must be used in scope access.
            throw emitError(self, node, ErrorKind::InvalidModulePath);
        },
        case ast::NodeValue::Nil => {
            // Use the hint type if it's an optional, otherwise fall back to `Nil`.
            if let case Type::Optional(_) = hint {
            if isOptionalType(hint) {
                return setNodeType(self, node, hint);
            }
            return setNodeType(self, node, Type::Nil);
        },
        case ast::NodeValue::Undef => {

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

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

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

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

        // Validate that the instance method's signature matches the
        // trait method's signature exactly (params, return type, throws).
        if sig.params.len <> expectedFn.paramTypes.len {
            throw emitError(self, methodNode, ErrorKind::FnArgCountMismatch(CountMismatch {

    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(receiver) = fullReceiverTy
        else throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
    let concreteType = *receiver.target;
    let case Type::Core(CoreType::Pointer { shape: PointerShape::Thin, properties: receiver, target }) = fullReceiverTy else {
        throw emitError(self, receiverType, ErrorKind::TraitReceiverMismatch);
    };
    let concreteType = *target;
    let case Type::Nominal(nominalTy) = concreteType
        else throw emitError(self, receiverType, ErrorKind::ExpectedRecord);
    try ensureNominalResolved(self, nominalTy, receiverType);

    let methodName = try nodeName(self, name);

    // Resolve parameter types.
    let a = alloc::arenaAllocator(&mut self.arena);
    let mut paramTypes = vec::Vec⟨*Type⟩ { data: &mut [], len: 0 };

    // Receiver is the first parameter.
    let receiverPtrType = Type::Pointer(PointerType {
        class: receiver.class,
        target: allocType(self, concreteType),
        mutable: receiver.mutable,
    });
    let receiverPtrType = pointerType(
        receiver.class, allocType(self, concreteType), receiver.mutable
    );
    vec::append⟨*Type⟩(
        &mut paramTypes, allocType(self, receiverPtrType), a
    );

    for paramNode in sig.params {

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

                        } else => {}
                    }
                } else => {}
            }
        }
        case Type::Array(arrayInfo) => {
        case Type::Core(CoreType::Array { item, length }) => {
            if let case ast::NodeValue::ArrayLit(items) = pattern.value {
                let length = concreteArrayLength(arrayInfo.length)
                    else throw emitError(self, pattern, ErrorKind::ConstExprRequired);
                if items.len as u32 <> length {
                    throw emitError(self, pattern, ErrorKind::RecordFieldCountMismatch(
                        CountMismatch { expected: length, actual: items.len as u32 }
                    ));
                let lengthValue = concreteArrayLength(length)
                    else throw emitError(
                        self, pattern, ErrorKind::ConstExprRequired
                    );
                if items.len as u32 <> lengthValue {
                    throw emitError(
                        self,
                        pattern,
                        ErrorKind::RecordFieldCountMismatch(CountMismatch {
                            expected: lengthValue,
                            actual: items.len as u32,
                        }),
                    );
                }
                let elemTy = *arrayInfo.item;
                for item in items {
                    try resolveCasePattern(self, item, elemTy, IdentMode::Bind, matchBy);
                let elemTy = *item;
                for child in items {
                    try resolveCasePattern(
                        self, child, elemTy, IdentMode::Bind, matchBy
                    );
                }
                setNodeType(self, pattern, scrutineeTy);
                return;
            }
        } else => {}

        }
    }
    // Extract item type and store pre-computed loop metadata for the lowerer.
    let mut itemTy: Type = undefined;
    match iterableTy {
        case Type::Slice(slice) => {
            set itemTy = *slice.item;
        case Type::Core(CoreType::Pointer { shape: PointerShape::Slice, target, .. }) => {
            set itemTy = *target;
            setForLoopInfo(self, node, ForLoopInfo::Collection {
                elemType: slice.item, length: nil, bindingName, indexName
                elemType: target,
                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.


            setForLoopInfo(self, node, ForLoopInfo::Range {
                valType, range, bindingName, indexName
            });
        }
        case Type::Array(arrayInfo) => {
            set itemTy = *arrayInfo.item;
        case Type::Core(CoreType::Array { item, length }) => {
            set itemTy = *item;
            setForLoopInfo(self, node, ForLoopInfo::Collection {
                elemType: arrayInfo.item,
                length: arrayInfo.length,
                elemType: item,
                length,
                bindingName,
                indexName,
            });
        }
        else => throw emitError(self, forStmt.iterable, ErrorKind::ExpectedIterable),

    throws (ResolveError)
{
    let subjectTy = try infer(self, sw.subject);
    let subject = unwrapMatchSubject(subjectTy);

    if let case Type::Optional(inner) = subject.effectiveTy {
        try resolveMatchOptional(self, node, sw, inner, subject.by);
    } else if let case Type::Nominal(NominalType::Union(u)) = subject.effectiveTy {
    if let case Type::Core(CoreType::Optional { payload }) =
        subject.effectiveTy
    {
        try resolveMatchOptional(self, node, sw, payload, subject.by);
    } else if let case Type::Nominal(NominalType::Union(u)) =
        subject.effectiveTy
    {
        try resolveMatchUnion(self, node, sw, subject.effectiveTy, u, subject.by);
    } else {
        try resolveMatchGeneric(self, node, sw, subject.effectiveTy);
    }


    sw: ast::Match,
    innerTy: *Type,
    matchBy: MatchBy
) -> Type throws (ResolveError)
{
    let subjectTy = Type::Optional(innerTy);
    let subjectTy = optionalType(innerTy);
    let prongs = sw.prongs;
    let mut hasValue = false;
    let mut hasNil = false;
    let mut catchAll = false;
    let mut matchType = Type::Never;

) -> Type throws (ResolveError) {
    match prong.arm {
        case ast::ProngArm::Binding(pat) => {
            // For optionals, bind the unwrapped inner type.
            let mut bindTy = subjectTy;
            if let case Type::Optional(inner) = subjectTy {
                set bindTy = *inner;
            if let case Type::Core(CoreType::Optional { payload }) = subjectTy {
                set bindTy = *payload;
            }
            try bindPatternVar(self, pat, bindTy, matchBy);
        }
        case ast::ProngArm::Case(patterns) => {
            for pattern in patterns {

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

    let exprTy = try infer(self, pat.scrutinee);

    match pat.kind {
        case ast::PatternKind::Binding => {
            // Simple binding requires an optional expression.
            let case Type::Optional(inner) = exprTy else {
                throw emitError(self, pat.scrutinee, ErrorKind::ExpectedOptional);
            let case Type::Core(CoreType::Optional { payload }) = exprTy else {
                throw emitError(
                    self, pat.scrutinee, ErrorKind::ExpectedOptional
                );
            };
            let payloadTy = *inner;
            let payloadTy = *payload;
            let _ = try bindValueIdent(self, pat.pattern, node, payloadTy, pat.mutable, 0, 0);
            // The `else` branch supplies the binding when the optional is nil.
            try checkAssignable(self, letElse.elseBranch, payloadTy);

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

                expected: 2,
                actual: args.len as u32,
            }));
        }
        let ptrType = try visit(self, args[0], Type::Unknown);
        let case Type::Pointer(ptr) = ptrType else {
        let case Type::Core(CoreType::Pointer { shape: PointerShape::Thin, properties, target }) = ptrType else {
            throw emitError(self, node, ErrorKind::ExpectedPointer);
        };
        let _ = try checkAssignable(self, args[1], Type::U32);
        return setNodeType(self, node, Type::Slice(SliceType {
            class: ptr.class,
            item: ptr.target,
            mutable: ptr.mutable,
        }));
        return setNodeType(
            self,
            node,
            sliceType(properties.class, target, properties.mutable),
        );
    }
    if kind == ast::Builtin::Relocate {
        if args.len <> 2 {
            throw emitError(self, node, ErrorKind::BuiltinArgCountMismatch(CountMismatch {
                expected: 2,
                actual: args.len as u32,
            }));
        }
        let destinationType = try visit(self, args[0], Type::Unknown);
        let case Type::Slice(destination) = destinationType else {
        let case Type::Core(CoreType::Pointer { shape: PointerShape::Slice, properties: destination, target: item }) = destinationType else {
            throw emitError(self, args[0], ErrorKind::ExpectedIndexable);
        };
        if not destination.mutable or not typesEqual(*destination.item, Type::U8) {
        if hasLayoutObstacle(*item, LayoutObstacle::Opaque) {
            throw emitError(self, args[0], ErrorKind::OpaqueTypeNotAllowed);
        }
        if not destination.mutable {
            throw emitTypeMismatch(self, args[0], TypeMismatch {
                expected: Type::Slice(SliceType {
                    class: destination.class,
                    item: allocType(self, Type::U8),
                    mutable: true,
                }),
                expected: sliceType(destination.class, item, true),
                actual: destinationType,
            });
        }
        let sourceType = try visit(self, args[1], Type::Unknown);
        let case Type::Slice(source) = sourceType else {
        let case Type::Core(CoreType::Pointer { shape: PointerShape::Slice, properties: source, target: sourceItem }) = sourceType else {
            throw emitError(self, args[1], ErrorKind::ExpectedIndexable);
        };
        if not source.mutable or not typesEqual(*source.item, Type::U8) {
        if not source.mutable or not typesEqual(*sourceItem, *item) {
            throw emitTypeMismatch(self, args[1], TypeMismatch {
                expected: Type::Slice(SliceType {
                    class: source.class,
                    item: allocType(self, Type::U8),
                    mutable: true,
                }),
                expected: sliceType(source.class, item, true),
                actual: sourceType,
            });
        }
        return setNodeType(self, node, Type::Void);
    }

    }
    if not containsGenericParameter(pattern) {
        return true;
    }
    match pattern {
        case Type::Pointer(pointer) => {
            let case Type::Pointer(actualPointer) = actual else return false;
            return pointer.class == actualPointer.class
                and pointer.mutable == actualPointer.mutable
                and inferGenericArgument(
                    self,
                    *pointer.target,
                    *actualPointer.target,
                    params,
                    inferred,
                );
        }
        case Type::Slice(slice) => {
            let case Type::Slice(actualSlice) = actual else return false;
            return slice.class == actualSlice.class
                and slice.mutable == actualSlice.mutable
                and inferGenericArgument(
        case Type::Core(core) => {
            let case Type::Core(actualCore) = actual else return false;
            let placeholder = coreValueArgument(core);
            if not coreTypesEqual(
                coreWithArguments(core, placeholder, placeholder),
                coreWithArguments(actualCore, placeholder, placeholder),
            ) { return false; }
            if let patternConstant = coreConstantArgument(core) {
                let actualConstant = coreConstantArgument(actualCore)
                    else return false;
                if not inferGenericArgument(
                    self,
                    *slice.item,
                    *actualSlice.item,
                    *patternConstant,
                    *actualConstant,
                    params,
                    inferred,
                );
        }
        case Type::Optional(inner) => {
            let case Type::Optional(actualInner) = actual else return false;
            return inferGenericArgument(
                self, *inner, *actualInner, params, inferred
            );
        }
        case Type::Array(array) => {
            let case Type::Array(actualArray) = actual else return false;
                ) {
                    return false;
                }
            }
            return inferGenericArgument(
                self, *array.length, *actualArray.length, params, inferred
            ) and inferGenericArgument(
                self, *array.item, *actualArray.item, params, inferred
                self,
                *coreValueArgument(core),
                *coreValueArgument(actualCore),
                params,
                inferred,
            );
        }
        case Type::GenericDataApply(application) => {
            let case Type::Nominal(nominal) = actual else return false;
            let concrete = genericDataSpecializationForNominal(self, nominal)

        return nil;
    }
    let traitSym = try resolveNamePath(self, access.parent);
    let case SymbolData::Trait(traitInfo) = traitSym.data else return nil;
    let receiverTy = try infer(self, call.args[0]);
    let case Type::Pointer(receiver) = receiverTy else return nil;
    let case Type::Parameter(param) = *receiver.target else return nil;
    let case Type::Core(CoreType::Pointer { shape: PointerShape::Thin, properties: receiver, target }) = receiverTy else return nil;
    let case Type::Parameter(param) = *target else return nil;
    let mut hasBound = false;
    for bound in param.bounds {
        if bound == traitInfo {
            set hasBound = true;
            break;

            );
            let case Type::Fn(info) = calleeTy
                else throw emitError(self, call.callee, ErrorKind::Internal);
            if selected.method.mutable {
                let mut isMutPtr = false;
                if let case Type::Pointer(pointer) = parentTy {
                    set isMutPtr = pointer.mutable;
                if let properties = pointerProperties(parentTy) {
                    set isMutPtr = properties.mutable;
                }
                if not isMutPtr and not (try canBorrowMutFrom(self, access.parent)) {
                if not isMutPtr
                    and not (try canBorrowMutFrom(self, access.parent))
                {
                    throw emitError(self, access.parent, ErrorKind::ImmutableBinding);
                }
            }
            try checkUnsafeCall(self, call.callee, info);
            try checkCallArgs(self, node, call, info, ctx);

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

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

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

            try checkSliceRangeIndices(self, range);

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

            if let case Type::Slice(slice) = subjectTy {
                if not slice.mutable {
                    throw emitError(self, container, ErrorKind::ImmutableBinding);
            let case Type::Core(core) = subjectTy
                else throw emitError(
                    self, container, ErrorKind::ExpectedIndexable
                );
            match core {
                case CoreType::Pointer { shape: PointerShape::Slice, properties, target } => {
                    if not properties.mutable {
                        throw emitError(
                            self, container, ErrorKind::ImmutableBinding
                        );
                    }
                    set item = target;
                }
                set item = slice.item;
            } else {
                match subjectTy {
                    case Type::Array(a) => {
                        if let length = concreteArrayLength(a.length) {
                            try validateArraySliceBounds(self, range, length, node);
                        }
                        set item = a.item;
                        set capacity = a.length;
                case CoreType::Array { item: arrayItem, length } => {
                    if let value = concreteArrayLength(length) {
                        try validateArraySliceBounds(
                            self, range, value, node
                        );
                    }
                    else => throw emitError(self, container, ErrorKind::ExpectedIndexable),
                    set item = arrayItem;
                    set capacity = length;
                }
                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(source) = rhsTy {
                if *source.item <> *item {
            if let case Type::Core(CoreType::Pointer { shape: PointerShape::Slice, target, .. }) = rhsTy {
                if not typesEqual(*target, *item) {
                    throw emitTypeMismatch(
                        self,
                        assign.right,
                        TypeMismatch { expected: *item, actual: *source.item },
                        TypeMismatch { expected: *item, actual: *target },
                    );
                }
            } else {
                try checkAssignable(self, assign.right, *item);
            }
            setSliceRangeInfo(self, node, SliceRangeInfo { itemType: item, mutable: true, capacity });
            setSliceRangeInfo(self, node, SliceRangeInfo {
                itemType: item,
                mutable: true,
                capacity,
            });
            setNodeType(self, assign.left, *item);

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

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

    match subjectTy {
        case Type::Array(arrayInfo) => {
            return setNodeType(self, node, *arrayInfo.item);
        }
        else => {
            throw emitError(self, container, ErrorKind::ExpectedIndexable);
    if let case Type::Core(core) = subjectTy {
        match core {
            case CoreType::Pointer { shape: PointerShape::Slice, target, .. } =>
                return setNodeType(self, node, *target),
            case CoreType::Array { item, .. } =>
                return setNodeType(self, node, *item),
            else => {}
        }
    }
    throw emitError(self, container, ErrorKind::ExpectedIndexable);
}

/// Find a record field by name.
fn findRecordField(s: *RecordType, fieldName: *[u8]) -> ?u32 {
    for field, i in s.fields {

fn resolveAnonRecordLit(self: *mut Resolver, node: *ast::Node, lit: ast::RecordLit, hint: Type) -> Type
    throws (ResolveError)
{
    // Unwrap optional hint to get the inner record type.
    let mut innerHint = hint;
    if let case Type::Optional(inner) = hint {
        set innerHint = *inner;
    if let case Type::Core(CoreType::Optional { payload }) = hint {
        set innerHint = *payload;
    }
    let mut hintInfo: ?RecordType = nil;
    if let case Type::Nominal(info) = innerHint {
        try ensureNominalResolved(self, info, node);
        if let case NominalType::Record(s) = *info {

        setNodeType(self, fieldNode, fieldType);
    }
    return setNodeType(self, node, innerHint);
}

/// Return an array element type supplied directly or through an optional hint.
fn arrayItemFromHint(hint: Type) -> ?Type {
    let mut candidate = hint;
    if let case Type::Core(CoreType::Optional { payload }) = hint {
        set candidate = *payload;
    }
    if let case Type::Core(CoreType::Array { item, .. }) = candidate {
        return *item;
    }
    return nil;
}

/// Analyze an array literal expression.
fn resolveArrayLit(self: *mut Resolver, node: *ast::Node, items: *mut [*ast::Node], hint: Type) -> Type
    throws (ResolveError)
{
    let length = items.len;
    let mut expectedTy: Type = Type::Unknown;

    if let case Type::Array(ary) = hint {
        set expectedTy = *ary.item;
    } else if let case Type::Optional(inner) = hint {
        if let case Type::Array(ary) = *inner {
            set expectedTy = *ary.item;
        }
    };
    if let item = arrayItemFromHint(hint) {
        set expectedTy = item;
    }
    for itemNode in items {
        let itemTy = try visit(self, itemNode, expectedTy);
        assert itemTy <> Type::Unknown;

        // Set the expected type to the first type we encounter.

        }
    }
    if expectedTy == Type::Unknown {
        throw emitError(self, node, ErrorKind::CannotInferType);
    };
    let arrayTy = Type::Array(ArrayType {
        item: allocType(self, expectedTy),
        length: allocConcreteArrayLength(self, length),
    });
    let arrayTy = arrayType(allocType(self, expectedTy), allocConcreteArrayLength(self, length));
    return setNodeType(self, node, arrayTy);
}

/// Analyze an array repeat literal expression.
fn resolveArrayRepeat(self: *mut Resolver, node: *ast::Node, lit: ast::ArrayRepeatLit, hint: Type) -> Type
    throws (ResolveError)
{
    let mut itemHint = hint;
    if let case Type::Array(ary) = hint {
        set itemHint = *ary.item;
    } else if let case Type::Optional(inner) = hint {
        if let case Type::Array(ary) = *inner {
            set itemHint = *ary.item;
        }
    if let item = arrayItemFromHint(hint) {
        set itemHint = item;
    }
    let valueTy = try visit(self, lit.item, itemHint);
    let _ = try checkNumeric(self, lit.count);
    let mut length: *Type = undefined;
    if let value = constValueEntry(self, lit.count) {

    {
        set length = allocSymbolicArrayLength(self, lit.count);
    } else {
        throw emitError(self, lit.count, ErrorKind::ConstExprRequired);
    }
    return setNodeType(self, node, Type::Array(ArrayType {
        item: allocType(self, valueTy),
    return setNodeType(self, node, arrayType(
        allocType(self, valueTy),
        length,
    }));
    ));
}

/// Resolve union variant access.
fn resolveUnionVariantAccess(
    self: *mut Resolver,

    let parentTy = try infer(self, access.parent);
    if isUnsafePointerType(parentTy) {
        try requireUnsafe(self, access.parent);
    }
    let subjectTy = autoDeref(parentTy);
    if let case Type::Slice(slice) = subjectTy {
    if let case Type::Core(CoreType::Pointer { shape: PointerShape::Slice, properties, target }) = 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(PointerType {
                    class: slice.class,
                    target: slice.item,
                    mutable: slice.mutable,
                }),
                pointerType(properties.class, target, properties.mutable),
            );
        }
        if mem::eq(fieldName, LEN_FIELD) {
            setRecordFieldIndex(self, fieldNode, 1);
            return setNodeType(self, node, Type::U32);

            if let method = findMethod(self, subjectTy, fieldName) {
                return setNodeType(self, node, Type::Fn(method.fnType));
            }
            throw emitError(self, node, ErrorKind::RecordFieldUnknown(fieldName));
        }
        case Type::Array(arrayInfo) => {
        case Type::Core(CoreType::Array { length, .. }) => {
            let fieldNode = access.child;
            let fieldName = try nodeName(self, fieldNode);

            if mem::eq(fieldName, LEN_FIELD) {
                if let length = concreteArrayLength(arrayInfo.length) {
                if let value = concreteArrayLength(length) {
                    setNodeConstValue(
                        self, node, constInt(length as u64, 32, false, false)
                        self, node, constInt(value as u64, 32, false, false)
                    );
                }
                return setNodeType(self, node, Type::U32);
            }
            throw emitError(self, node, ErrorKind::ArrayFieldUnknown(fieldName));
            throw emitError(
                self, node, ErrorKind::ArrayFieldUnknown(fieldName)
            );
        }
        else => {
            // Check for standalone methods on any nominal type (e.g. unions).
            if let case Type::Nominal(_) = subjectTy {
                let fieldName = try nodeName(self, access.child);

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

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

            if let case Type::Slice(slice) = subjectTy {
                return slice.mutable;
            }
            if let case Type::Array(_) = subjectTy {
                return try canBorrowMutFrom(self, container);
            if let case Type::Core(core) = subjectTy {
                match core {
                    case CoreType::Pointer { shape: PointerShape::Slice, properties, .. } =>
                        return properties.mutable,
                    case CoreType::Array { .. } =>
                        return try canBorrowMutFrom(self, container),
                    else => {}
                }
            }
            return false;
        }
        case ast::NodeValue::ArrayLit(_),
             ast::NodeValue::ArrayRepeatLit(_) =>

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

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

            try checkSliceRangeIndices(self, range);

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

            if let case Type::Slice(slice) = subjectTy {
                if addr.mutable and not slice.mutable {
                    throw emitError(self, addr.target, ErrorKind::ImmutableBinding);
                }
                set item = slice.item;
            } else {
                match subjectTy {
                    case Type::Array(arrayInfo) => {
                        if let length = concreteArrayLength(arrayInfo.length) {
                            try validateArraySliceBounds(self, range, length, node);
                        }
                        set item = arrayInfo.item;
                        set capacity = arrayInfo.length;
            let case Type::Core(core) = subjectTy
                else throw emitError(
                    self, container, ErrorKind::ExpectedIndexable
                );
            match core {
                case CoreType::Pointer { shape: PointerShape::Slice, properties, target } => {
                    if addr.mutable and not properties.mutable {
                        throw emitError(
                            self, addr.target, ErrorKind::ImmutableBinding
                        );
                    }
                    else => {
                        throw emitError(self, container, ErrorKind::ExpectedIndexable);
                    set item = target;
                }
                case CoreType::Array { item: arrayItem, length } => {
                    if let value = concreteArrayLength(length) {
                        try validateArraySliceBounds(
                            self, range, value, node
                        );
                    }
                    set item = arrayItem;
                    set capacity = length;
                }
                else => throw emitError(
                    self, container, ErrorKind::ExpectedIndexable
                ),
            }
            let sliceTy = Type::Slice(SliceType {
                class,
                item,
                mutable: addr.mutable,
            });
            let sliceTy = sliceType(class, item, addr.mutable);
            let alloc = allocType(self, sliceTy);
            setSliceRangeInfo(self, node, SliceRangeInfo {
                itemType: item,
                mutable: addr.mutable,
                capacity,

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

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

                else => {}
            }
        }
    }

    if let case Type::Array(arrayInfo) = targetTy {
    if let case Type::Core(CoreType::Array { item, .. }) = targetTy {
        match addr.target.value {
            case ast::NodeValue::ArrayLit(_),
                 ast::NodeValue::ArrayRepeatLit(_) =>
            {
                let sliceTy = Type::Slice(SliceType {
                    class,
                    item: arrayInfo.item,
                    mutable: addr.mutable,
                });
                let sliceTy = sliceType(class, item, addr.mutable);
                return setNodeType(self, node, *allocType(self, sliceTy));
            }
            else => {}
        }
    }
    let pointerTy = Type::Pointer(PointerType {
    let pointerTy = pointerType(
        class,
        target: allocType(self, targetTy),
        mutable: addr.mutable,
    });
        allocType(self, targetTy),
        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(pointer) = operandTy {
        if pointer.class == types::PointerClass::Unsafe {
    if let case Type::Core(CoreType::Pointer { shape: PointerShape::Thin, properties, target }) = operandTy {
        if properties.class == types::PointerClass::Unsafe {
            try requireUnsafe(self, targetNode);
        }
        // Disallow dereferencing opaque pointers.
        if *pointer.target == Type::Opaque {
            throw emitError(self, targetNode, ErrorKind::OpaqueTypeDeref);
        if *target == Type::Opaque {
            throw emitError(self, node, ErrorKind::OpaqueTypeDeref);
        }
        return setNodeType(self, node, *pointer.target);
        return setNodeType(self, node, *target);
    }
    // Auto-deref for single-field unlabeled records.
    if let case Type::Nominal(NominalType::Record(recInfo)) = operandTy {
        if not recInfo.labeled and recInfo.fields.len == 1 {
            let fieldTy = recInfo.fields[0].fieldType;

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

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

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

/// Check if an `as` cast between two types is valid.
fn isValidCast(source: Type, target: Type) -> bool {
/// Check if an `as` cast is valid.
fn isValidCast(source: Type, target: Type, allowRefToUnsafe: bool) -> bool {
    // Allow identity casts.
    if source == target {
    if typesEqual(source, target) {
        return true;
    }
    // Allow numeric to numeric.
    if isNumericType(source) and isNumericType(target) {
        return true;

    // Allow `void` union to numeric.
    // TODO: Check that variant index fits in target type.
    if isVoidUnion(source) and isNumericType(target) {
        return true;
    }
    // Allow address to numeric.
    if let case Type::Slice(_) = source {
        // Disallow slice to numeric; slices are fat pointers.
    } else if isAddressType(source) and isNumericType(target) {
    // Thin pointers and function addresses can be cast to numeric values.
    if isAddressType(source) and isNumericType(target) {
        if let case Type::Core(CoreType::Pointer { shape: PointerShape::Slice, .. }) = source {
            return false;
        }
        return true;
    }
    // Allow pointer casts if one side is `*opaque` or target types are castable.
    if let case Type::Pointer(sourcePointer) = source {
        if let case Type::Pointer(targetPointer) = target {
            if sourcePointer.class <> targetPointer.class {
                return false;
            }
            if targetPointer.mutable and not sourcePointer.mutable {
                return false;
            }
            if isOpaquePointer(source) or isOpaquePointer(target) {
                return true;
            }
            return isValidCast(*sourcePointer.target, *targetPointer.target);
        }
    let case Type::Core(CoreType::Pointer { shape: sourceShape, properties: sourceProperties, target: sourceTarget }) = source else return false;
    let case Type::Core(CoreType::Pointer { shape: targetShape, properties: targetProperties, target: targetTarget }) = target else return false;
    let classCompatible = sourceProperties.class == targetProperties.class
        or (allowRefToUnsafe
            and sourceProperties.class == types::PointerClass::Ref
            and targetProperties.class == types::PointerClass::Unsafe);
    if sourceShape <> targetShape
        or not classCompatible
        or (targetProperties.mutable and not sourceProperties.mutable)
    {
        return false;
    }
    // Allow slice casts if one side is `*[opaque]`, target is `*[u8]`,
    // or element types are castable.
    if let case Type::Slice(sourceSlice) = source {
        if let case Type::Slice(targetSlice) = target {
            if sourceSlice.class <> targetSlice.class {
                return false;
            }
            if targetSlice.mutable and not sourceSlice.mutable {
                return false;
            }
            if isOpaqueSlice(source) or isOpaqueSlice(target) {
                return true;
            }
            if *targetSlice.item == Type::U8 {
                return true;
            }
            return isValidCast(*sourceSlice.item, *targetSlice.item);
        }
    if *sourceTarget == Type::Opaque or *targetTarget == Type::Opaque {
        return true;
    }
    match sourceShape {
        // Slices additionally allow casts to a byte target.
        case PointerShape::Slice if *targetTarget == Type::U8 => return true,
        else => return isValidCast(*sourceTarget, *targetTarget, false),
    }
    return false;
}

/// Analyze an `as` cast expression.
fn resolveAs(self: *mut Resolver, node: *ast::Node, expr: ast::As) -> Type
    throws (ResolveError)

    }

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

    let mut valid = isValidCast(sourceTy, targetTy);
    if let case Type::Pointer(sourcePointer) = sourceTy {
        if let case Type::Pointer(targetPointer) = targetTy {
            if sourcePointer.class == types::PointerClass::Ref and
               targetPointer.class == types::PointerClass::Unsafe and
               (not targetPointer.mutable or sourcePointer.mutable) and
               isValidCast(*sourcePointer.target, *targetPointer.target)
            {
                set valid = true;
            }
        }
    }
    if let case Type::Slice(sourceSlice) = sourceTy {
        if let case Type::Slice(targetSlice) = targetTy {
            if sourceSlice.class == types::PointerClass::Ref and
               targetSlice.class == types::PointerClass::Unsafe and
               (not targetSlice.mutable or sourceSlice.mutable) and
               isValidCast(*sourceSlice.item, *targetSlice.item)
            {
                set valid = true;
            }
        }
    }
    let valid = isValidCast(sourceTy, targetTy, 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 {

    // If we're not catching the error, nor panicking on error, nor returning
    // optional, then the current function must be able to propagate it.
    let mut tryResultTy = resultTy;
    if tryExpr.returnsOptional {
        // `try?` converts errors to `nil` and wraps the result in an optional.
        if let case Type::Optional(_) = resultTy {
            // Already optional, no wrapping needed.
        } else {
            set tryResultTy = Type::Optional(allocType(self, resultTy));
        if not isOptionalType(resultTy) {
            set tryResultTy = optionalType(allocType(self, resultTy));
        }
    } else if tryExpr.catches.len > 0 {
        // `try ... catch` -- one or more catch clauses.
        set tryResultTy = try resolveTryCatches(self, node, tryExpr.catches, calleeInfo, resultTy, hint);
    } else if not tryExpr.shouldPanic {

            // We use the already-optional type from the other side rather than
            // constructing a new optional, so that e.g. `?u8 == 42` coerces
            // `42` to `?u8` (not `?i32`). We also record OptionalLift directly
            // rather than using expectAssignable, because comparisons should
            // allow e.g. `?*mut T == *T` where mutability differs.
            if let case Type::Optional(_) = leftTy {
            if isOptionalType(leftTy) {
                if not isOptionalType(rightTy) {
                    setNodeCoercion(self, binop.right, Coercion::OptionalLift(leftTy));
                }
            } else if let case Type::Optional(_) = rightTy {
            } else if isOptionalType(rightTy) {
                setNodeCoercion(self, binop.left, Coercion::OptionalLift(rightTy));
            }
            set resultTy = Type::Bool;
        },
        else => {

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

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

                            self, length, ErrorKind::ConstExprRequired
                        );
                    }
                }
            }
            set ty = Type::Array(ArrayType {
                item: allocType(self, item),
                length: lengthType,
            });
            set ty = arrayType(allocType(self, item), lengthType);
        }
        case ast::TypeSig::Slice { class, itemType, mutable } => {
            let item = try resolveTypeSyntax(self, itemType, context);
            set ty = Type::Slice(SliceType {
                class,
                item: allocType(self, item),
                mutable,
            });
            set ty = sliceType(class, allocType(self, item), mutable);
        }
        case ast::TypeSig::Pointer { class, valueType, mutable } => {
            let target = try resolveTypeSyntax(self, valueType, context);
            set ty = Type::Pointer(PointerType {
                class,
                target: allocType(self, target),
                mutable,
            });
            set ty = pointerType(class, allocType(self, target), mutable);
        }
        case ast::TypeSig::Optional { valueType } => {
            let payload = try resolveTypeSyntax(self, valueType, context);
            set ty = Type::Optional(allocType(self, payload));
            set ty = optionalType(allocType(self, payload));
        }
        case ast::TypeSig::Nominal(name) => {
            if let case TypeSyntaxContext::Symbolic = context {
                if let case ast::NodeValue::GenericApply(app) = name.value {
                    let templateSym = try resolveGenericDataTarget(self, app.target);

            if not traitInfo.objectSafe {
                throw emitError(self, traitName, ErrorKind::TraitNotObjectSafe);
            }
            setNodeSymbol(self, traitName, sym);
            set ty = Type::TraitObject(TraitObjectType {
                class,
                properties: PointerProperties { class, mutable },
                traitInfo,
                mutable,
            });
        }
    }
    return setNodeType(self, node, ty);
}

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

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


    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(PointerType { class: types::PointerClass::Ref, mutable, .. }) = expected {
            set argExclusive = mutable;
        } else if let case Type::Slice(SliceType {
            class: types::PointerClass::Ref, mutable, ..
        }) = expected {
            set argExclusive = mutable;
        } else if let case Type::TraitObject(TraitObjectType {
            class: types::PointerClass::Ref, mutable, ..
        }) = expected {
            set argExclusive = mutable;
        if let properties = pointerProperties(expected);
            properties.class == types::PointerClass::Ref
        {
            set argExclusive = properties.mutable;
        }
        if not isUnsafePointerType(expected) {
            if let rootSym = root {
                for j in 0..rootsLen {
                    if let previous = roots[j] {

lib/std/lang/resolver/printer.rad +32 -24

            io::print("i32");
        }
        case super::Type::I64 => {
            io::print("i64");
        }
        case super::Type::Pointer(pointer) => {
            printPtrPrefix(pointer.class, pointer.mutable);
            printTypeBody(*pointer.target, brief);
        }
        case super::Type::Slice(slice) => {
            printPtrPrefix(slice.class, slice.mutable);
            io::print("[");
            printTypeBody(*slice.item, brief);
            io::print("]");
        }
        case super::Type::Array(array) => {
            io::print("[");
            printTypeBody(*array.item, brief);
            io::print("; ");
            if let length = super::concreteArrayLength(array.length) {
                io::printU32(length);
            } else {
                printTypeBody(*array.length, brief);
        case super::Type::Core(core) => {
            match core {
                case super::CoreType::Pointer { shape, properties, target } => {
                    printPtrPrefix(properties.class, properties.mutable);
                    match shape {
                        case super::PointerShape::Thin =>
                            printTypeBody(*target, brief),
                        case super::PointerShape::Slice => {
                            io::print("[");
                            printTypeBody(*target, brief);
                            io::print("]");
                        }
                    }
                }
                case super::CoreType::Array { item, length } => {
                    io::print("[");
                    printTypeBody(*item, brief);
                    io::print("; ");
                    if let value = super::concreteArrayLength(length) {
                        io::printU32(value);
                    } else {
                        printTypeBody(*length, brief);
                    }
                    io::print("]");
                }
                case super::CoreType::Optional { payload } => {
                    io::print("?");
                    printTypeBody(*payload, brief);
                }
            }
            io::print("]");
        }
        case super::Type::Optional(inner) => {
            io::print("?");
            printTypeBody(*inner, brief);
        }
        case super::Type::Fn(fnType) => {
            if fnType.isUnsafe {
                io::print("unsafe ");
            }

                printTypeBody(*arg, brief);
            }
            io::print("]");
        }
        case super::Type::TraitObject(object) => {
            printPtrPrefix(object.class, object.mutable);
            printPtrPrefix(
                object.properties.class, object.properties.mutable
            );
            io::print("opaque ");
            io::print(object.traitInfo.name);
        }
        case super::Type::Range { start, end } => {
            if let s = start {

lib/std/lang/resolver/tests.rad +85 -80


/// 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;
    let actualLength = super::concreteArrayLength(info.length)
    let case super::Type::Core(super::CoreType::Array {
        item, length: lengthArgument
    }) = ty else throw testing::TestError::Failed;
    let actualLength = super::concreteArrayLength(lengthArgument)
        else throw testing::TestError::Failed;
    try testing::expect(actualLength == 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(super::SliceType {
        class: types::PointerClass::Owned, item, mutable: sliceMut
    }) = ty
        else throw testing::TestError::Failed;
    try testing::expect(sliceMut == mutable);

    return *item;
}

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

    try testing::expect(actualShape == shape);
    try testing::expect(properties.class == types::PointerClass::Owned);
    try testing::expect(properties.mutable == mutable);
    return *target;
}

/// Verify that a node has a constant integer value with the expected magnitude.
fn expectConstInt(a: *super::Resolver, node: *ast::Node, expected: u32)

    let mut a = testResolver();
    let result = try resolveExprStr(&mut a, "\"hello\"");

    try expectNoErrors(&result);
    let ty = try typeOf(&a, result.root);
    let elemTy = try expectSliceType(ty, false);
    let elemTy = try expectPointerType(ty, super::PointerShape::Slice, false);
    try testing::expect(elemTy == super::Type::U8);
}

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

    let stmt = try getBlockStmt(result.root, 0);
    let case ast::NodeValue::Let(decl) = stmt.value
        else throw testing::TestError::Failed;
    let arrayTy = try typeOf(&a, decl.value);
    let elemTy = try expectArrayType(arrayTy, 2);
    let case super::Type::Optional(inner) = elemTy
    let case super::Type::Core(super::CoreType::Optional { payload }) = elemTy
        else throw testing::TestError::Failed;
    try testing::expect(*inner == super::Type::I32);
    try testing::expect(*payload == super::Type::I32);
}

@test fn testResolveArrayLiteralOptionalMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(&mut a, "let xs: [?bool; 2] = [1, 2];");


    let sliceStmt = try getBlockStmt(result.root, 1);
    let case ast::NodeValue::Let(sliceDecl) = sliceStmt.value
        else throw testing::TestError::Failed;
    let sliceTy = try typeOf(&a, sliceDecl.value);
    let elemTy = try expectSliceType(sliceTy, false);
    let elemTy = try expectPointerType(sliceTy, super::PointerShape::Slice, false);
    try testing::expect(elemTy == super::Type::I32);

    let indexStmt = try getBlockStmt(result.root, 2);
    try expectExprStmtType(&a, indexStmt, super::Type::I32);
}


    let ptrStmt = try getBlockStmt(result.root, 3);
    let case ast::NodeValue::ExprStmt(ptrExpr) = ptrStmt.value
        else throw testing::TestError::Failed;
    let ptrTy = try typeOf(&a, ptrExpr);
    let targetTy = try expectPointerType(ptrTy, false);
    let targetTy = try expectPointerType(ptrTy, super::PointerShape::Thin, false);
    try testing::expect(targetTy == super::Type::I32);
}

@test fn testResolveSliceLiteralImmutable() throws (testing::TestError) {
    let mut a = testResolver();

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

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



    // Verify the array constant has the correct type with length 3.
    let arrStmt = try getBlockStmt(result.root, 1);
    let sym = super::symbolFor(&a, arrStmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
        else throw testing::TestError::Failed;
    let actualLength = super::concreteArrayLength(arrType.length)
    let case super::SymbolData::Constant { type: arrayType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(actualLength == 3);
    let _ = try expectArrayType(arrayType, 3);
}

/// Test that a record field can use a constant as its array length.
@test fn testRecordFieldWithConstArrayLength() throws (testing::TestError) {
    let mut a = testResolver();

        let case super::ErrorKind::TypeMismatch(_) = err.kind
            else throw testing::TestError::Failed;
    }
}

/// Test `@relocate` accepts mutable slices with a matching non-byte item type.
@test fn testResolveRelocateTypedSlices() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(destination: *mut [i32], source: *mut [i32]) { @relocate(destination, source); }";
    let result = try resolveProgramStr(&mut a, program);
    try expectNoErrors(&result);
}

/// Test `@relocate` rejects mutable slices with different item types.
@test fn testResolveRelocateItemMismatch() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "fn f(destination: *mut [i32], source: *mut [u32]) { @relocate(destination, source); }";
    let result = try resolveProgramStr(&mut a, program);
    let err = try expectError(&result);
    let case super::ErrorKind::TypeMismatch(_) = err.kind
        else throw testing::TestError::Failed;
}

/// Test `@relocate` rejects slices whose item size is unknown.
@test fn testResolveRelocateOpaqueItems() throws (testing::TestError) {
    {
        let mut a = testResolver();
        let program = "fn f(destination: *mut [opaque], source: *mut [opaque]) { @relocate(destination, source); }";
        let result = try resolveProgramStr(&mut a, program);
        let _ = try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
    } {
        let mut a = testResolver();
        let program = "fn f(destination: *mut [[opaque; 2]], source: *mut [[opaque; 2]]) { @relocate(destination, source); }";
        let result = try resolveProgramStr(&mut a, program);
        let _ = try expectErrorKind(&result, super::ErrorKind::OpaqueTypeNotAllowed);
    }
}

/// Test `match &opt` produces immutable pointer bindings.
@test fn testResolveMatchRefUnionBinding() throws (testing::TestError) {
    let mut a = testResolver();
    let program = "union Opt { Some(i32), None } fn f() { let opt = Opt::Some(42); match &opt { case Opt::Some(x) => { *x; } else => {} } }";
    let result = try resolveProgramStr(&mut a, program);

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

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

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

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

    try expectNoErrors(&result);

    let arrStmt = try getBlockStmt(result.root, 3);
    let sym = super::symbolFor(&a, arrStmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
    let case super::SymbolData::Constant { type: arrayType, .. } = sym.data
        else throw testing::TestError::Failed;
    let actualLength = super::concreteArrayLength(arrType.length)
        else throw testing::TestError::Failed;
    try testing::expect(actualLength == 5);
    let _ = try expectArrayType(arrayType, 5);
}

/// Test cross-module constant expression: a constant in one module references
/// a constant from another module via scope access.
@test fn testCrossModuleConstExpr() throws (testing::TestError) {

    try expectNoErrors(&result);

    let arrStmt = try getBlockStmt(result.root, 2);
    let sym = super::symbolFor(&a, arrStmt)
        else throw testing::TestError::Failed;
    let case super::SymbolData::Constant { type: super::Type::Array(arrType), .. } = sym.data
        else throw testing::TestError::Failed;
    let actualLength = super::concreteArrayLength(arrType.length)
    let case super::SymbolData::Constant { type: arrayType, .. } = sym.data
        else throw testing::TestError::Failed;
    try testing::expect(actualLength == 4);
    let _ = try expectArrayType(arrayType, 4);
}

/// Test unsuffixed integer literals in constant expressions.
@test fn testConstExprUnsuffixedLiterals() throws (testing::TestError) {
    try expectConstFold("constant A: u32 = 4 * 4;", 0, 16);

    let sym = super::symbolFor(&a, block.statements[0])
        else throw testing::TestError::Failed;
    let template = super::genericTemplateFor(&a, sym)
        else throw testing::TestError::Failed;
    let rigid = super::Type::Parameter(template.params[0]);
    let pointer = super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Owned,
        target: super::allocType(&mut a, rigid),
        mutable: true,
    });
    let symbolic = super::Type::Optional(super::allocType(&mut a, pointer));
    let pointer = super::pointerType( types::PointerClass::Owned, super::allocType(&mut a, rigid), true, );
    let symbolic = super::optionalType( super::allocType(&mut a, pointer), );
    let concrete = super::allocType(&mut a, super::Type::U32);
    let args: [*super::Type; 1] = [concrete];
    let sub = super::Substitution { params: template.params, args: &args[..] };
    let replaced = try super::substituteType(
        &mut a, symbolic, &sub, block.statements[0]
    ) catch {
        throw testing::TestError::Failed;
    };
    let case super::Type::Optional(inner) = replaced
    let case super::Type::Core(super::CoreType::Optional { payload }) = replaced
        else throw testing::TestError::Failed;
    let case super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Owned, target, mutable
    }) = *inner
    let case super::Type::Core(super::CoreType::Pointer { shape: super::PointerShape::Thin, properties, target }) = *payload
        else throw testing::TestError::Failed;
    assert mutable;
    assert properties.class == types::PointerClass::Owned;
    assert properties.mutable;
    assert *target == super::Type::U32;
}

/// Duplicate generic parameter names are rejected in their declaration scope.
@test fn testDuplicateGenericParameterRejected() throws (testing::TestError) {

        "record Value {} fn invalid⟨T: Value⟩(value: T) {}",
    );
    try expectErrorKind(&result, super::ErrorKind::GenericBoundNotTrait);
}

/// Integer constant parameters specialize array layouts.
/// Non-u32 integer constant parameters specialize array layouts.
@test fn testGenericConstParameterArrayLayout() throws (testing::TestError) {
    let mut a = testResolver();
    let result = try resolveProgramStr(
        &mut a,
        "record Buffer⟨constant N: u32⟩ { data: [u8; N] } instantiate Buffer⟨4⟩;",
        "record Buffer⟨constant N: u64⟩ { data: [u8; N] } instantiate Buffer⟨4⟩;",
    );
    try expectNoErrors(&result);
    let case ast::NodeValue::Block(block) = result.root.value
        else throw testing::TestError::Failed;
    let case ast::NodeValue::Instantiate(applications) = block.statements[1].value

        else throw testing::TestError::Failed;
    let case super::Type::Nominal(nominal) = resolved
        else throw testing::TestError::Failed;
    let case super::NominalType::Record(recordType) = *nominal
        else throw testing::TestError::Failed;
    let case super::Type::Array(arrayType) = recordType.fields[0].fieldType
        else throw testing::TestError::Failed;
    let actualLength = super::concreteArrayLength(arrayType.length)
        else throw testing::TestError::Failed;
    assert actualLength == 4;
    let item = try expectArrayType(recordType.fields[0].fieldType, 4);
    assert item == super::Type::U8;
    assert recordType.layout.size == 4;
}

/// Equivalent integer expressions share a canonical specialization.
@test fn testGenericConstParameterCanonical() throws (testing::TestError) {

        else throw testing::TestError::Failed;
    let case super::Type::Nominal(listType) = resolved
        else throw testing::TestError::Failed;
    let case super::NominalType::Record(recordType) = *listType
        else throw testing::TestError::Failed;
    let case super::Type::Optional(optionalTarget) = recordType.fields[1].fieldType
    let case super::Type::Core(super::CoreType::Optional { payload }) = recordType.fields[1].fieldType
        else throw testing::TestError::Failed;
    let case super::Type::Pointer(super::PointerType {
        class: types::PointerClass::Owned, target, ..
    }) = *optionalTarget
    let case super::Type::Core(super::CoreType::Pointer { shape: super::PointerShape::Thin, properties, target }) = *payload
        else throw testing::TestError::Failed;
    assert properties.class == types::PointerClass::Owned;
    let case super::Type::Nominal(nextType) = *target
        else throw testing::TestError::Failed;
    assert nextType == listType;
}


test/tests/relocate.rad +12 -1

//! returns: 0
//! Test overlap-safe relocation between mutable byte slices.
//! Test overlap-safe relocation between mutable typed slices.

@default fn main() -> i32 {
    let mut bytes: [u8; 6] = [1, 2, 3, 4, 5, 6];

    let rightDestination: *mut [u8] = &mut bytes[1..5];

    @relocate(emptyDestination, emptySource);

    assert bytes[0] == 1;
    assert bytes[5] == 6;

    let mut words: [i32; 5] = [10, 20, 30, 40, 50];
    let wordDestination: *mut [i32] = &mut words[1..5];
    let wordSource: *mut [i32] = &mut words[0..4];
    @relocate(wordDestination, wordSource);

    assert words[0] == 10;
    assert words[1] == 10;
    assert words[2] == 20;
    assert words[3] == 30;
    assert words[4] == 40;

    return 0;
}

267	267		/// Trait object v-table pointer offset.
268	268		constant TRAIT_OBJ_VTABLE_OFFSET: i32 = resolver::PTR_SIZE as i32;
269	269
270	270		// Tagged Value Layout (optionals, tagged unions)
271	271		//
272		-	// Optionals and unions use 1-byte tags. Results use 8-byte tags.
	272	+	// Tagged optionals and unions use 1-byte tags. Results use 8-byte tags.
273	273		//
274	274		// `{ tag: u8, [padding], payload: T }`
275	275		//
276	276		// Optionals use `tag: 0` for `nil` and `tag: 1` otherwise.
277		-	// When `T` is a pointer, the entire optional is stored as a single pointer.
	277	+	// Nullable pointer-like payloads use their null data pointer as the nil niche.
278	278		//
279	279		// Tagged unions have a payload the size of the maximum variant size.
280	280
281	281		/// Offset of tag in tagged value data structure.
282	282		constant TVAL_TAG_OFFSET: i32 = 0;

676	676
677	677		/// Classifies a match subject by how it should be compared and destructured.
678	678		union MatchSubjectKind {
679	679		/// Regular value: direct equality comparison.
680	680		Regular,
681		-	/// Optional with null pointer optimization: `?T`, `?[T]`.
	681	+	/// Optional with null pointer optimization.
682	682		OptionalPtr,
683		-	/// Optional aggregate `?T`: tagged union with payload.
	683	+	/// Tagged optional aggregate.
684	684		OptionalAggregate,
685	685		/// Union type: tag compared against variant indices.
686	686		Union(resolver::UnionType),
687	687		}
688	688
689	689		/// Determine the kind of a match subject from its type.
690	690		fn matchSubjectKind(type: resolver::Type) -> MatchSubjectKind {
691		-	if resolver::isOptionalPointer(type) {
692		-	return MatchSubjectKind::OptionalPtr;
693		-	}
694		-	if resolver::isOptionalAggregate(type) {
695		-	return MatchSubjectKind::OptionalAggregate;
	691	+	if let payload = resolver::optionalTypeArgument(type) {
	692	+	return MatchSubjectKind::OptionalPtr
	693	+	if resolver::isNullableType(*payload)
	694	+	else MatchSubjectKind::OptionalAggregate;
696	695		}
697	696		if let info = unionInfoFromType(type) {
698	697		return MatchSubjectKind::Union(info);
699	698		}
700	699		return MatchSubjectKind::Regular;

1076	1075		case resolver::Type::U64 => namePush(builder, "u64"),
1077	1076		case resolver::Type::I8 => namePush(builder, "i8"),
1078	1077		case resolver::Type::I16 => namePush(builder, "i16"),
1079	1078		case resolver::Type::I32 => namePush(builder, "i32"),
1080	1079		case resolver::Type::I64 => namePush(builder, "i64"),
1081		-	case resolver::Type::Pointer(pointer) => {
1082		-	match pointer.class {
1083		-	case types::PointerClass::Owned => namePush(builder, "*"),
1084		-	case types::PointerClass::Ref => namePush(builder, "&"),
1085		-	case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
1086		-	}
1087		-	if pointer.mutable { namePush(builder, "mut "); }
1088		-	namePushType(self, builder, *pointer.target);
1089		-	}
1090		-	case resolver::Type::Slice(slice) => {
1091		-	match slice.class {
1092		-	case types::PointerClass::Owned => namePush(builder, "*"),
1093		-	case types::PointerClass::Ref => namePush(builder, "&"),
1094		-	case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
	1080	+	case resolver::Type::Core(core) => {
	1081	+	match core {
	1082	+	case resolver::CoreType::Pointer { shape, properties, target } => {
	1083	+	match properties.class {
	1084	+	case types::PointerClass::Owned => namePush(builder, "*"),
	1085	+	case types::PointerClass::Ref => namePush(builder, "&"),
	1086	+	case types::PointerClass::Unsafe =>
	1087	+	namePush(builder, "*unsafe "),
	1088	+	}
	1089	+	if properties.mutable { namePush(builder, "mut "); }
	1090	+	match shape {
	1091	+	case resolver::PointerShape::Thin =>
	1092	+	namePushType(self, builder, *target),
	1093	+	case resolver::PointerShape::Slice => {
	1094	+	namePush(builder, "[");
	1095	+	namePushType(self, builder, *target);
	1096	+	namePush(builder, "]");
	1097	+	}
	1098	+	}
	1099	+	}
	1100	+	case resolver::CoreType::Array { item, length } => {
	1101	+	namePush(builder, "[");
	1102	+	namePushType(self, builder, *item);
	1103	+	namePush(builder, "; ");
	1104	+	namePushType(self, builder, *length);
	1105	+	namePush(builder, "]");
	1106	+	}
	1107	+	case resolver::CoreType::Optional { payload } => {
	1108	+	namePush(builder, "?");
	1109	+	namePushType(self, builder, *payload);
	1110	+	}
1095	1111		}
1096		-	if slice.mutable { namePush(builder, "mut "); }
1097		-	namePush(builder, "[");
1098		-	namePushType(self, builder, *slice.item);
1099		-	namePush(builder, "]");
1100		-	}
1101		-	case resolver::Type::Array(array) => {
1102		-	namePush(builder, "[");
1103		-	namePushType(self, builder, *array.item);
1104		-	namePush(builder, "; ");
1105		-	namePushType(self, builder, *array.length);
1106		-	namePush(builder, "]");
1107	1112		}
1108	1113		case resolver::Type::ConstArgument { value, .. } => {
1109	1114		if value.negative { namePush(builder, "-"); }
1110	1115		namePushU64(builder, value.magnitude);
1111	1116		}
1112		-	case resolver::Type::Optional(inner) => {
1113		-	namePush(builder, "?");
1114		-	namePushType(self, builder, *inner);
1115		-	}
1116	1117		case resolver::Type::Fn(info) => {
1117	1118		if info.isUnsafe { namePush(builder, "unsafe "); }
1118	1119		namePush(builder, "fn(");
1119	1120		for param, i in info.paramTypes {
1120	1121		if i > 0 { namePush(builder, ", "); }

1167	1168		case resolver::NominalType::Placeholder(_) =>
1168	1169		panic "namePushType: unresolved nominal type",
1169	1170		}
1170	1171		}
1171	1172		case resolver::Type::TraitObject(object) => {
1172		-	match object.class {
	1173	+	match object.properties.class {
1173	1174		case types::PointerClass::Owned => namePush(builder, "*"),
1174	1175		case types::PointerClass::Ref => namePush(builder, "&"),
1175		-	case types::PointerClass::Unsafe => namePush(builder, "*unsafe "),
	1176	+	case types::PointerClass::Unsafe =>
	1177	+	namePush(builder, "*unsafe "),
1176	1178		}
1177		-	if object.mutable { namePush(builder, "mut "); }
	1179	+	if object.properties.mutable { namePush(builder, "mut "); }
1178	1180		namePush(builder, "opaque ");
1179	1181		namePushTrait(self, builder, object.traitInfo);
1180	1182		}
1181	1183		else => panic "namePushType: non-concrete type",
1182	1184		}

1667	1669		}
1668	1670		throw LowerError::MissingConst(node);
1669	1671		};
1670	1672
1671	1673		if let case resolver::ConstValue::String(s) = val {
1672		-	if let case resolver::Type::Slice(_) = ty {
	1674	+	if let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, .. }) = ty {
1673	1675		let strSym = try getOrCreateStringData(self, s, dataPrefix);
1674	1676		dataSliceHeader(b, strSym, s.len);
1675	1677		return;
1676	1678		}
1677	1679		}

1742	1744		addr: ast::AddressOf,
1743	1745		ty: resolver::Type,
1744	1746		dataPrefix: *[u8],
1745	1747		b: *mut DataValueBuilder
1746	1748		) throws (LowerError) {
1747		-	let case resolver::Type::Slice(slice) = ty
	1749	+	let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, properties: slice, .. }) = ty
1748	1750		else throw LowerError::ExpectedSliceOrArray;
1749	1751		let targetTy = resolver::typeFor(self.resolver, addr.target)
1750	1752		else throw LowerError::MissingType(addr.target);
1751		-	let case resolver::Type::Array(arrInfo) = targetTy
	1753	+	let case resolver::Type::Core(resolver::CoreType::Array { length, .. }) = targetTy
1752	1754		else throw LowerError::ExpectedArray;
1753	1755
1754	1756		let mut nested = dataBuilder(self.allocator);
1755	1757		let layout = resolver::getTypeLayout(targetTy);
1756	1758		try lowerConstDataInto(self, addr.target, targetTy, layout.size, dataPrefix, &mut nested);

1765	1767		set dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
1766	1768		}
1767	1769		} else {
1768	1770		set dataName = try pushDeclData(self, layout.size, layout.alignment, readOnly, backing.values, dataPrefix);
1769	1771		}
1770		-	let length = resolver::concreteArrayLength(arrInfo.length)
	1772	+	let concreteLength = resolver::concreteArrayLength(length)
1771	1773		else throw LowerError::MissingMetadata;
1772		-	dataSliceHeader(b, dataName, length);
	1774	+	dataSliceHeader(b, dataName, concreteLength);
1773	1775		}
1774	1776
1775	1777		/// Lower a constant expression payload into a builder without slot padding.
1776	1778		fn lowerConstDataPayloadInto(
1777	1779		self: *mut Lowerer,

1880	1882		elems: mut [ast::Node],
1881	1883		ty: resolver::Type,
1882	1884		dataPrefix: *[u8],
1883	1885		b: *mut DataValueBuilder
1884	1886		) throws (LowerError) {
1885		-	let case resolver::Type::Array(arrInfo) = ty
	1887	+	let case resolver::Type::Core(resolver::CoreType::Array { item, .. }) = ty
1886	1888		else throw LowerError::ExpectedArray;
1887		-	let elemTy = *arrInfo.item;
	1889	+	let elemTy = *item;
1888	1890		let elemLayout = resolver::getTypeLayout(elemTy);
1889	1891
1890	1892		for elem in elems {
1891	1893		try lowerConstDataInto(self, elem, elemTy, elemLayout.size, dataPrefix, b);
1892	1894		}

1898	1900		repeat: ast::ArrayRepeatLit,
1899	1901		ty: resolver::Type,
1900	1902		dataPrefix: *[u8],
1901	1903		b: *mut DataValueBuilder
1902	1904		) throws (LowerError) {
1903		-	let case resolver::Type::Array(arrInfo) = ty
	1905	+	let case resolver::Type::Core(resolver::CoreType::Array { item, length }) = ty
1904	1906		else throw LowerError::ExpectedArray;
1905		-	let length = resolver::concreteArrayLength(arrInfo.length)
	1907	+	let concreteLength = resolver::concreteArrayLength(length)
1906	1908		else throw LowerError::MissingMetadata;
1907		-	let elemTy = *arrInfo.item;
	1909	+	let elemTy = *item;
1908	1910		let elemLayout = resolver::getTypeLayout(elemTy);
1909	1911
1910	1912		if let case ast::NodeValue::Undef = repeat.item.value {
1911	1913		dataBuilderPush(b, il::DataValue {
1912	1914		item: il::DataItem::Undef,
1913		-	count: elemLayout.size * length
	1915	+	count: elemLayout.size * concreteLength
1914	1916		});
1915	1917		} else if let val = resolver::constValueEntry(self.resolver, repeat.item) {
1916	1918		if let case resolver::ConstValue::String(_) = val {
1917	1919		// A string used as a slice is represented by a three-word slice
1918	1920		// header, not by the bytes of the string itself.
1919		-	for _ in 0..length {
	1921	+	for _ in 0..concreteLength {
1920	1922		try lowerConstDataInto(self, repeat.item, elemTy, elemLayout.size, dataPrefix, b);
1921	1923		}
1922	1924		} else {
1923	1925		dataBuilderPush(b, il::DataValue {
1924	1926		item: constValueToDataItem(self, val, elemTy),
1925		-	count: length
	1927	+	count: concreteLength
1926	1928		});
1927	1929		}
1928	1930		} else {
1929		-	for _ in 0..length {
	1931	+	for _ in 0..concreteLength {
1930	1932		try lowerConstDataInto(self, repeat.item, elemTy, elemLayout.size, dataPrefix, b);
1931	1933		}
1932	1934		}
1933	1935		}
1934	1936

2793	2795		}
2794	2796		let isNil = pattern.value == ast::NodeValue::Nil;
2795	2797
2796	2798		match subject.kind {
2797	2799		case MatchSubjectKind::OptionalPtr if isNil => {
2798		-	// Null pointer optimization: branch on the data pointer being null.
	2800	+	// Null pointer optimization branches on the niche data pointer.
2799	2801		let nilReg = try optionalNilReg(self, subject.val, subject.type);
2800	2802		try emitBrCmp(self, il::CmpOp::Eq, il::Type::W64, il::Val::Reg(nilReg), il::Val::Imm(0), matchBlock, fallthrough);
2801	2803		}
2802	2804		case MatchSubjectKind::OptionalAggregate => {
2803	2805		let base = emitValToReg(self, subject.val);
2804	2806
2805		-	if isNil { // Optional aggregate: `nil` means tag is zero.
	2807	+	if isNil {
2806	2808		let tagReg = tvalTagReg(self, base);
2807	2809		try emitBr(self, tagReg, fallthrough, matchBlock);
2808	2810		} else {
2809		-	// `lowerExpr` applies the resolver's optional-lift coercion,
2810		-	// materializing the tagged representation for value patterns.
	2811	+	// `lowerExpr` applies the optional-lift coercion and
	2812	+	// materializes the tagged representation for value patterns.
2811	2813		let pattVal = try lowerExpr(self, pattern);
2812	2814		let pattReg = emitValToReg(self, pattVal);
2813	2815		let eq = try lowerOptionalEq(self, subject.bindType, base, pattReg, 0);
2814	2816		let eqReg = emitValToReg(self, eq);
2815	2817

2817	2819		}
2818	2820		}
2819	2821		case MatchSubjectKind::Union(unionInfo) => {
2820	2822		assert not isNil;
2821	2823
2822		-	let case resolver::NodeExtra::UnionVariant { tag: variantTag, .. } =
2823		-	resolver::nodeData(self.low.resolver, pattern).extra
2824		-	else {
	2824	+	let case resolver::NodeExtra::UnionVariant {
	2825	+	tag: variantTag,
	2826	+	..
	2827	+	} = resolver::nodeData(self.low.resolver, pattern).extra else {
2825	2828		throw LowerError::ExpectedVariant;
2826	2829		};
2827	2830		// Void unions are passed by value (the tag itself).
2828	2831		// Non-void unions are passed by reference (need to load tag).
2829	2832		// When matching by reference, always load from the pointer.
2830	2833		if unionInfo.isAllVoid {
2831	2834		let mut tagVal = subject.val;
2832	2835		match subject.by {
2833		-	case resolver::MatchBy::Ref, resolver::MatchBy::MutRef => {
	2836	+	case resolver::MatchBy::Ref,
	2837	+	resolver::MatchBy::MutRef => {
2834	2838		let base = emitValToReg(self, subject.val);
2835	2839		set tagVal = loadTag(self, base, 0, il::Type::W8);
2836	2840		}
2837	2841		case resolver::MatchBy::Value => {}
2838	2842		}

2842	2846		let tagReg = tvalTagReg(self, base);
2843	2847
2844	2848		try emitBrCmp(self, il::CmpOp::Eq, il::Type::W8, il::Val::Reg(tagReg), il::Val::Imm(variantTag as i64), matchBlock, fallthrough);
2845	2849		}
2846	2850		}
2847		-	else => { // Value comparison.
	2851	+	else => {
2848	2852		assert not isNil;
2849	2853		let pattVal = try lowerExpr(self, pattern);
2850	2854		if isAggregateType(subject.type) {
2851	2855		// Aggregate types need structural comparison rather than
2852	2856		// scalar compare.

2878	2882		for i in 0..(patterns.len - 1) {
2879	2883		let pattern = patterns[i];
2880	2884		let nextArm = try createBlock(self, "arm");
2881	2885		try emitPatternMatch(self, subject, pattern, matchBlock, nextArm);
2882	2886
2883		-	// Seal the intermediate arm block: all predecessor edges are known
	2887	+	// Seal the intermediate arm block: all predecessor edges are known.
2884	2888		// This ensures SSA construction can resolve variable uses through
2885		-	// single-predecessor optimization instead of creating unresolved block
2886		-	// parameters.
	2889	+	// single-predecessor optimization instead of creating unresolved
	2890	+	// block parameters.
2887	2891		try switchToAndSeal(self, nextArm);
2888	2892		}
2889	2893		// Handle last pattern: go to fallthrough block on failure.
2890	2894		let last = patterns[patterns.len - 1];
2891	2895		try emitPatternMatch(self, subject, last, matchBlock, fallthrough);
2892	2896		}
2893		-
2894	2897		/// Emit a match binding pattern.
2895	2898		/// Binding patterns always match for regular values, but for optionals they
2896	2899		/// check for the presence of a value. Jumps to `valuePresent` on success,
2897	2900		/// `valueAbsent` on failure.
2898	2901		fn emitBindingTest(

3534	3537		if unwrapped.by == resolver::MatchBy::Value and isAggregateType(unwrapped.effectiveTy) {
3535	3538		set val = try emitStackVal(self, unwrapped.effectiveTy, val);
3536	3539		}
3537	3540
3538	3541		let mut bindType = unwrapped.effectiveTy;
3539		-	if let case resolver::Type::Optional(inner) = unwrapped.effectiveTy {
3540		-	set bindType = *inner;
	3542	+	if let case resolver::Type::Core(
	3543	+	resolver::CoreType::Optional { payload }
	3544	+	) = unwrapped.effectiveTy {
	3545	+	set bindType = *payload;
3541	3546		}
3542	3547		let ilType = ilType(self.low, unwrapped.effectiveTy);
3543	3548		let kind = matchSubjectKind(unwrapped.effectiveTy);
3544	3549
3545	3550		return MatchSubject { val, type: unwrapped.effectiveTy, ilType, bindType, kind, by: unwrapped.by };

3573	3578		let tagReg = nextReg(self);
3574	3579		emitLoadW64At(self, tagReg, base, TVAL_TAG_OFFSET);
3575	3580		return tagReg;
3576	3581		}
3577	3582
3578		-	/// Get the register to compare against `0` for optional `nil` checking.
3579		-	/// For null-ptr-optimized types, loads the data pointer, or returns it
3580		-	/// directly for scalar pointers. For aggregates, returns the tag register.
	3583	+	/// Return the nil discriminator: thin pointers use their value, slices use their data pointer, and tagged optionals use their tag.
3581	3584		fn optionalNilReg(self: *mut FnLowerer, val: il::Val, typ: resolver::Type) -> il::Reg throws (LowerError) {
3582	3585		let reg = emitValToReg(self, val);
3583		-
3584		-	if let case resolver::Type::Optional(inner) = typ {
3585		-	if let case resolver::Type::Slice(_) = *inner {
3586		-	let ptrReg = nextReg(self);
3587		-	emitLoadW64At(self, ptrReg, reg, SLICE_PTR_OFFSET);
3588		-	return ptrReg;
3589		-	}
3590		-	if let case resolver::Type::Pointer(_) = *inner {
3591		-	return reg;
	3586	+	if let inner = resolver::optionalTypeArgument(typ) {
	3587	+	if let case resolver::Type::Core(resolver::CoreType::Pointer { shape, .. }) = *inner {
	3588	+	match shape {
	3589	+	case resolver::PointerShape::Thin => return reg,
	3590	+	case resolver::PointerShape::Slice => {
	3591	+	let ptrReg = nextReg(self);
	3592	+	emitLoadW64At(self, ptrReg, reg, SLICE_PTR_OFFSET);
	3593	+	return ptrReg;
	3594	+	}
	3595	+	}
3592	3596		}
3593	3597		return tvalTagReg(self, reg);
3594	3598		}
3595	3599		return reg;
3596	3600		}

7833	7849		resolver::Type::U16 => return il::Type::W16,
7834	7850		case resolver::Type::I32,
7835	7851		resolver::Type::U32 => return il::Type::W32,
7836	7852		case resolver::Type::I64,
7837	7853		resolver::Type::U64,
7838		-	resolver::Type::Pointer(_),
7839		-	resolver::Type::Slice(_),
	7854	+	resolver::Type::Core(_),
7840	7855		resolver::Type::TraitObject(_),
7841		-	resolver::Type::Array(_),
7842		-	resolver::Type::Optional(_),
7843	7856		resolver::Type::Fn(_) => return il::Type::W64,
7844	7857		case resolver::Type::Nominal(_) => {
7845	7858		if resolver::isVoidUnion(typ) {
7846	7859		return il::Type::W8;
7847	7860		}

3603	3607		return il::Val::Imm(1) if isEq else il::Val::Imm(0);
3604	3608		}
3605	3609		let val = try lowerExpr(self, opt);
3606	3610		let cmpReg = try optionalNilReg(self, val, optTy);
3607	3611
3608		-	// Null-pointer-optimized types compare a 64-bit pointer against zero.
3609		-	// Aggregate optionals compare an 8-bit tag byte against zero.
3610		-	let cmpType = il::Type::W64 if resolver::isOptionalPointer(optTy) else il::Type::W8;
	3612	+	let inner = resolver::optionalTypeArgument(optTy)
	3613	+	else throw LowerError::ExpectedOptional;
	3614	+	let cmpType = il::Type::W64 if resolver::isNullableType(*inner) else il::Type::W8;
3611	3615
3612	3616		let op = il::BinOp::Eq if isEq else il::BinOp::Ne;
3613	3617		return emitTypedBinOp(self, op, cmpType, il::Val::Reg(cmpReg), il::Val::Imm(0));
3614	3618		}
3615	3619

3728	3732		/// tested against the subject element, branching to `failBlock` on mismatch.
3729	3733		fn bindArrayPatternElements(
3730	3734		self: *mut FnLowerer,
3731	3735		subject: *MatchSubject,
3732	3736		items: mut [ast::Node],
3733		-	failBlock: BlockId
	3737	+	failBlock: BlockId,
3734	3738		) throws (LowerError) {
3735		-	let case resolver::Type::Array(arrInfo) = subject.type
	3739	+	let case resolver::Type::Core(resolver::CoreType::Array { item, .. }) = subject.type
3736	3740		else throw LowerError::ExpectedSliceOrArray;
3737	3741
3738		-	let elemTy = *arrInfo.item;
	3742	+	let elemTy = *item;
3739	3743		let elemLayout = resolver::getTypeLayout(elemTy);
3740	3744		let stride = elemLayout.size as i32;
3741	3745		let base = emitValToReg(self, subject.val);
3742	3746
3743	3747		for elem, i in items {

3812	3816		}
3813	3817		// Plain nested record destructuring pattern.
3814	3818		// Auto-deref: if the field is a pointer, load it first.
3815	3819		let mut derefType = fieldInfo.fieldType;
3816	3820		let mut nestedBase = emitPtrOffset(self, base, fieldInfo.offset);
3817		-	if let case resolver::Type::Pointer(pointer) = fieldInfo.fieldType {
	3821	+	if let case resolver::Type::Core(
	3822	+	resolver::CoreType::Pointer { shape: resolver::PointerShape::Thin, target, .. }
	3823	+	) = fieldInfo.fieldType {
3818	3824		let ptrReg = nextReg(self);
3819	3825		emitLoadW64At(self, ptrReg, nestedBase, 0);
3820	3826		set nestedBase = ptrReg;
3821		-	set derefType = *pointer.target;
	3827	+	set derefType = *target;
3822	3828		}
3823	3829		let recInfo = resolver::getRecord(derefType)
3824	3830		else throw LowerError::ExpectedRecord;
3825	3831
3826	3832		try bindNestedRecordFields(self, nestedBase, lit, recInfo, matchBy, failBlock);

3848	3854
3849	3855		// Auto-deref: when the field is a pointer and the pattern destructures
3850	3856		// the pointed-to value, load the pointer and use the target type.
3851	3857		// The loaded pointer becomes the base address for the nested subject.
3852	3858		let mut derefBase: ?il::Reg = nil;
3853		-	if let case resolver::Type::Pointer(pointer) = fieldType {
	3859	+	if let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Thin, target, .. }) = fieldType {
3854	3860		if resolver::isDestructuringPattern(pattern) {
3855	3861		let ptrReg = nextReg(self);
3856	3862		emitLoadW64At(self, ptrReg, fieldPtr, 0);
3857	3863		set derefBase = ptrReg;
3858		-	set fieldType = *pointer.target;
	3864	+	set fieldType = *target;
3859	3865		}
3860	3866		}
3861	3867		// Build a MatchSubject for the nested field.
3862	3868		let ilTy = ilType(self.low, fieldType);
3863	3869		let kind = matchSubjectKind(fieldType);

4463	4469		return ty;
4464	4470		}
4465	4471
4466	4472		/// Check if a resolver type lowers to an aggregate in memory.
4467	4473		fn isAggregateType(typ: resolver::Type) -> bool {
4468		-	match typ {
4469		-	case resolver::Type::Optional(resolver::Type::Pointer(_)) => {
4470		-	// Optional pointers are scalar due to NPO.
	4474	+	if let payload = resolver::optionalTypeArgument(typ) {
	4475	+	if let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Thin, .. }) = *payload {
	4476	+	// Optional thin pointers are scalar due to NPO.
4471	4477		return false;
4472	4478		}
4473		-	case resolver::Type::Optional(_) => {
4474		-	// All other optionals, including optional slices, are aggregates.
4475		-	return true;
4476		-	}
4477		-	case resolver::Type::Nominal(_) => {
	4479	+	// All other optionals, including optional slices, are aggregates.
	4480	+	return true;
	4481	+	}
	4482	+	match typ {
	4483	+	case resolver::Type::Nominal(_) =>
4478	4484		// Void unions are small enough to pass by value.
4479		-	return not resolver::isVoidUnion(typ);
4480		-	}
4481		-	case resolver::Type::Slice(_),
4482		-	resolver::Type::TraitObject(_),
4483		-	resolver::Type::Array(_),
4484		-	resolver::Type::Nil => return true,
	4485	+	return not resolver::isVoidUnion(typ),
	4486	+	case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, .. }) => return true,
	4487	+	case resolver::Type::TraitObject(_) => return true,
	4488	+	case resolver::Type::Nil => return true,
	4489	+	case resolver::Type::Core(resolver::CoreType::Array { .. }) => return true,
4485	4490		else => return false,
4486	4491		}
4487	4492		}
4488	4493
4489	4494		/// Check if a resolver type is a small aggregate that can be

4607	4612		}
4608	4613		}
4609	4614		return il::Val::Reg(dst);
4610	4615		}
4611	4616
4612		-	/// Wrap a value in an optional type.
4613		-	///
4614		-	/// For optional pointers (`?*T`), the value is returned as-is since pointers
4615		-	/// use zero to represent `nil`. For other optionals, builds a tagged aggregate.
4616		-	/// with the tag set to `1`, and the value as payload.
	4617	+	/// Wrap an optional payload: nullable pointers keep their representation, while other payloads use a present tag and stored value.
4617	4618		fn wrapInOptional(self: *mut FnLowerer, val: il::Val, optType: resolver::Type) -> il::Val throws (LowerError) {
4618		-	let case resolver::Type::Optional(inner) = optType else {
4619		-	throw LowerError::ExpectedOptional;
4620		-	};
4621		-	// Null-pointer-optimized (NPO) types are used as-is -- valid values are never null.
	4619	+	let inner = resolver::optionalTypeArgument(optType)
	4620	+	else throw LowerError::ExpectedOptional;
4622	4621		if resolver::isNullableType(*inner) {
4623	4622		return val;
4624	4623		}
4625		-	let layout = resolver::getTypeLayout(optType);
4626		-	let valOffset = resolver::getOptionalValOffset(*inner) as i32;
4627		-
4628		-	return try buildTagged(self, layout, 1, val, *inner, 1, valOffset);
	4624	+	return try buildTagged(self, resolver::getTypeLayout(optType), 1, val, inner, 1, resolver::getOptionalValOffset(inner) as i32);
4629	4625		}
4630	4626
4631		-	/// Build a `nil` value for an optional type.
4632		-	///
4633		-	/// For optional pointers (`?*T`), returns an immediate `0` (null pointer).
4634		-	/// For other optionals, builds a tagged aggregate with tag set to `0` (absent).
	4627	+	/// Build nil: thin pointers use zero, slices use a zero data pointer and length, and tagged optionals use an absent tag.
4635	4628		fn buildNilOptional(self: *mut FnLowerer, optType: resolver::Type) -> il::Val throws (LowerError) {
4636		-	let case resolver::Type::Optional(inner) = optType
	4629	+	let inner = resolver::optionalTypeArgument(optType)
4637	4630		else throw LowerError::ExpectedOptional;
4638		-	if let case resolver::Type::Pointer(_) = *inner {
4639		-	return il::Val::Imm(0);
4640		-	}
4641		-	if let case resolver::Type::Slice(slice) = *inner {
4642		-	return try buildSliceValue(
4643		-	self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0)
4644		-	);
	4631	+	if let case resolver::Type::Core(resolver::CoreType::Pointer { shape, properties, target }) = *inner {
	4632	+	match shape {
	4633	+	case resolver::PointerShape::Thin => return il::Val::Imm(0),
	4634	+	case resolver::PointerShape::Slice =>
	4635	+	return try buildSliceValue(self, target, properties.mutable, il::Val::Imm(0), il::Val::Imm(0)),
	4636	+	}
4645	4637		}
4646		-	let valOffset = resolver::getOptionalValOffset(*inner) as i32;
4647		-	return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);
	4638	+	return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, inner, 1, resolver::getOptionalValOffset(inner) as i32);
4648	4639		}
4649	4640
4650	4641		/// Build a result value for throwing functions.
4651	4642		fn buildResult(
4652	4643		self: *mut FnLowerer,

4667	4658		elemTy: *resolver::Type,
4668	4659		mutable: bool,
4669	4660		ptrVal: il::Val,
4670	4661		lenVal: il::Val
4671	4662		) -> il::Val throws (LowerError) {
4672		-	let sliceType = resolver::Type::Slice(resolver::SliceType {
4673		-	class: types::PointerClass::Unsafe,
4674		-	item: elemTy,
	4663	+	let sliceType = resolver::sliceType(
	4664	+	types::PointerClass::Unsafe,
	4665	+	elemTy,
4675	4666		mutable,
4676		-	});
	4667	+	);
4677	4668		let dst = try emitReserve(self, sliceType);
4678		-	let ptrTy = resolver::Type::Pointer(resolver::PointerType {
4679		-	class: types::PointerClass::Unsafe,
4680		-	target: elemTy,
	4669	+	let ptrTy = resolver::pointerType(
	4670	+	types::PointerClass::Unsafe,
	4671	+	elemTy,
4681	4672		mutable,
4682		-	});
	4673	+	);
4683	4674
4684	4675		try emitStore(self, dst, SLICE_PTR_OFFSET, ptrTy, ptrVal);
4685	4676		try emitStore(self, dst, SLICE_LEN_OFFSET, resolver::Type::U32, lenVal);
4686	4677
4687	4678		return il::Val::Reg(dst);

4866	4857		mutable: bool,
4867	4858		a: il::Reg,
4868	4859		b: il::Reg,
4869	4860		offset: i32
4870	4861		) -> il::Val throws (LowerError) {
4871		-	let ptrTy = resolver::Type::Pointer(resolver::PointerType {
4872		-	class: types::PointerClass::Unsafe,
4873		-	target: elemTy,
	4862	+	let ptrTy = resolver::pointerType(
	4863	+	types::PointerClass::Unsafe,
	4864	+	elemTy,
4874	4865		mutable,
4875		-	});
	4866	+	);
4876	4867		let ptrEq = try emitEqAtOffset(self, a, b, offset + SLICE_PTR_OFFSET, ptrTy);
4877	4868		let lenEq = try emitEqAtOffset(self, a, b, offset + SLICE_LEN_OFFSET, resolver::Type::U32);
4878	4869
4879	4870		return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, ptrEq, lenEq);
4880	4871		}

4905	4896
4906	4897		// For simple inner types (no unions/nested optionals), use branchless comparison.
4907	4898		// Unions and nested optionals may contain uninitialized payload bytes
4908	4899		// when nil, so they need a guarded comparison.
4909	4900		let isUnion = unionInfoFromType(inner) <> nil;
4910		-	let mut isOptional = false;
4911		-	if let case resolver::Type::Optional(_) = inner {
4912		-	set isOptional = true;
4913		-	}
4914		-	if not isUnion and not isOptional {
	4901	+	if not isUnion and not resolver::isOptionalType(inner) {
4915	4902		let tagEq = emitTypedBinOp(self, il::BinOp::Eq, il::Type::W8, tagA, tagB);
4916	4903		let tagNil = emitTypedBinOp(self, il::BinOp::Eq, il::Type::W8, tagA, il::Val::Imm(0));
4917	4904		let payloadEq = try emitEqAtOffset(self, a, b, offset + valOffset, inner);
4918	4905
4919	4906		return emitTypedBinOp(self, il::BinOp::And, il::Type::W32, tagEq,

5089	5076		}
5090	5077
5091	5078		/// Compare two array values for equality, element by element.
5092	5079		fn lowerArrayEq(
5093	5080		self: *mut FnLowerer,
5094		-	arr: resolver::ArrayType,
	5081	+	item: *resolver::Type,
	5082	+	lengthArgument: *resolver::Type,
5095	5083		a: il::Reg,
5096	5084		b: il::Reg,
5097	5085		offset: i32
5098	5086		) -> il::Val throws (LowerError) {
5099		-	let elemLayout = resolver::getTypeLayout(*arr.item);
	5087	+	let elemLayout = resolver::getTypeLayout(*item);
5100	5088		let stride = elemLayout.size as i32;
5101	5089		let mut result: ?il::Val = nil;
5102		-	let length = resolver::concreteArrayLength(arr.length)
	5090	+	let length = resolver::concreteArrayLength(lengthArgument)
5103	5091		else throw LowerError::MissingMetadata;
5104	5092
5105	5093		for i in 0..length {
5106	5094		let elemOffset = offset + (i as i32) * stride;
5107		-	let cmp = try emitEqAtOffset(self, a, b, elemOffset, *arr.item);
	5095	+	let cmp = try emitEqAtOffset(self, a, b, elemOffset, *item);
5108	5096		set result = emitLogicalAnd(self, result, cmp);
5109	5097		}
5110	5098		if let r = result {
5111	5099		return r;
5112	5100		}

5120	5108		typ: resolver::Type,
5121	5109		a: il::Reg,
5122	5110		b: il::Reg,
5123	5111		offset: i32
5124	5112		) -> il::Val throws (LowerError) {
	5113	+	let mut effective = typ;
	5114	+	if let payload = resolver::optionalTypeArgument(typ) {
	5115	+	set effective = *payload;
	5116	+	}
	5117	+	if let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, properties, target }) = effective {
	5118	+	return try lowerSliceEq(
	5119	+	self, target, properties.mutable, a, b, offset
	5120	+	);
	5121	+	}
5125	5122		match typ {
5126		-	case resolver::Type::Slice(slice) =>
5127		-	return try lowerSliceEq(self, slice.item, slice.mutable, a, b, offset),
5128		-	case resolver::Type::Optional(inner) => {
5129		-	if let case resolver::Type::Slice(slice) = *inner {
5130		-	// Optional slices use null pointer optimization.
5131		-	return try lowerSliceEq(self, slice.item, slice.mutable, a, b, offset);
5132		-	}
5133		-	return try lowerOptionalEq(self, *inner, a, b, offset);
5134		-	}
5135		-	case resolver::Type::Array(arr) =>
5136		-	return try lowerArrayEq(self, arr, a, b, offset),
	5123	+	case resolver::Type::Core(
	5124	+	resolver::CoreType::Optional { payload }
	5125	+	) => return try lowerOptionalEq(self, *payload, a, b, offset),
	5126	+	case resolver::Type::Core(resolver::CoreType::Array { item, length }) =>
	5127	+	return try lowerArrayEq(self, item, length, a, b, offset),
5137	5128		case resolver::Type::Nominal(resolver::NominalType::Record(recInfo)) =>
5138	5129		return try lowerRecordEq(self, recInfo, a, b, offset),
5139	5130		case resolver::Type::Nominal(resolver::NominalType::Union(unionInfo)) =>
5140	5131		return try lowerUnionEq(self, unionInfo, a, b, offset),
5141	5132		else => {

5237	5228		/// Lower an array literal expression like `[1, 2, 3]`.
5238	5229		fn lowerArrayLit(self: mut FnLowerer, node: ast::Node, elements: mut [ast::Node]) -> il::Val
5239	5230		throws (LowerError)
5240	5231		{
5241	5232		let typ = try typeOf(self, node);
5242		-	let case resolver::Type::Array(arrInfo) = typ else {
5243		-	throw LowerError::ExpectedArray;
5244		-	};
5245		-	let elemTy = *arrInfo.item;
	5233	+	let case resolver::Type::Core(resolver::CoreType::Array { item, .. }) = typ
	5234	+	else throw LowerError::ExpectedArray;
	5235	+	let elemTy = *item;
5246	5236		let elemLayout = resolver::getTypeLayout(elemTy);
5247	5237		let dst = try emitReserve(self, typ);
5248	5238
5249	5239		for elemNode, i in elements {
5250	5240		let elemVal = try lowerExpr(self, elemNode);

5260	5250		// TODO: Beyond a certain length, lower this to a loop.
5261	5251		fn lowerArrayRepeatLit(self: mut FnLowerer, node: ast::Node, repeat: ast::ArrayRepeatLit) -> il::Val
5262	5252		throws (LowerError)
5263	5253		{
5264	5254		let typ = try typeOf(self, node);
5265		-	let case resolver::Type::Array(arrInfo) = typ else {
5266		-	throw LowerError::ExpectedArray;
5267		-	};
5268		-	let elemTy = *arrInfo.item;
5269		-	let length = resolver::concreteArrayLength(arrInfo.length)
	5255	+	let case resolver::Type::Core(resolver::CoreType::Array { item, length: lengthArgument }) = typ
	5256	+	else throw LowerError::ExpectedArray;
	5257	+	let elemTy = *item;
	5258	+	let length = resolver::concreteArrayLength(lengthArgument)
5270	5259		else throw LowerError::MissingMetadata;
5271	5260		let elemLayout = resolver::getTypeLayout(elemTy);
5272	5261		let dst = try emitReserve(self, typ);
5273	5262
5274	5263		// Evaluate the repeated item once.

5492	5481		self: *mut FnLowerer,
5493	5482		sliceNode: *ast::Node,
5494	5483		arrayNode: *ast::Node
5495	5484		) -> il::Val throws (LowerError) {
5496	5485		let sliceTy = try typeOf(self, sliceNode);
5497		-	let case resolver::Type::Slice(slice) = sliceTy else {
5498		-	throw LowerError::UnexpectedType(&sliceTy);
5499		-	};
	5486	+	let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, properties: slice, target: item }) = sliceTy
	5487	+	else throw LowerError::UnexpectedType(&sliceTy);
5500	5488		let arrayTy = try typeOf(self, arrayNode);
5501		-	let case resolver::Type::Array(arrayInfo) = arrayTy else {
5502		-	throw LowerError::ExpectedArray;
5503		-	};
5504		-	let length = resolver::concreteArrayLength(arrayInfo.length)
	5489	+	let case resolver::Type::Core(resolver::CoreType::Array { length: lengthArgument, .. }) = arrayTy
	5490	+	else throw LowerError::ExpectedArray;
	5491	+	let length = resolver::concreteArrayLength(lengthArgument)
5505	5492		else throw LowerError::MissingMetadata;
5506	5493		if length == 0 {
5507	5494		return try buildSliceValue(
5508		-	self, slice.item, slice.mutable, il::Val::Imm(0), il::Val::Imm(0)
	5495	+	self,
	5496	+	item,
	5497	+	slice.mutable,
	5498	+	il::Val::Imm(0),
	5499	+	il::Val::Imm(0),
5509	5500		);
5510	5501		}
5511	5502		if resolver::isConstExpr(self.low.resolver, arrayNode) {
5512	5503		let mut b = dataBuilder(self.low.allocator);
5513	5504		match arrayNode.value {

5516	5507		case ast::NodeValue::ArrayRepeatLit(repeat) =>
5517	5508		try lowerConstArrayRepeatInto(self.low, repeat, arrayTy, self.fnName, &mut b),
5518	5509		else => throw LowerError::UnexpectedNodeValue(arrayNode),
5519	5510		}
5520	5511		let result = dataBuilderFinish(&b);
5521		-	let alignment = resolver::getTypeLayout(*slice.item).alignment;
	5512	+	let alignment = resolver::getTypeLayout(*item).alignment;
5522	5513		return try lowerConstDataAsSlice(
5523		-	self, result.values, alignment, not slice.mutable,
5524		-	slice.item, slice.mutable, length
	5514	+	self,
	5515	+	result.values,
	5516	+	alignment,
	5517	+	not slice.mutable,
	5518	+	item,
	5519	+	slice.mutable,
	5520	+	length,
5525	5521		);
5526	5522		}
5527	5523		let data = try lowerExpr(self, arrayNode);
5528	5524		let count = il::Val::Imm(length as i64);
5529		-	return try buildSliceValue(self, slice.item, slice.mutable, data, count);
	5525	+	return try buildSliceValue(self, item, slice.mutable, data, count);
5530	5526		}
5531	5527
5532	5528		/// Lower the common element pointer computation for subscript operations.
5533	5529		/// Handles both arrays and slices by resolving the container type, extracting
5534	5530		/// the data pointer (for slices), and emitting an [`il::Instr::Elem`] to compute

5544	5540
5545	5541		let mut dataReg = baseReg;
5546	5542		let mut elemType: resolver::Type = undefined;
5547	5543
5548	5544		match subjectTy {
5549		-	case resolver::Type::Slice(slice) => {
5550		-	set elemType = *slice.item;
	5545	+	case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, target, .. }) => {
	5546	+	set elemType = *target;
5551	5547		let sliceLen = loadSliceLen(self, baseReg);
5552	5548		// Runtime safety check: index must be strictly less than slice length.
5553		-	try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, sliceLen);
	5549	+	try emitTrapUnlessCmp(
	5550	+	self, il::CmpOp::Ult, il::Type::W32, indexVal, sliceLen
	5551	+	);
5554	5552
5555	5553		set dataReg = loadSlicePtr(self, baseReg);
5556	5554		}
5557		-	case resolver::Type::Array(arrInfo) => {
5558		-	set elemType = *arrInfo.item;
	5555	+	case resolver::Type::Core(resolver::CoreType::Array { item, length: lengthArgument }) => {
	5556	+	set elemType = *item;
5559	5557		// Runtime safety check: index must be strictly less than array length.
5560	5558		// Skip when the index is a compile-time constant, since we check
5561	5559		// that in the resolver.
5562	5560		if not resolver::isConstExpr(self.low.resolver, index) {
5563		-	let length = resolver::concreteArrayLength(arrInfo.length)
	5561	+	let length = resolver::concreteArrayLength(lengthArgument)
5564	5562		else throw LowerError::MissingMetadata;
5565	5563		let arrLen = il::Val::Imm(length as i64);
5566		-	try emitTrapUnlessCmp(self, il::CmpOp::Ult, il::Type::W32, indexVal, arrLen);
	5564	+	try emitTrapUnlessCmp(
	5565	+	self, il::CmpOp::Ult, il::Type::W32, indexVal, arrLen
	5566	+	);
5567	5567		}
5568	5568		}
5569	5569		else => throw LowerError::ExpectedSliceOrArray,
5570	5570		}
5571	5571		let elemLayout = resolver::getTypeLayout(elemType);

5837	5837		let r = try resolveSliceRangePtr(self, container, range, info);
5838	5838		let itemType = try specializeType(self, *info.itemType);
5839	5839		let elemSize = resolver::getTypeLayout(itemType).size;
5840	5840		let rhsTy = try typeOf(self, rhs);
5841	5841
5842		-	if let case resolver::Type::Slice(_) = rhsTy {
	5842	+	if let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, .. }) = rhsTy {
5843	5843		// Copy from source slice.
5844	5844		let srcReg = emitValToReg(self, try lowerExpr(self, rhs));
5845	5845		let srcData = loadSlicePtr(self, srcReg);
5846	5846		let srcLen = loadSliceLen(self, srcReg);
5847	5847

6595	6595		/// String literals are stored as global data and the result is a slice
6596	6596		/// pointing to the data with the appropriate length.
6597	6597		fn lowerStringLit(self: mut FnLowerer, node: ast::Node, s: *[u8]) -> il::Val throws (LowerError) {
6598	6598		// Get the slice type from the node.
6599	6599		let sliceTy = try typeOf(self, node);
6600		-	let case resolver::Type::Slice(slice) = sliceTy
	6600	+	let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, properties: slice, target: item }) = sliceTy
6601	6601		else throw LowerError::ExpectedSliceOrArray;
6602	6602		// Build the string data value.
6603	6603		let ptr = try! alloc::alloc(
6604	6604		self.low.arena, @sizeOf(il::DataValue), @alignOf(il::DataValue)
6605	6605		) as *mut il::DataValue;
6606	6606
6607	6607		set *ptr = il::DataValue { item: il::DataItem::Str(s), count: 1 };
6608	6608
6609	6609		return try lowerConstDataAsSlice(
6610		-	self, @sliceOf(ptr, 1), 1, true, slice.item, slice.mutable, s.len
	6610	+	self,
	6611	+	@sliceOf(ptr, 1),
	6612	+	1,
	6613	+	true,
	6614	+	item,
	6615	+	slice.mutable,
	6616	+	s.len,
6611	6617		);
6612	6618		}
6613	6619
6614	6620		/// Lower a builtin call expression.
6615	6621		fn lowerBuiltinCall(self: mut FnLowerer, node: ast::Node, kind: ast::Builtin, args: mut [ast::Node]) -> il::Val throws (LowerError) {

6638	6644		fn lowerSliceOf(self: mut FnLowerer, node: ast::Node, args: mut [ast::Node]) -> il::Val throws (LowerError) {
6639	6645		if args.len <> 2 {
6640	6646		throw LowerError::InvalidArgCount;
6641	6647		}
6642	6648		let sliceTy = try typeOf(self, node);
6643		-	let case resolver::Type::Slice(slice) = sliceTy
	6649	+	let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, properties: slice, target: item }) = sliceTy
6644	6650		else throw LowerError::ExpectedSliceOrArray;
6645	6651		let ptrVal = try lowerExpr(self, args[0]);
6646	6652		let lenVal = try lowerExpr(self, args[1]);
6647		-	return try buildSliceValue(self, slice.item, slice.mutable, ptrVal, lenVal);
	6653	+	return try buildSliceValue(
	6654	+	self, item, slice.mutable, ptrVal, lenVal
	6655	+	);
6648	6656		}
6649	6657
6650		-	/// Lower `@relocate(destination, source)` as an overlap-safe byte move.
	6658	+	/// Lower `@relocate(destination, source)` as an overlap-safe typed move.
6651	6659		fn lowerRelocate(
6652	6660		self: *mut FnLowerer,
6653	6661		args: mut [ast::Node],
6654	6662		) -> il::Val throws (LowerError) {
6655	6663		if args.len <> 2 {
6656	6664		throw LowerError::InvalidArgCount;
6657	6665		}
	6666	+	let destinationType = try typeOf(self, args[0]);
	6667	+	let case resolver::Type::Core(resolver::CoreType::Pointer { shape: resolver::PointerShape::Slice, target: item, .. }) = destinationType
	6668	+	else throw LowerError::ExpectedSliceOrArray;
6658	6669
6659	6670		let destinationSlice = emitValToReg(self, try lowerExpr(self, args[0]));
6660	6671		let destination = loadSlicePtr(self, destinationSlice);
6661	6672		let destinationLen = loadSliceLen(self, destinationSlice);
6662	6673		let sourceSlice = emitValToReg(self, try lowerExpr(self, args[1]));
6663	6674		let source = loadSlicePtr(self, sourceSlice);
6664	6675		let sourceLen = loadSliceLen(self, sourceSlice);
6665	6676
6666		-	// The destination must hold every source byte.
	6677	+	// The destination must hold every source element.
6667	6678		try emitTrapIfLt(self, il::Type::W32, destinationLen, sourceLen);
	6679	+	let itemSize = resolver::getTypeLayout(*item).size;
	6680	+	let mut byteLen = sourceLen;
	6681	+	if itemSize <> 1 {
	6682	+	set byteLen = emitTypedBinOp(self, il::BinOp::Mul, il::Type::W32, sourceLen, il::Val::Imm(itemSize as i64));
	6683	+	}
6668	6684
6669	6685		let forwardBlock = try createBlock(self, "relocate.forward");
6670	6686		let backwardBlock = try createBlock(self, "relocate.backward");
6671	6687		let doneBlock = try createBlock(self, "relocate.done");
6672	6688		try emitBrCmp(

6683	6699		try switchToAndSeal(self, forwardBlock);
6684	6700		try emitByteCopyLoop(
6685	6701		self,
6686	6702		destination,
6687	6703		source,
6688		-	sourceLen,
	6704	+	byteLen,
6689	6705		"relocate.forward",
6690	6706		);
6691	6707		try emitJmp(self, doneBlock);
6692	6708
6693	6709		// Moving toward a higher address must copy from the end for overlap safety.