Struct Validator 

pub struct Validator {

    flags: ValidationFlags,
    capabilities: Capabilities,
    subgroup_stages: ShaderStages,
    subgroup_operations: SubgroupOperationSet,
    types: Vec<TypeInfo>,
    layouter: Layouter,
    location_mask: BitSet,
    blend_src_mask: BitSet,
    ep_resource_bindings: FastHashSet<ResourceBinding>,
    switch_values: FastHashSet<SwitchValue>,
    valid_expression_list: Vec<Handle<Expression>>,
    valid_expression_set: HandleSet<Expression>,
    override_ids: FastHashSet<u16>,
    overrides_resolved: bool,
    needs_visit: HandleSet<Expression>,
}

Fields

flags: ValidationFlags

capabilities: Capabilities

subgroup_stages: ShaderStages

subgroup_operations: SubgroupOperationSet

types: Vec<TypeInfo>

layouter: Layouter

location_mask: BitSet

blend_src_mask: BitSet

ep_resource_bindings: FastHashSet<ResourceBinding>

switch_values: FastHashSet<SwitchValue>

valid_expression_list: Vec<Handle<Expression>>

valid_expression_set: HandleSet<Expression>

override_ids: FastHashSet<u16>

overrides_resolved: bool

Treat overrides whose initializers are not fully-evaluated constant expressions as errors.

needs_visit: HandleSet<Expression>

A checklist of expressions that must be visited by a specific kind of statement.

For example:

• CallResult expressions must be visited by a Call statement.
• AtomicResult expressions must be visited by an Atomic statement.

Be sure not to remove any Expression handle from this set unless you’ve explicitly checked that it is the right kind of expression for the visiting Statement.

Implementations

impl Validator

pub(super) fn validate_const_expression( &self, handle: Handle<Expression>, gctx: GlobalCtx<'_>, mod_info: &ModuleInfo, global_expr_kind: &ExpressionKindTracker, ) -> Result<(), ConstExpressionError>

pub(super) fn validate_expression( &self, root: Handle<Expression>, expression: &Expression, function: &Function, module: &Module, info: &FunctionInfo, mod_info: &ModuleInfo, expr_kind: &ExpressionKindTracker, ) -> Result<ShaderStages, ExpressionError>

fn global_var_ty( module: &Module, function: &Function, expr: Handle<Expression>, ) -> Result<Handle<Type>, ExpressionError>

pub fn validate_literal(&self, literal: Literal) -> Result<(), LiteralError>

impl Validator

fn validate_call( &mut self, function: Handle<Function>, arguments: &[Handle<Expression>], result: Option<Handle<Expression>>, context: &BlockContext<'_>, ) -> Result<ShaderStages, WithSpan<CallError>>

fn emit_expression( &mut self, handle: Handle<Expression>, context: &BlockContext<'_>, ) -> Result<(), WithSpan<FunctionError>>

fn validate_atomic( &mut self, pointer: Handle<Expression>, fun: &AtomicFunction, value: Handle<Expression>, result: Option<Handle<Expression>>, span: Span, context: &BlockContext<'_>, ) -> Result<(), WithSpan<FunctionError>>

fn validate_subgroup_operation( &mut self, op: &SubgroupOperation, collective_op: &CollectiveOperation, argument: Handle<Expression>, result: Handle<Expression>, context: &BlockContext<'_>, ) -> Result<(), WithSpan<FunctionError>>

fn validate_subgroup_gather( &mut self, mode: &GatherMode, argument: Handle<Expression>, result: Handle<Expression>, context: &BlockContext<'_>, ) -> Result<(), WithSpan<FunctionError>>

fn validate_block_impl( &mut self, statements: &Block, context: &BlockContext<'_>, ) -> Result<BlockInfo, WithSpan<FunctionError>>

fn validate_block( &mut self, statements: &Block, context: &BlockContext<'_>, ) -> Result<BlockInfo, WithSpan<FunctionError>>

fn validate_local_var( &self, var: &LocalVariable, gctx: GlobalCtx<'_>, fun_info: &FunctionInfo, local_expr_kind: &ExpressionKindTracker, ) -> Result<(), LocalVariableError>

pub(super) fn validate_function( &mut self, fun: &Function, module: &Module, mod_info: &ModuleInfo, entry_point: bool, ) -> Result<FunctionInfo, WithSpan<FunctionError>>

impl Validator

pub(super) fn validate_module_handles( module: &Module, ) -> Result<(), ValidationError>

Validates that all handles within module are:

• Valid, in the sense that they contain indices within each arena structure inside the crate::Module type.
• No arena contents contain any items that have forward dependencies; that is, the value associated with a handle only may contain references to handles in the same arena that were constructed before it.

By validating the above conditions, we free up subsequent logic to assume that handle accesses are infallible.

Errors

Errors returned by this method are intentionally sparse, for simplicity of implementation. It is expected that only buggy frontends or fuzzers should ever emit IR that fails this validation pass.

fn validate_type_handle( handle: Handle<Type>, types: &UniqueArena<Type>, ) -> Result<(), InvalidHandleError>

fn validate_constant_handle( handle: Handle<Constant>, constants: &Arena<Constant>, ) -> Result<(), InvalidHandleError>

fn validate_global_variable_handle( handle: Handle<GlobalVariable>, global_variables: &Arena<GlobalVariable>, ) -> Result<(), InvalidHandleError>

fn validate_override_handle( handle: Handle<Override>, overrides: &Arena<Override>, ) -> Result<(), InvalidHandleError>

fn validate_expression_handle( handle: Handle<Expression>, expressions: &Arena<Expression>, ) -> Result<(), InvalidHandleError>

fn validate_function_handle( handle: Handle<Function>, functions: &Arena<Function>, ) -> Result<(), InvalidHandleError>

fn validate_type_handles( (handle, ty): (Handle<Type>, &Type), overrides: &Arena<Override>, ) -> Result<Option<Handle<Expression>>, InvalidHandleError>

Validate all handles that occur in ty, whose handle is handle.

If ty refers to any expressions, return the highest-indexed expression handle that it uses. This is used for detecting cycles between the expression and type arenas.

fn validate_entry_point_index( entry_point_index: usize, entry_points: &[EntryPoint], ) -> Result<(), InvalidHandleError>

fn validate_const_expression_handles( (handle, expression): (Handle<Expression>, &Expression), constants: &Arena<Constant>, overrides: &Arena<Override>, ) -> Result<Option<Handle<Type>>, InvalidHandleError>

Validate all handles that occur in expression, whose handle is handle.

If expression refers to any Types, return the highest-indexed type handle that it uses. This is used for detecting cycles between the expression and type arenas.

fn validate_expression_handles( (handle, expression): (Handle<Expression>, &Expression), constants: &Arena<Constant>, overrides: &Arena<Override>, types: &UniqueArena<Type>, local_variables: &Arena<LocalVariable>, global_variables: &Arena<GlobalVariable>, functions: &Arena<Function>, current_function: Option<Handle<Function>>, ) -> Result<(), InvalidHandleError>

fn validate_block_handles( block: &Block, expressions: &Arena<Expression>, functions: &Arena<Function>, ) -> Result<(), InvalidHandleError>

impl Validator

pub(super) fn validate_global_var( &self, var: &GlobalVariable, gctx: GlobalCtx<'_>, mod_info: &ModuleInfo, global_expr_kind: &ExpressionKindTracker, ) -> Result<(), GlobalVariableError>

pub(super) fn validate_entry_point( &mut self, ep: &EntryPoint, module: &Module, mod_info: &ModuleInfo, ) -> Result<FunctionInfo, WithSpan<EntryPointError>>

impl Validator

const fn require_type_capability( &self, capability: Capabilities, ) -> Result<(), TypeError>

pub(super) const fn check_width( &self, scalar: Scalar, ) -> Result<Result<(), PushConstantError>, WidthError>

pub(super) fn reset_types(&mut self, size: usize)

pub(super) fn validate_type( &self, handle: Handle<Type>, gctx: GlobalCtx<'_>, ) -> Result<TypeInfo, TypeError>

impl Validator

pub fn new(flags: ValidationFlags, capabilities: Capabilities) -> Self

Construct a new validator instance.

pub fn subgroup_stages(&mut self, stages: ShaderStages) -> &mut Self

pub fn subgroup_operations( &mut self, operations: SubgroupOperationSet, ) -> &mut Self

pub fn reset(&mut self)

Reset the validator internals

fn validate_constant( &self, handle: Handle<Constant>, gctx: GlobalCtx<'_>, mod_info: &ModuleInfo, global_expr_kind: &ExpressionKindTracker, ) -> Result<(), ConstantError>

fn validate_override( &mut self, handle: Handle<Override>, gctx: GlobalCtx<'_>, mod_info: &ModuleInfo, ) -> Result<(), OverrideError>

pub fn validate( &mut self, module: &Module, ) -> Result<ModuleInfo, WithSpan<ValidationError>>

Check the given module to be valid.

pub fn validate_resolved_overrides( &mut self, module: &Module, ) -> Result<ModuleInfo, WithSpan<ValidationError>>

Check the given module to be valid, requiring overrides to be resolved.

This is the same as validate, except that any override whose value is not a fully-evaluated constant expression is treated as an error.

fn validate_impl( &mut self, module: &Module, ) -> Result<ModuleInfo, WithSpan<ValidationError>>

Trait Implementations

impl Debug for Validator

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

Formats the value using the given formatter.