Enum ParseError 

pub enum ParseError {
    ExpectedIdentifier,
    ParseFloatError(ParseFloatError),
    ParseIntError(ParseIntError),
    RuleError(Box<Rule>),
    IoError(Error),
    Parser(Box<Error<Rule>>),
    ParseColorError(ParseColorError),
    UnknownColorName(String),
    UnknownUnit(String),
    UnexpectedToken,
    MixedTupleArguments,
    DuplicateNamedArgument(Identifier),
    PositionalArgumentAfterNamed,
    EmptyTupleExpression,
    ParameterMissingTypeOrValue(Identifier),
    DuplicateParameter(Identifier),
    DuplicateArgument(Identifier),
    InvalidMapKeyType(String),
    DuplicatedMapType(Identifier),
    DuplicateIdentifier(Identifier),
    DuplicateTupleIdentifier(Identifier),
    DuplicateTupleType(Type),
    MissingFormatExpression,
    StatementBetweenInit,
    LoadSource(PathBuf),
    GrammarRuleError(String),
    InvalidQualifiedName(String),
    InvalidIdentifier(String),
    QualifiedNameIsNoId(QualifiedName),
    IllegalWorkbenchStatement(SrcRef),
    CodeBetweenInitializers(SrcRef),
    StatementNotAllowedPriorInitializers(SrcRef),
    NotAvailable,
    UnknownType(String),
}

Parsing errors

Variants

ExpectedIdentifier

Expected identifier

ParseFloatError(ParseFloatError)

Error parsing floating point literal

ParseIntError(ParseIntError)

Error parsing integer literal

RuleError(Box<Rule>)

Parser rule error

IoError(Error)

IO Error

Parser(Box<Error<Rule>>)

Error in pest parser

ParseColorError(ParseColorError)

Error parsing color literal

UnknownColorName(String)

Unknown color name

UnknownUnit(String)

Unknown unit

UnexpectedToken

Unexpected token

MixedTupleArguments

Tuple expression contains both named and positional arguments

DuplicateNamedArgument(Identifier)

Duplicate named argument

PositionalArgumentAfterNamed

Positional argument after named argument

EmptyTupleExpression

Empty tuple expression

ParameterMissingTypeOrValue(Identifier)

Missing type or value for definition parameter

DuplicateParameter(Identifier)

Duplicate parameter

DuplicateArgument(Identifier)

Duplicate argument

InvalidMapKeyType(String)

Invalid map key type

DuplicatedMapType(Identifier)

Duplicated type name in map

DuplicateIdentifier(Identifier)

Duplicate identifier

DuplicateTupleIdentifier(Identifier)

Duplicate identifier in tuple

DuplicateTupleType(Type)

Duplicate unnamed type in tuple

MissingFormatExpression

Missing format expression

StatementBetweenInit

Statement between two init statements

LoadSource(PathBuf)

Loading of a source file failed

GrammarRuleError(String)

Grammar rule error

InvalidQualifiedName(String)

Grammar rule error

InvalidIdentifier(String)

Grammar rule error

QualifiedNameIsNoId(QualifiedName)

Qualified name cannot be converted into an Id

IllegalWorkbenchStatement(SrcRef)

Statement not allowed within workbenches

CodeBetweenInitializers(SrcRef)

Code Between initializers

StatementNotAllowedPriorInitializers(SrcRef)

Statement not allowed prior initializers

NotAvailable

Element is not available

UnknownType(String)

Unknown type

Trait Implementations

impl Debug for ParseError

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

Formats the value using the given formatter.

impl Display for ParseError

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

Formats the value using the given formatter.

impl Error for ParseError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<Box<Error<Rule>>> for ParseError

fn from(source: Box<Error<Rule>>) -> Self

Converts to this type from the input type.

impl From<Error> for ParseError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ParseColorError> for ParseError

fn from(source: ParseColorError) -> Self

Converts to this type from the input type.

impl From<ParseError> for EvalError

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl From<ParseError> for ResolveError

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl From<ParseFloatError> for ParseError

fn from(source: ParseFloatError) -> Self

Converts to this type from the input type.

impl From<ParseIntError> for ParseError

fn from(source: ParseIntError) -> Self

Converts to this type from the input type.