match ty {

        case Type::Array(arr) => return getArrayLayout(getTypeLayout(*arr.item), arr.length),

        case Type::Optional(inner) => {

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

            if isNullableType(*inner) {

                return getTypeLayout(*inner);

            }

            return getOptionalAggregateLayout(getTypeLayout(*inner));

        }

        case Type::Nominal(info) => return getNominalLayout(*info),

        else => return fixedTypeLayout(ty),

    }

}

/// Get a layout that does not depend on nested type or nominal metadata.

fn fixedTypeLayout(ty: Type) -> Layout {

            panic "fixedTypeLayout: the given type has no fixed layout";

/// Fixed layouts cover primitive and pointer-like representations.

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

    for ty in [super::Type::Void, super::Type::Never] {

        checkFixedTypeLayout(ty, 0, 0);

    }

    for ty in [super::Type::Bool, super::Type::U8, super::Type::I8] {

        checkFixedTypeLayout(ty, 1, 1);

    }

    for ty in [super::Type::U16, super::Type::I16] { checkFixedTypeLayout(ty, 2, 2); }

    for ty in [super::Type::U32, super::Type::I32] { checkFixedTypeLayout(ty, 4, 4); }

    for ty in [super::Type::Int, super::Type::U64, super::Type::I64] { checkFixedTypeLayout(ty, 8, 8); }

    let mut arena = testArena();

    let itemStorage = try! alloc::alloc(&mut arena, @sizeOf(super::Type), @alignOf(super::Type)) as *mut super::Type;

    set *itemStorage = super::Type::U32;

    let item: *super::Type = itemStorage;

    let region = types::Region { id: 1, origin: types::RegionOrigin::Block, name: "r", parent: nil };

    let traitInfo = super::TraitType { name: "T", moduleId: 0, methods: &mut [], supertraits: &mut [] };

    let signature = try! alloc::alloc(&mut arena, @sizeOf(super::FnType), @alignOf(super::FnType)) as *mut super::FnType;

    set *signature = super::FnType {

        regions: nil, paramTypes: &[], returnType: item, throwList: &[], isUnsafe: false,

    };

    checkFixedTypeLayout(super::Type::Fn(signature), 8, 8);

    checkFixedTypeLayout(super::Type::Session(&region), 16, 8);

    for class in [types::PointerClass::Owned, types::PointerClass::Ref,

                  types::PointerClass::Unsafe, types::PointerClass::Region(&region)] {

        checkFixedTypeLayout(super::Type::Cell { class, payload: item }, 8, 8);

        for mutable in [false, true] {

            checkFixedTypeLayout(super::Type::Pointer { class, target: item, mutable }, 8, 8);

            checkFixedTypeLayout(super::Type::Slice { class, item, mutable }, 16, 8);

            checkFixedTypeLayout(super::Type::TraitObject { class, traitInfo: &traitInfo, mutable }, 16, 8);

        }

    }

}

/// Check a fixed layout through direct, array, and optional type traversal.

unsafe fn checkFixedTypeLayout(ty: super::Type, size: u32, alignment: u32) {

    let layout = super::getTypeLayout(ty);

    assert layout.size == size and layout.alignment == alignment;

    let mut arena = alloc::new(&mut FIXED_LAYOUT_STORAGE[..]);

    let itemStorage = try! alloc::alloc(&mut arena, @sizeOf(super::Type), @alignOf(super::Type)) as *mut super::Type;

    set *itemStorage = ty;

    let item: *super::Type = itemStorage;

    for length in [0 as u32, 1, 3] {

        let array = super::getTypeLayout(super::Type::Array(super::ArrayType { item, length }));

        assert array.size == size * length and array.alignment == alignment;

    }

    let optional = super::getTypeLayout(super::Type::Optional(item));

    let expected = layout if super::isNullableType(ty) else super::getOptionalAggregateLayout(layout);

    assert optional.size == expected.size and optional.alignment == expected.alignment;

}

/// Storage for one owned type used by array and optional layout fixtures.

static FIXED_LAYOUT_STORAGE: [u8; 256] = [0; 256];