Enum Error 

pub(crate) enum Error<'a> {
    Unexpected(Span, ExpectedToken<'a>),
    UnexpectedComponents(Span),
    UnexpectedOperationInConstContext(Span),
    BadNumber(Span, NumberError),
    BadMatrixScalarKind(Span, Scalar),
    BadAccessor(Span),
    BadTexture(Span),
    BadTypeCast {
        span: Span,
        from_type: String,
        to_type: String,
    },
    NotStorageTexture(Span),
    BadTextureSampleType {
        span: Span,
        scalar: Scalar,
    },
    BadIncrDecrReferenceType(Span),
    InvalidResolve(ResolveError),
    InvalidForInitializer(Span),
    InvalidBreakIf(Span),
    InvalidGatherComponent(Span),
    InvalidConstructorComponentType(Span, i32),
    InvalidIdentifierUnderscore(Span),
    ReservedIdentifierPrefix(Span),
    UnknownAddressSpace(Span),
    RepeatedAttribute(Span),
    UnknownAttribute(Span),
    UnknownBuiltin(Span),
    UnknownAccess(Span),
    UnknownIdent(Span, &'a str),
    UnknownScalarType(Span),
    UnknownType(Span),
    UnknownStorageFormat(Span),
    UnknownConservativeDepth(Span),
    UnknownEnableExtension(Span, &'a str),
    UnknownLanguageExtension(Span, &'a str),
    UnknownDiagnosticRuleName(Span),
    SizeAttributeTooLow(Span, u32),
    AlignAttributeTooLow(Span, Alignment),
    NonPowerOfTwoAlignAttribute(Span),
    InconsistentBinding(Span),
    TypeNotConstructible(Span),
    TypeNotInferable(Span),
    InitializationTypeMismatch {
        name: Span,
        expected: String,
        got: String,
    },
    DeclMissingTypeAndInit(Span),
    MissingAttribute(&'static str, Span),
    InvalidAddrOfOperand(Span),
    InvalidAtomicPointer(Span),
    InvalidAtomicOperandType(Span),
    InvalidRayQueryPointer(Span),
    NotPointer(Span),
    NotReference(&'static str, Span),
    InvalidAssignment {
        span: Span,
        ty: InvalidAssignmentType,
    },
    ReservedKeyword(Span),
    Redefinition {
        previous: Span,
        current: Span,
    },
    RecursiveDeclaration {
        ident: Span,
        usage: Span,
    },
    CyclicDeclaration {
        ident: Span,
        path: Box<[(Span, Span)]>,
    },
    InvalidSwitchSelector {
        span: Span,
    },
    InvalidSwitchCase {
        span: Span,
    },
    SwitchCaseTypeMismatch {
        span: Span,
    },
    CalledEntryPoint(Span),
    WrongArgumentCount {
        span: Span,
        expected: Range<u32>,
        found: u32,
    },
    TooManyArguments {
        function: String,
        call_span: Span,
        arg_span: Span,
        max_arguments: u32,
    },
    WrongArgumentType {
        function: String,
        call_span: Span,
        arg_span: Span,
        arg_index: u32,
        arg_ty: String,
        allowed: Vec<String>,
    },
    InconsistentArgumentType {
        function: String,
        call_span: Span,
        arg_span: Span,
        arg_index: u32,
        arg_ty: String,
        inconsistent_span: Span,
        inconsistent_index: u32,
        inconsistent_ty: String,
        allowed: Vec<String>,
    },
    FunctionReturnsVoid(Span),
    FunctionMustUseUnused(Span),
    FunctionMustUseReturnsVoid(Span, Span),
    InvalidWorkGroupUniformLoad(Span),
    Internal(&'static str),
    ExpectedConstExprConcreteIntegerScalar(Span),
    ExpectedNonNegative(Span),
    ExpectedPositiveArrayLength(Span),
    MissingWorkgroupSize(Span),
    ConstantEvaluatorError(Box<ConstantEvaluatorError>, Span),
    AutoConversion(Box<AutoConversionError>),
    AutoConversionLeafScalar(Box<AutoConversionLeafScalarError>),
    ConcretizationFailed(Box<ConcretizationFailedError>),
    ExceededLimitForNestedBraces {
        span: Span,
        limit: u8,
    },
    PipelineConstantIDValue(Span),
    NotBool(Span),
    ConstAssertFailed(Span),
    DirectiveAfterFirstGlobalDecl {
        directive_span: Span,
    },
    EnableExtensionNotYetImplemented {
        kind: UnimplementedEnableExtension,
        span: Span,
    },
    EnableExtensionNotEnabled {
        kind: EnableExtension,
        span: Span,
    },
    LanguageExtensionNotYetImplemented {
        kind: UnimplementedLanguageExtension,
        span: Span,
    },
    DiagnosticInvalidSeverity {
        severity_control_name_span: Span,
    },
    DiagnosticDuplicateTriggeringRule(ConflictingDiagnosticRuleError),
    DiagnosticAttributeNotYetImplementedAtParseSite {
        site_name_plural: &'static str,
        spans: Vec<Span>,
    },
    DiagnosticAttributeNotSupported {
        on_what: DiagnosticAttributeNotSupportedPosition,
        spans: Vec<Span>,
    },
    SelectUnexpectedArgumentType {
        arg_span: Span,
        arg_type: String,
    },
    SelectRejectAndAcceptHaveNoCommonType {
        reject_span: Span,
        reject_type: String,
        accept_span: Span,
        accept_type: String,
    },
}

Variants

Unexpected(Span, ExpectedToken<'a>)

UnexpectedComponents(Span)

UnexpectedOperationInConstContext(Span)

BadNumber(Span, NumberError)

BadMatrixScalarKind(Span, Scalar)

BadAccessor(Span)

BadTexture(Span)

BadTypeCast

Fields

span: Span

from_type: String

to_type: String

NotStorageTexture(Span)

BadTextureSampleType

Fields

span: Span

scalar: Scalar

BadIncrDecrReferenceType(Span)

InvalidResolve(ResolveError)

InvalidForInitializer(Span)

InvalidBreakIf(Span)

A break if appeared outside of a continuing block

InvalidGatherComponent(Span)

InvalidConstructorComponentType(Span, i32)

InvalidIdentifierUnderscore(Span)

ReservedIdentifierPrefix(Span)

UnknownAddressSpace(Span)

RepeatedAttribute(Span)

UnknownAttribute(Span)

UnknownBuiltin(Span)

UnknownAccess(Span)

UnknownIdent(Span, &'a str)

UnknownScalarType(Span)

UnknownType(Span)

UnknownStorageFormat(Span)

UnknownConservativeDepth(Span)

UnknownEnableExtension(Span, &'a str)

UnknownLanguageExtension(Span, &'a str)

UnknownDiagnosticRuleName(Span)

SizeAttributeTooLow(Span, u32)

AlignAttributeTooLow(Span, Alignment)

NonPowerOfTwoAlignAttribute(Span)

InconsistentBinding(Span)

TypeNotConstructible(Span)

TypeNotInferable(Span)

InitializationTypeMismatch

Fields

name: Span

expected: String

got: String

DeclMissingTypeAndInit(Span)

MissingAttribute(&'static str, Span)

InvalidAddrOfOperand(Span)

InvalidAtomicPointer(Span)

InvalidAtomicOperandType(Span)

InvalidRayQueryPointer(Span)

NotPointer(Span)

NotReference(&'static str, Span)

InvalidAssignment

Fields

span: Span

ty: InvalidAssignmentType

ReservedKeyword(Span)

Redefinition

Redefinition of an identifier (used for both module-scope and local redefinitions).

Fields

previous: Span

Span of the identifier in the previous definition.

current: Span

Span of the identifier in the new definition.

RecursiveDeclaration

A declaration refers to itself directly.

Fields

ident: Span

The location of the name of the declaration.

usage: Span

The point at which it is used.

CyclicDeclaration

A declaration refers to itself indirectly, through one or more other definitions.

Fields

ident: Span

The location of the name of some declaration in the cycle.

path: Box<[(Span, Span)]>

The edges of the cycle of references.

Each (decl, reference) pair indicates that the declaration whose name is decl has an identifier at reference whose definition is the next declaration in the cycle. The last pair’s reference is the same identifier as ident, above.

InvalidSwitchSelector

Fields

span: Span

InvalidSwitchCase

Fields

span: Span

SwitchCaseTypeMismatch

Fields

span: Span

CalledEntryPoint(Span)

WrongArgumentCount

Fields

span: Span

expected: Range<u32>

found: u32

TooManyArguments

No overload of this function accepts this many arguments.

Fields

function: String

The name of the function being called.

call_span: Span

The function name in the call expression.

arg_span: Span

The first argument that is unacceptable.

max_arguments: u32

Maximum number of arguments accepted by any overload of this function.

WrongArgumentType

A value passed to a builtin function has a type that is not accepted by any overload of the function.

Fields

function: String

The name of the function being called.

call_span: Span

The function name in the call expression.

arg_span: Span

The first argument whose type is unacceptable.

arg_index: u32

The index of the first argument whose type is unacceptable.

arg_ty: String

That argument’s actual type.

allowed: Vec<String>

The set of argument types that would have been accepted for this argument, given the prior arguments.

InconsistentArgumentType

A value passed to a builtin function has a type that is not accepted, given the earlier arguments’ types.

Fields

function: String

The name of the function being called.

call_span: Span

The function name in the call expression.

arg_span: Span

The first unacceptable argument.

arg_index: u32

The index of the first unacceptable argument.

arg_ty: String

The actual type of the first unacceptable argument.

inconsistent_span: Span

The prior argument whose type made the arg_span argument unacceptable.

inconsistent_index: u32

The index of the inconsistent_span argument.

inconsistent_ty: String

The type of the inconsistent_span argument.

allowed: Vec<String>

The types that would have been accepted instead of the first unacceptable argument.

FunctionReturnsVoid(Span)

FunctionMustUseUnused(Span)

FunctionMustUseReturnsVoid(Span, Span)

InvalidWorkGroupUniformLoad(Span)

Internal(&'static str)

ExpectedConstExprConcreteIntegerScalar(Span)

ExpectedNonNegative(Span)

ExpectedPositiveArrayLength(Span)

MissingWorkgroupSize(Span)

ConstantEvaluatorError(Box<ConstantEvaluatorError>, Span)

AutoConversion(Box<AutoConversionError>)

AutoConversionLeafScalar(Box<AutoConversionLeafScalarError>)

ConcretizationFailed(Box<ConcretizationFailedError>)

ExceededLimitForNestedBraces

Fields

span: Span

limit: u8

PipelineConstantIDValue(Span)

NotBool(Span)

ConstAssertFailed(Span)

DirectiveAfterFirstGlobalDecl

Fields

directive_span: Span

EnableExtensionNotYetImplemented

Fields

kind: UnimplementedEnableExtension

span: Span

EnableExtensionNotEnabled

Fields

kind: EnableExtension

span: Span

LanguageExtensionNotYetImplemented

Fields

kind: UnimplementedLanguageExtension

span: Span

DiagnosticInvalidSeverity

Fields

severity_control_name_span: Span

DiagnosticDuplicateTriggeringRule(ConflictingDiagnosticRuleError)

DiagnosticAttributeNotYetImplementedAtParseSite

Fields

site_name_plural: &'static str

spans: Vec<Span>

DiagnosticAttributeNotSupported

Fields

on_what: DiagnosticAttributeNotSupportedPosition

spans: Vec<Span>

SelectUnexpectedArgumentType

Fields

arg_span: Span

arg_type: String

SelectRejectAndAcceptHaveNoCommonType

Fields

reject_span: Span

reject_type: String

accept_span: Span

accept_type: String

Implementations

impl<'a> Error<'a>

pub(crate) fn as_parse_error(&self, source: &'a str) -> ParseError

Trait Implementations

impl<'a> Clone for Error<'a>

fn clone(&self) -> Error<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Error<'a>

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

Formats the value using the given formatter.

impl From<ConflictingDiagnosticRuleError> for Error<'_>

fn from(value: ConflictingDiagnosticRuleError) -> Self

Converts to this type from the input type.