Enum ParseError 

pub enum ParseError {
    SyntaxError {
        span: SourceSpan,
        message: String,
        suggestion: Option<Suggestion>,
    },
    NotSupported {
        span: SourceSpan,
        rule: Rule,
    },
    Unexpected {
        span: SourceSpan,
        rule: Rule,
        expected: Vec<Rule>,
    },
    UnexpectedTokens {
        span: SourceSpan,
        rules: Vec<Rule>,
    },
    EOF {
        span: SourceSpan,
    },
    InvalidFloat(ParseFloatError),
    InvalidInteger(ParseIntError),
    InvalidBool(ParseBoolError),
    InvalidDate(ParseError),
    InvalidRegex(Error),
    UnsupportedAlignFunction {
        span: SourceSpan,
        name: String,
    },
    UnsupportedGroupFunction {
        span: SourceSpan,
        name: String,
    },
    UnsupportedComputeFunction {
        span: SourceSpan,
        name: String,
    },
    UnsupportedBucketFunction {
        span: SourceSpan,
        name: String,
    },
    UnsupportedMapEvaluation {
        span: SourceSpan,
        name: String,
    },
    UnsupportedMapFunction {
        span: SourceSpan,
        name: String,
    },
    UnsupportedRegexpComparison {
        span: SourceSpan,
        op: String,
    },
    UnsupportedTagComparison {
        span: SourceSpan,
        op: String,
    },
    NotImplemented(&'static str),
    StrumbraError(Error),
    Unreachable(&'static str),
    ParamDefinedMultipleTimes {
        span: SourceSpan,
        param: String,
    },
    UndefinedParam {
        span: SourceSpan,
        param: String,
    },
    InvalidTagType {
        span: SourceSpan,
        tpe: String,
    },
}

MPL parsing error

Variants

SyntaxError

Syntax error with source location.

Fields

span: SourceSpan

The source location of the error with detailed message

message: String

The detailed error message

suggestion: Option<Suggestion>

Optional suggestion for fixing the error

NotSupported

Rule for a unsupported feature

Fields

span: SourceSpan

The source location of the unsupported feature

rule: Rule

The rule that is not supported

Unexpected

Unexpected rule

Fields

span: SourceSpan

The source location of the unexpected rule

rule: Rule

The rule that was unexpected

expected: Vec<Rule>

Expected rules

UnexpectedTokens

Unexpected Token

Fields

span: SourceSpan

The source location of the unexpected tokens

rules: Vec<Rule>

The unexpected rules

EOF

Unexpected EOF

Fields

span: SourceSpan

The source location where more input was expected

InvalidFloat(ParseFloatError)

Invalid Floating point number

InvalidInteger(ParseIntError)

Invalid Integer

InvalidBool(ParseBoolError)

Invalid bool

InvalidDate(ParseError)

Invalid date

InvalidRegex(Error)

Invalid Regex

UnsupportedAlignFunction

Unsupported align function

Fields

span: SourceSpan

The source location of the unsupported function

name: String

The name of the unsupported function

UnsupportedGroupFunction

Unsupported group function

Fields

span: SourceSpan

The source location of the unsupported function

name: String

The name of the unsupported function

UnsupportedComputeFunction

Unsupported compute function

Fields

span: SourceSpan

The source location of the unsupported function

name: String

The name of the unsupported function

UnsupportedBucketFunction

Unsupported bucketing function

Fields

span: SourceSpan

The source location of the unsupported function

name: String

The name of the unsupported function

UnsupportedMapEvaluation

Unsupported map evaluation

Fields

span: SourceSpan

The source location of the unsupported operation

name: String

The name of the unsupported operation

UnsupportedMapFunction

Unsupported map function

Fields

span: SourceSpan

The source location of the unsupported function

name: String

The name of the unsupported function

UnsupportedRegexpComparison

Unsupported regexp comparison

Fields

span: SourceSpan

The source location of the unsupported operator

op: String

The unsupported operator

UnsupportedTagComparison

Unsupported comparison against tag value

Fields

span: SourceSpan

The source location of the unsupported operator

op: String

The unsupported operator

NotImplemented(&'static str)

The feature is not implemented yet

StrumbraError(Error)

Strumbra error

Unreachable(&'static str)

Unreachable error

ParamDefinedMultipleTimes

Param is defined multiple times

Fields

span: SourceSpan

The source location of the duplicate definition

param: String

The param

UndefinedParam

Param is not defined

Fields

span: SourceSpan

The source location of the undefine param

param: String

The param

InvalidTagType

Invalid tag type

Fields

span: SourceSpan

The source location of the invalid type

tpe: String

The invalid type

Trait Implementations

impl Debug for ParseError

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

Formats the value using the given formatter.

impl Diagnostic for ParseError

fn code(&self) -> Option<Box<dyn Display + '_>>

Unique diagnostic code that can be used to look up more information about this Diagnostic. Ideally also globally unique, and documented in the toplevel crate’s documentation for easy searching. Rust path format (foo::bar::baz) is recommended, but more classic codes like E0123 or enums will work just fine.

fn help(&self) -> Option<Box<dyn Display + '_>>

Additional help text related to this Diagnostic. Do you have any advice for the poor soul who’s just run into this issue?

fn labels(&self) -> Option<Box<dyn Iterator<Item = LabeledSpan> + '_>>

Labels to apply to this Diagnostic’s Diagnostic::source_code

fn severity(&self) -> Option<Severity>

Diagnostic severity. This may be used by ReportHandlers to change the display format of this diagnostic.

fn url<'a>(&'a self) -> Option<Box<dyn Display + 'a>>

URL to visit for a more detailed explanation/help about this Diagnostic.

fn source_code(&self) -> Option<&dyn SourceCode>

Source code to apply this Diagnostic’s Diagnostic::labels to.

fn related<'a>( &'a self, ) -> Option<Box<dyn Iterator<Item = &'a dyn Diagnostic> + 'a>>

Additional related Diagnostics.

fn diagnostic_source(&self) -> Option<&dyn Diagnostic>

The cause of the error.

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<Error<Rule>> for ParseError

fn from(err: PestError<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<Error> for ParseError

fn from(source: Error) -> Self

Converts to this type from the input type.

impl From<ParseBoolError> for ParseError

fn from(source: ParseBoolError) -> Self

Converts to this type from the input type.

impl From<ParseError> for CompileError

fn from(source: ParseError) -> Self

Converts to this type from the input type.

impl From<ParseError> for ParseError

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.