if resolver::typesEqual(target, ty) {

                    if resolver::isNullableType(*inner) {

                        try lowerConstDataPayloadInto(self, node, *inner, dataPrefix, b);

                    } else {

                        let layout = resolver::getTypeLayout(ty);

                        dataBuilderPush(b, il::DataValue {

                            item: il::DataItem::Val { typ: il::Type::W8, val: 1 }, count: 1,

                        });

                        if offset > 1 {

                            dataBuilderPush(b, il::DataValue { item: il::DataItem::Undef, count: offset - 1 });

        return nil;

    };

    // For optional aggregates, extract the payload from the tagged value.

    // The tag check already passed, so we know the payload is valid.

    if let case MatchSubjectKind::OptionalAggregate = subject.kind {

        return try bindPayloadVariable(self, name, subject.val, subject.bindType, subject.by, valOffset, mutable);

    }

    // Declare the variable in the current block's scope.

    return newVar(self, name, ilType(self.low, subject.bindType), mutable, subject.val);

}

    // Null-pointer-optimized (NPO) types are used as-is -- valid values are never null.

    if resolver::isNullableType(*inner) {

        return val;

    }

    let layout = resolver::getTypeLayout(optType);

    return try buildTagged(self, layout, 1, val, *inner, 1, valOffset);

}

/// Build a `nil` value for an optional type.

    if let case resolver::Type::Slice { item, mutable, .. } = *inner {

        return try buildSliceValue(

            self, item, mutable, il::Val::Imm(0), il::Val::Imm(0), il::Val::Imm(0)

        );

    }

    return try buildTagged(self, resolver::getTypeLayout(optType), 0, nil, *inner, 1, valOffset);

}

/// Build a result value for throwing functions.

unsafe fn buildResult 'arena 'phase 'function (

    inner: resolver::Type,

    a: il::Reg,

    b: il::Reg,

    offset: i32

) -> il::Val throws (LowerError) where 'arena: 'phase, 'phase: 'function {

    // Load tags.

    let tagA = loadTag(self, a, offset + TVAL_TAG_OFFSET, il::Type::W8);

    let tagB = loadTag(self, b, offset + TVAL_TAG_OFFSET, il::Type::W8);

    // Nullable types use null pointer optimization -- no tag byte needed.

    if isNullableType(inner) {

        return getTypeLayout(inner);

    }

    let innerLayout = getTypeLayout(inner);

    let alignment = max(innerLayout.alignment, 1);

    return Layout {

        size: mem::alignUp(valOffset + innerLayout.size, alignment),

        alignment,

    };

}

/// Get the payload offset within an optional aggregate.

}

/// Check if a type is optional.

export fn isOptionalType(ty: Type) -> bool {

    match ty {

use std::testing;

use std::lang::types;

use std::lang::resolver;

use std::lang::ast;

/// Each declaration has a distinct identity within its resolver.

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

    let mut arena = super::testArena();

    let storage: 'test = &mut arena in {

        let mut res = super::testResolver(storage);