Enum ParseErrorType 

pub enum ParseErrorType {
    OtherError(String),
    EmptySlice,
    EmptyGlobalNames,
    EmptyNonlocalNames,
    EmptyDeleteTargets,
    EmptyImportNames,
    EmptyTypeParams,
    UnparenthesizedNamedExpression,
    UnparenthesizedTupleExpression,
    UnparenthesizedGeneratorExpression,
    InvalidLambdaExpressionUsage,
    InvalidYieldExpressionUsage,
    InvalidStarredExpressionUsage,
    InvalidStarPatternUsage,
    ParamAfterVarKeywordParam,
    NonDefaultParamAfterDefaultParam,
    VarParameterWithDefault,
    DuplicateKeywordArgumentError(String),
    InvalidAssignmentTarget,
    InvalidNamedAssignmentTarget,
    InvalidAnnotatedAssignmentTarget,
    InvalidAugmentedAssignmentTarget,
    InvalidDeleteTarget,
    PositionalAfterKeywordArgument,
    PositionalAfterKeywordUnpacking,
    InvalidArgumentUnpackingOrder,
    IterableUnpackingInComprehension,
    SimpleStatementsOnSameLine,
    SimpleAndCompoundStatementOnSameLine,
    ExpectedKeywordParam,
    ExpectedRealNumber,
    ExpectedImaginaryNumber,
    ExpectedExpression,
    ExpectedToken {
        expected: TokenKind,
        found: TokenKind,
    },
    UnexpectedIndentation,
    UnexpectedTokenAfterAsync(TokenKind),
    UnexpectedIpythonEscapeCommand,
    UnexpectedExpressionToken,
    FStringError(InterpolatedStringErrorType),
    TStringError(InterpolatedStringErrorType),
    Lexical(LexicalErrorType),
}

Represents the different types of errors that can occur during parsing.

Variants

OtherError(String)

An unexpected error occurred.

EmptySlice

An empty slice was found during parsing, e.g data[].

EmptyGlobalNames

An empty global names list was found during parsing.

EmptyNonlocalNames

An empty nonlocal names list was found during parsing.

EmptyDeleteTargets

An empty delete targets list was found during parsing.

EmptyImportNames

An empty import names list was found during parsing.

EmptyTypeParams

An empty type parameter list was found during parsing.

UnparenthesizedNamedExpression

An unparenthesized named expression was found where it is not allowed.

UnparenthesizedTupleExpression

An unparenthesized tuple expression was found where it is not allowed.

UnparenthesizedGeneratorExpression

An unparenthesized generator expression was found where it is not allowed.

InvalidLambdaExpressionUsage

An invalid usage of a lambda expression was found.

InvalidYieldExpressionUsage

An invalid usage of a yield expression was found.

InvalidStarredExpressionUsage

An invalid usage of a starred expression was found.

InvalidStarPatternUsage

A star pattern was found outside a sequence pattern.

ParamAfterVarKeywordParam

A parameter was found after a vararg.

NonDefaultParamAfterDefaultParam

A non-default parameter follows a default parameter.

VarParameterWithDefault

A default value was found for a * or ** parameter.

DuplicateKeywordArgumentError(String)

A keyword argument was repeated.

InvalidAssignmentTarget

An invalid expression was found in the assignment target.

InvalidNamedAssignmentTarget

An invalid expression was found in the named assignment target.

InvalidAnnotatedAssignmentTarget

An invalid expression was found in the annotated assignment target.

InvalidAugmentedAssignmentTarget

An invalid expression was found in the augmented assignment target.

InvalidDeleteTarget

An invalid expression was found in the delete target.

PositionalAfterKeywordArgument

A positional argument was found after a keyword argument.

PositionalAfterKeywordUnpacking

A positional argument was found after a keyword argument unpacking.

InvalidArgumentUnpackingOrder

An iterable argument unpacking was found after keyword argument unpacking.

IterableUnpackingInComprehension

An invalid usage of iterable unpacking in a comprehension was found.

SimpleStatementsOnSameLine

Multiple simple statements were found in the same line without a ; separating them.

SimpleAndCompoundStatementOnSameLine

A simple statement and a compound statement was found in the same line.

ExpectedKeywordParam

Expected one or more keyword parameter after * separator.

ExpectedRealNumber

Expected a real number for a complex literal pattern.

ExpectedImaginaryNumber

Expected an imaginary number for a complex literal pattern.

ExpectedExpression

Expected an expression at the current parser location.

ExpectedToken

The parser expected a specific token that was not found.

Fields

expected: TokenKind

found: TokenKind

UnexpectedIndentation

An unexpected indentation was found during parsing.

UnexpectedTokenAfterAsync(TokenKind)

The statement being parsed cannot be async.

UnexpectedIpythonEscapeCommand

Ipython escape command was found

UnexpectedExpressionToken

An unexpected token was found at the end of an expression parsing

FStringError(InterpolatedStringErrorType)

An f-string error containing the InterpolatedStringErrorType.

TStringError(InterpolatedStringErrorType)

A t-string error containing the InterpolatedStringErrorType.

Lexical(LexicalErrorType)

Parser encountered an error during lexing.

Trait Implementations

impl Clone for ParseErrorType

fn clone(&self) -> ParseErrorType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ParseErrorType

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

Formats the value using the given formatter.

impl Display for ParseErrorType

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

Formats the value using the given formatter.

impl Error for ParseErrorType

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 GetSize for ParseErrorType

fn get_heap_size(&self) -> usize

Determines how many bytes this object occupies inside the heap.

fn get_heap_size_with_tracker<TRACKER: GetSizeTracker>( &self, tracker: TRACKER, ) -> (usize, TRACKER)

Determines how many bytes this object occupies inside the heap while using a tracker.

fn get_stack_size() -> usize

Determines how may bytes this object occupies inside the stack.

fn get_size(&self) -> usize

Determines the total size of the object.

fn get_size_with_tracker<T>(&self, tracker: T) -> (usize, T)

where T: GetSizeTracker,

Determines the total size of the object while using a tracker.

impl PartialEq for ParseErrorType

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

impl StructuralPartialEq for ParseErrorType