Enum ParseErrorKind 

#[non_exhaustive]
pub enum ParseErrorKind {
    Lex(Error),
    Syntax {
        span: Span,
        message: String,
    },
    ItemNotFound {
        span: Span,
        name: String,
        kind: String,
        hint: Option<String>,
    },
    TypeCycle {
        span: Span,
        name: String,
        kind: String,
    },
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Lex(Error)

Lexer error (invalid character, unterminated comment, etc.)

Syntax

Syntactic or semantic error within a single package (duplicate name, invalid attribute, etc.)

Fields

span: Span

message: String

ItemNotFound

A type/interface/world references a name that does not exist within the same package.

Fields

span: Span

name: String

kind: String

hint: Option<String>

TypeCycle

A type/interface/world depends on itself.

Fields

span: Span

name: String

kind: String

Implementations

impl ParseErrorKind

pub fn span(&self) -> Span

Trait Implementations

impl Debug for ParseErrorKind

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

Formats the value using the given formatter.

impl Display for ParseErrorKind

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

Formats the value using the given formatter.

impl From<ParseErrorKind> for ParseError

fn from(kind: ParseErrorKind) -> Self

Converts to this type from the input type.

impl PartialEq for ParseErrorKind

fn eq(&self, other: &ParseErrorKind) -> 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 Eq for ParseErrorKind

impl StructuralPartialEq for ParseErrorKind