Enum ParseError 

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

Parsing errors

Variants

ParseFloatError(Refer<ParseFloatError>)

Error parsing floating point literal

ParseIntError(Refer<ParseIntError>)

Error parsing integer literal

RuleNotFoundError(Box<Rule>)

Parser rule not found error

IoError(Refer<Error>)

IO Error

Parser(Box<Error<Rule>>)

Error in pest parser

ParseColorError(Refer<ParseColorError>)

Error parsing color literal

UnknownColorName(Refer<String>)

Unknown color name

UnknownUnit(Refer<String>)

Unknown unit

UnexpectedToken(SrcRef)

Unexpected token

MixedTupleArguments(SrcRef)

Tuple expression contains both named and positional arguments

DuplicateNamedArgument(Identifier)

Duplicate named argument

PositionalArgumentAfterNamed(SrcRef)

Positional argument after named argument

EmptyTupleExpression(SrcRef)

Empty tuple expression

ParameterMissingTypeOrValue(Identifier)

Missing type or value for definition parameter

DuplicateParameter(Identifier)

Duplicate parameter

DuplicateArgument(Identifier)

Duplicate argument

DuplicatedMapType(Identifier)

Duplicated type name in map

DuplicateIdentifier(Identifier)

Duplicate id

DuplicateTupleIdentifier(Identifier)

Duplicate id in tuple

DuplicateTupleType(Refer<Type>)

Duplicate unnamed type in tuple

MissingFormatExpression(SrcRef)

Missing format expression

StatementBetweenInit(SrcRef)

Statement between two init statements

LoadSource(Refer<PathBuf>)

Loading of a source file failed

GrammarRuleError(Refer<String>)

Grammar rule error

InvalidQualifiedName(Refer<String>)

Grammar rule error

InvalidIdentifier(Refer<String>)

Grammar rule error

QualifiedNameIsNoId(QualifiedName)

Qualified name cannot be converted into an Id

NotAvailable(SrcRef)

Element is not available

UnknownType(Refer<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<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 SrcReferrer for ParseError

fn src_ref(&self) -> SrcRef

Return source code reference.

fn source_hash(&self) -> u64

Return source code hash.