Enum LocalType

enum LocalType {
    Numeric(NumericType),
    Pointer {
        base: Word,
        class: StorageClass,
    },
    Image(LocalImageType),
    SampledImage {
        image_type_id: Word,
    },
    Sampler,
    BindingArray {
        base: Handle<Type>,
        size: u32,
    },
    AccelerationStructure,
    RayQuery,
}

A SPIR-V type constructed during code generation.

This is the variant of LookupType used to represent types that might not be available in the arena. Variants are present here for one of two reasons:

• They represent types synthesized during code generation, as explained in the documentation for LookupType.

• They represent types for which SPIR-V forbids duplicate OpType... instructions, requiring deduplication.

This is not a complete copy of TypeInner: for example, SPIR-V generation never synthesizes new struct types, so LocalType has nothing for that.

Each LocalType variant should be handled identically to its analogous TypeInner variant. You can use the Writer::localtype_from_inner function to help with this, by converting everything possible to a LocalType before inspecting it.

LocalType equality and SPIR-V OpType uniqueness

The definition of Eq on LocalType is carefully chosen to help us follow certain SPIR-V rules. SPIR-V §2.8 requires some classes of OpType... instructions to be unique; for example, you can’t have two OpTypeInt 32 1 instructions in the same module. All 32-bit signed integers must use the same type id.

All SPIR-V types that must be unique can be represented as a LocalType, and two LocalTypes are always Eq if SPIR-V would require them to use the same OpType... instruction. This lets us avoid duplicates by recording the ids of the type instructions we’ve already generated in a hash table, Writer::lookup_type, keyed by LocalType.

As another example, LocalImageType, stored in the LocalType::Image variant, is designed to help us deduplicate OpTypeImage instructions. See its documentation for details.

SPIR-V does not require pointer types to be unique - but different SPIR-V ids are considered to be distinct pointer types. Since Naga uses structural type equality, we need to represent each Naga equivalence class with a single SPIR-V OpTypePointer.

As it always must, the Hash implementation respects the Eq relation.

Variants

Numeric(NumericType)

A numeric type.

Pointer

Fields

base: Word

class: StorageClass

Image(LocalImageType)

SampledImage

Fields

image_type_id: Word

Sampler

BindingArray

Fields

base: Handle<Type>

size: u32

AccelerationStructure

RayQuery

Trait Implementations

impl Clone for LocalType

fn clone(&self) -> LocalType

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LocalType

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<LocalType> for LookupType

fn from(local: LocalType) -> Self

Converts to this type from the input type.

impl Hash for LocalType

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LocalType

fn eq(&self, other: &LocalType) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for LocalType

impl Eq for LocalType

impl StructuralPartialEq for LocalType