/// Return the number of appended data entries, not bytes or array elements.

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

) -> u32 throws (LowerError) {

    let start = b.values.len;

    // 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; resolver::typesEqual(target, ty) {

                let layout = resolver::getTypeLayout(ty);

                let mut offset: u32 = 0;

                if resolver::isOptionalAggregate(ty) {

                    set 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 b.values.len - start;

            }

        }

    }

        return b.values.len - start;

                return b.values.len - start;

        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,

            });

        },

    return b.values.len - start;

/// Repeat element payloads without extra slot padding. Undefined payloads

/// already carry their element size in bytes.

    if length == 0 {

        return;

    }

    let elementStart = b.values.len;

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

    if entryCount == 1 {

        set b.values[elementStart].count *= length;

        // A string used as a slice is represented by a slice header, not by

        // the bytes of the string itself. Repeat complete payloads in order.

        for _ in 1..length {

            for i in 0..entryCount {

                let value = b.values[elementStart + i];

                dataBuilderPush(b, value);

            }

/// Build a present or absent optional value.

/// Optional pointers and slices use present values as-is, since valid values

/// have non-null data pointers. Absent values use a null pointer or zero slice.

/// Other optionals use a tagged aggregate with tag `1` and a payload when

/// present, or tag `0` with no payload when absent.

unsafe fn buildOptional(self: &mut FnLowerer, val: ?il::Val, optType: resolver::Type) -> il::Val throws (LowerError) {

    if resolver::isOptionalPointer(optType) {

        if let val = val {

            return val;

        }

        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 il::Val::Imm(0);

    return try buildTagged(self, layout, 1 if val <> nil else 0, val, *inner, 1, valOffset);

                set rhs = try buildOptional(self, rhs, leftTy);

            let lhs = try buildOptional(self, a, rightTy);

            set okVal = try buildOptional(self, payloadVal, tryExprTy);

            let errVal = try buildOptional(self, nil, tryExprTy);

                return try buildOptional(self, nil, optType);

            return try buildOptional(self, val, optType);

                set val = try buildOptional(self, nil, typ);

//! returns: 0

/// Aggregate whose fields need initialized storage.

record Pair: Copy {

    /// First summand.

    first: u32,

    /// Second summand.

    second: u64,

}

/// Check initialized values and storage layouts.

@default unsafe fn main() -> u32 {

    let mut pair: Pair = undefined;

    set pair.first = 40;

    set pair.second = 0x1122334455667788;

    let numbers: [u32; 2] = [40, 2];

    assert pair.first == numbers[0];

    assert pair.second == 0x1122334455667788;

    let wrapped: ?Pair = pair;

    let value = wrapped else panic;

    assert value.first == 40;

    assert value.second == 0x1122334455667788;

    let scalar: u32 = 42;

    let mut optional: ?u32 = scalar;

    assert readOptional(&optional) == 42;

    set optional = nil;

    assert optional == nil;

    return 0;

}

/// Read a coerced optional through its stored representation.

fn readOptional(value: &?u32) -> u32 {

    let present = *value else return 0;

    return present;

}

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

    for byte, i in "answer" {

        assert text[i] == byte;

    }

    return 0;

}