Enum naga::proc::TypeResolution

pub enum TypeResolution {
    Handle(Handle<Type>),
    Value(TypeInner),
}

The result of computing an expression’s type.

This is the (Rust) type returned by ResolveContext::resolve to represent the (Naga) type it ascribes to some expression.

You might expect such a function to simply return a Handle<Type>. However, we want type resolution to be a read-only process, and that would limit the possible results to types already present in the expression’s associated UniqueArena<Type>. Naga IR does have certain expressions whose types are not certain to be present.

So instead, type resolution returns a TypeResolution enum: either a Handle, referencing some type in the arena, or a Value, holding a free-floating TypeInner. This extends the range to cover anything that can be represented with a TypeInner referring to the existing arena.

What sorts of expressions can have types not available in the arena?

• An Access or AccessIndex expression applied to a Vector or Matrix must have a Scalar or Vector type. But since Vector and Matrix represent their element and column types implicitly, not via a handle, there may not be a suitable type in the expression’s associated arena. Instead, resolving such an expression returns a TypeResolution::Value(TypeInner::X { ... }), where X is Scalar or Vector.

• Similarly, the type of an Access or AccessIndex expression applied to a pointer to a vector or matrix must produce a pointer to a scalar or vector type. These cannot be represented with a TypeInner::Pointer, since the Pointer’s base must point into the arena, and as before, we cannot assume that a suitable scalar or vector type is there. So we take things one step further and provide TypeInner::ValuePointer, specifically for the case of pointers to scalars or vectors. This type fits in a TypeInner and is exactly equivalent to a Pointer to a Vector or Scalar.

So, for example, the type of an Access expression applied to a value of type:

TypeInner::Matrix { columns, rows, width }

might be:

TypeResolution::Value(TypeInner::Vector {
    size: rows,
    kind: ScalarKind::Float,
    width,
})

and the type of an access to a pointer of address space space to such a matrix might be:

TypeResolution::Value(TypeInner::ValuePointer {
    size: Some(rows),
    kind: ScalarKind::Float,
    width,
    space,
})

Variants

Handle(Handle<Type>)

A type stored in the associated arena.

Value(TypeInner)

A free-floating TypeInner, representing a type that may not be available in the associated arena. However, the TypeInner itself may contain Handle<Type> values referring to types from the arena.

Implementations

impl TypeResolution

pub fn to_wgsl(&self, gctx: &GlobalCtx<'_>) -> String

impl TypeResolution

pub const fn handle(&self) -> Option<Handle<Type>>

pub fn inner_with<'a>(&'a self, arena: &'a UniqueArena<Type>) -> &'a TypeInner

Trait Implementations

impl Clone for TypeResolution

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for TypeResolution

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

Formats the value using the given formatter.

impl PartialEq for TypeResolution

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for TypeResolution