/// Compute the type layout when nil or undefined data needs a byte count.

    // Optional coercions define the tag and payload layout of constant values.

    if let case resolver::Type::Optional(inner) = ty {

        if let coercion = resolver::coercionFor(self.resolver, node) {

            if let case resolver::Coercion::OptionalLift(target) = coercion {

                if resolver::typesEqual(target, ty) {

                    if resolver::isNullableType(*inner) {

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

                    } else {

                        let layout = resolver::getTypeLayout(ty);

                        let offset = resolver::getOptionalValOffset(*inner);

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

                        }

                        try lowerConstDataInto(self, node, *inner, layout.size - offset, dataPrefix, b);

                    }

                    return;

                }

            }

        }

    }

        case ast::NodeValue::Nil => {

            let case resolver::Type::Optional(_) = ty else throw LowerError::NilInNonOptional;

            let layout = resolver::getTypeLayout(ty);

            dataBuilderPush(b, il::DataValue {

                item: il::DataItem::Val { typ: il::Type::W8, val: 0 }, count: layout.size,

            });

        },

    if let case resolver::Type::Optional(_) = elemTy {

        for _ in 0..length {

            try lowerConstDataPayloadInto(self, repeat.item, elemTy, dataPrefix, b);

        }

        return;

    }

//! returns: 0

/// Payload with alignment padding inside a tagged optional.

record Payload: Copy {

    /// Small prefix.

    prefix: u8,

    /// Aligned value.

    value: u64,

}

/// Initialized nullable pointer table.

unsafe static POINTERS: [?*u32; 3] = [nil; 3];

/// Initialized nullable slice.

unsafe static SLICE: ?*[u8] = nil;

/// Initialized tagged record optionals.

unsafe static RECORDS: [?Payload; 2] = [nil, nil];

/// Initialized nested optional.

unsafe static NESTED: ??u32 = nil;

/// Check initialized values and storage layouts.

@default unsafe fn main() -> u32 {

    for pointer in &POINTERS[..] {

        assert pointer == nil;

    }

    assert SLICE == nil;

    assert RECORDS[0] == nil;

    assert RECORDS[1] == nil;

    assert NESTED == nil;

    set RECORDS[1] = Payload { prefix: 2, value: 40 };

    let result = RECORDS[1] else panic;

    assert result.prefix as u32 + result.value as u32 == 42;

    return 0;

}

//! returns: 0

/// Aligned record payload in a present optional.

record Payload: Copy {

    /// Small prefix before the aligned value.

    prefix: u8,

    /// Value used to check payload alignment.

    number: u64,

}

/// Tagged payload with both empty and initialized variants.

union Value: Copy { Empty, Number(i64), Pair { left: u8, right: u64 } }

/// Optional payload in a tagged instruction.

union Instruction: Copy { Return { value: ?Value } }

/// Optional constant reused as a nested optional payload.

constant PRESENT: ?u32 = 42;

/// Absent inner payload used in a present outer optional.

constant ABSENT: ?u32 = nil;

/// Present aligned record initializer.

unsafe static RECORD: ?Payload = Payload { prefix: 2, number: 40 };

/// Present outer optional that contains a present value.

unsafe static NESTED: ??u32 = PRESENT;

/// Present outer optional that contains an absent value.

unsafe static NESTED_NIL: ??u32 = ABSENT;

/// Repeated present optional values.

unsafe static REPEATED: [?u32; 2] = [PRESENT; 2];

/// Present nullable slice initializer.

unsafe static TEXT: ?*[u8] = "answer";

/// Check initialized values and storage layouts.

@default unsafe fn main() -> u32 {

    let instructions = &[

        Instruction::Return { value: Value::Number(42) },

        Instruction::Return { value: Value::Pair { left: 2, right: 40 } },

        Instruction::Return { value: Value::Empty }

    ];

    let case Instruction::Return { value } = instructions[0] else panic;

    let present = value else panic;

    let case Value::Number(number) = present else panic;

    assert number == 42;

    let case Instruction::Return { value: second } = instructions[1] else panic;

    let pair = second else panic;

    let case Value::Pair { left, right } = pair else panic;

    assert left as u64 + right == 42;

    let case Instruction::Return { value: third } = instructions[2] else panic;

    let empty = third else panic;

    let case Value::Empty = empty else panic;

    let rec = RECORD else panic;

    assert rec.prefix as u64 + rec.number == 42;

    let inner = NESTED else panic;

    let answer = inner else panic;

    assert answer == 42;

    let missing = NESTED_NIL else panic;

    assert missing == nil;

    for item in &REPEATED[..] {

        let value = item else panic;

        assert value == 42;

    }

    let text = TEXT else panic;

    assert text.len == 6;

    assert number == 42;

    return 0;

}