type Target = ParseErrorType;

fn deref(&self) -> &Self::Target {

&self.error

}

fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {

Some(&self.error)

}

fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

write!(f, "{} at byte range {:?}", self.error, self.location)

}

fn from(error: LexicalError) -> Self {

ParseError {

location: error.location(),

error: ParseErrorType::Lexical(error.into_error()),

}

}

fn range(&self) -> TextRange {

self.location

}

pub fn error(self) -> ParseErrorType {

self.error

}

/// `\x` is not followed by two hexadecimal digits.

TruncatedHexByte,

/// `\u` is not followed by four hexadecimal digits.

TruncatedShortUnicode,

/// `\U` is not followed by eight hexadecimal digits.

TruncatedLongUnicode,

/// `\U` names a code point above `U+10FFFF`.

IllegalCharacter,

/// `\N` is not followed by a non-empty name in braces.

MalformedName,

/// `\N{...}` names no Unicode character.

UnknownName,

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

f.write_str(match self {

Self::TruncatedHexByte => "truncated \\xXX escape",

Self::TruncatedShortUnicode => "truncated \\uXXXX escape",

Self::TruncatedLongUnicode => "truncated \\UXXXXXXXX escape",

Self::IllegalCharacter => "illegal Unicode character",

Self::MalformedName => "malformed \\N character escape",

Self::UnknownName => "unknown Unicode character name",

})

}

/// Expected a right brace after an opened left brace.

UnclosedLbrace,

/// Expected a right brace for a replacement field opened on an earlier line.

UnclosedLbraceOnLine { opening_line: u32 },

/// An invalid conversion flag was encountered.

InvalidConversionFlag,

/// A single right brace was encountered.

SingleRbrace,

/// Unterminated string, detected at the given one-based line.

UnterminatedString { detected_line: u32 },

/// Unterminated triple-quoted string, detected at the given one-based line.

UnterminatedTripleQuotedString { detected_line: u32 },

/// A lambda expression without parentheses was encountered.

LambdaWithoutParentheses,

/// Conversion flag does not immediately follow exclamation.

ConversionFlagNotImmediatelyAfterExclamation,

/// Newline inside of a format spec for a single quoted f- or t-string.

NewlineInFormatSpec,

/// A replacement field has no expression before the given separator.

ExpressionRequiredBefore(char),

/// A replacement field does not start with an expression.

ExpectedExpressionAfterLbrace,

/// The expression of a replacement field is not followed by `=`, `!`, `:` or `}`.

ExpectedSeparatorAfterExpression,

/// The `=` of a replacement field is not followed by `!`, `:` or `}`.

ExpectedSeparatorAfterDebug,

/// The conversion of a replacement field is not followed by `:` or `}`.

ExpectedSeparatorAfterConversion,

/// The format spec of a replacement field is not followed by `}`.

UnclosedFormatSpec,

/// A `!` is directly followed by `:` or `}`.

MissingConversionFlag,

/// A closing bracket closes the brace that opens a replacement field.

UnmatchedBracket(char),

fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

match self {

Self::UnclosedLbrace => f.write_str("expecting '}'"),

Self::UnclosedLbraceOnLine { opening_line } => {

write!(f, "expecting '}}' to close '{{' on line {opening_line}")

}

Self::InvalidConversionFlag => write!(f, "invalid conversion character"),

Self::SingleRbrace => f.write_str("single '}' is not allowed"),

Self::UnterminatedString { .. } => write!(f, "unterminated string"),

Self::UnterminatedTripleQuotedString { .. } => {

write!(f, "unterminated triple-quoted string")

}

Self::LambdaWithoutParentheses => {

write!(f, "lambda expressions are not allowed without parentheses")

}

Self::ConversionFlagNotImmediatelyAfterExclamation => write!(

f,

"conversion type must come right after the exclamation mark"

),

Self::NewlineInFormatSpec => {

write!(

f,

"newlines are not allowed in format specifiers when using single quotes"

)

}

Self::ExpressionRequiredBefore(separator) => {

write!(f, "valid expression required before '{separator}'")

}

Self::ExpectedExpressionAfterLbrace => {

f.write_str("expecting a valid expression after '{'")

}

Self::ExpectedSeparatorAfterExpression => {

f.write_str("expecting '=', or '!', or ':', or '}'")

}

Self::ExpectedSeparatorAfterDebug => f.write_str("expecting '!', or ':', or '}'"),

Self::ExpectedSeparatorAfterConversion => f.write_str("expecting ':' or '}'"),

Self::UnclosedFormatSpec => f.write_str("expecting '}', or format specs"),

Self::MissingConversionFlag => f.write_str("missing conversion character"),

Self::UnmatchedBracket(closing) => write!(f, "unmatched '{closing}'"),

}

}

f: &mut std::fmt::Formatter,

kind: InterpolatedStringKind,

error: &InterpolatedStringErrorType,

) -> std::fmt::Result {

match error {

InterpolatedStringErrorType::UnterminatedString { detected_line } => {

write!(

f,

"unterminated {kind} literal (detected at line {detected_line})"

)

}

InterpolatedStringErrorType::UnterminatedTripleQuotedString { detected_line } => {

write!(

f,

"unterminated triple-quoted {kind} literal (detected at line {detected_line})"

)

}

InterpolatedStringErrorType::NewlineInFormatSpec => write!(

f,

"{kind}: newlines are not allowed in format specifiers for single quoted {kind}s"

),

_ => write!(f, "{kind}: {error}"),

}

/// An unexpected error occurred.

OtherError(String),

/// A missing-comma hint whose concatenated literal is displayed on its final line.

/// The original expression range controls error precedence; `diagnostic_start` can be

/// after the displayed range's end, which a `TextRange` cannot represent.

MissingCommaAfterConcatenatedLiteral {

expression_range: TextRange,

diagnostic_start: TextSize,

},

/// An error specific to stringified annotations occurred.

StringAnnotationError(&'static str),

/// A `raise from` statement has no exception expression.

MissingRaiseException,

/// A `raise` statement ends immediately after `from`.

MissingRaiseCause,

/// An unparenthesized `with` item list ends with a comma.

TrailingCommaInWith,

/// `lazy` follows the module name instead of preceding `from`.

MisplacedLazyImport,

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

EmptySlice,

/// An empty global names list was found during parsing.

EmptyGlobalNames,

/// An empty nonlocal names list was found during parsing.

EmptyNonlocalNames,

/// An empty delete targets list was found during parsing.

EmptyDeleteTargets,

/// An empty import names list was found during parsing.

EmptyImportNames,

/// An empty type parameter list was found during parsing.

EmptyTypeParams,

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

UnparenthesizedNamedExpression,

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

UnparenthesizedTupleExpression,

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

UnparenthesizedGeneratorExpression,

/// An invalid usage of a lambda expression was found.

InvalidLambdaExpressionUsage,

/// An invalid usage of a yield expression was found.

InvalidYieldExpressionUsage,

/// An invalid usage of a starred expression was found.

InvalidStarredExpressionUsage,

/// An unpacked conditional expression is missing parentheses.

InvalidConditionalUnpacking { double_starred: bool },

/// Only the else branch of a conditional expression is unpacked.

InvalidConditionalBranchUnpacking { double_starred: bool },

/// Dictionary unpacking is used in a list or generator comprehension.

InvalidComprehensionDictUnpacking { generator: bool },

/// An unpacked expression is used as a dictionary key.

InvalidDictKeyUnpacking { double_starred: bool },

/// An unpacked expression is used as a dictionary value.

InvalidDictValueUnpacking { double_starred: bool },

/// Dictionary unpacking is used outside a dictionary or call argument.

InvalidDictUnpacking,

/// A star pattern was found outside a sequence pattern.

InvalidStarPatternUsage,

/// An underscore was used as a binding target in a match pattern.

InvalidMatchPatternTarget,

/// A complete case clause was found outside a match statement.

CaseOutsideMatch,

/// A parameter was found after a vararg.

ParamAfterVarKeywordParam,

/// A non-default parameter follows a default parameter.

NonDefaultParamAfterDefaultParam,

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

VarParameterWithDefault,

/// A default value was found for a `**` parameter.

VarKeywordParameterWithDefault,

/// A dictionary key after the first item is not followed by a `:`. The error range is the

/// last character of the key.

ExpectedColonAfterDictionaryKey,

/// An invalid expression was found in the assignment target. `maybe_comparison` is set when

/// the `=` after it may have been meant as `==`.

InvalidAssignmentTarget {

kind: ExpressionKind,

maybe_comparison: bool,

},

/// A named expression is used in an assertion without its required parentheses.

NamedExpressionWithoutParentheses,

/// A mapping pattern contains an entry after its double-star rest pattern.

MappingRestPatternNotLast,

/// A name is assigned to where `==` or `:=` may have been meant.

AssignmentInsteadOfComparison,

/// A `yield` expression is assigned to.

AssignmentToYield,

/// An invalid expression was found in the named assignment target.

InvalidNamedAssignmentTarget(ExpressionKind),

/// An invalid expression was found in the annotated assignment target.

InvalidAnnotatedAssignmentTarget,

/// An invalid expression was found in the augmented assignment target.

InvalidAugmentedAssignmentTarget(ExpressionKind),

/// An invalid expression was found in the delete target.

InvalidDeleteTarget(ExpressionKind),

/// An invalid expression was found after `as` in an import.

InvalidImportTarget(ExpressionKind),

/// An invalid expression was found after `as` in a pattern.

InvalidPatternTarget(ExpressionKind),

/// An invalid expression was found after `as` in an `except` or `except*` clause.

InvalidExceptTarget { kind: ExpressionKind, star: bool },

/// A positional argument was found after a keyword argument.

PositionalAfterKeywordArgument,

/// A positional argument was found after a keyword argument unpacking.

PositionalAfterKeywordUnpacking,

/// An iterable argument unpacking was found after keyword argument unpacking.

InvalidArgumentUnpackingOrder,

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

IterableUnpackingInComprehension,

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

SimpleStatementsOnSameLine,

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

SimpleAndCompoundStatementOnSameLine,

/// Expected one or more keyword parameter after `*` separator.

ExpectedKeywordParam,

/// Expected a real number for a complex literal pattern.

ExpectedRealNumber,

/// Expected an imaginary number for a complex literal pattern.

ExpectedImaginaryNumber,

/// Expected an expression at the current parser location.

ExpectedExpression,

/// Expected an identifier at the current parser location.

ExpectedIdentifier,

/// The parser expected a specific token that was not found.

ExpectedToken {

expected: TokenKind,

found: TokenKind,

},

/// A token that the grammar requires right after the preceding ones (a forced token, `&&`

/// in the PEG grammar) was not found.

ExpectedForcedToken {

expected: TokenKind,

found: TokenKind,

},

/// A compound statement header is not followed by an indented block. `line` is the line of

/// the header's keyword.

ExpectedIndentedBlock { clause: BlockClause, line: u32 },

/// An unexpected indentation was found during parsing.

UnexpectedIndentation,

/// The statement being parsed cannot be `async`.

UnexpectedTokenAfterAsync(TokenKind),

/// Ipython escape command was found

UnexpectedIpythonEscapeCommand,

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

UnexpectedExpressionToken,

/// An f-string error containing the [`InterpolatedStringErrorType`].

FStringError(InterpolatedStringErrorType),

/// A t-string error containing the [`InterpolatedStringErrorType`].

TStringError(InterpolatedStringErrorType),

/// Parser encountered an error during lexing.

Lexical(LexicalErrorType),

Attribute,

Subscript,

Starred,

Name,

List,

Tuple,

Lambda,

FunctionCall,

Expression,

GeneratorExpression,

YieldExpression,

AwaitExpression,

ListComprehension,

SetComprehension,

DictComprehension,

DictLiteral,

SetDisplay,

FStringExpression,

TStringExpression,

None,

False,

True,

Ellipsis,

Literal,

Comparison,

ConditionalExpression,

NamedExpression,

pub fn of(expr: &Expr) -> Self {

match expr {

Expr::Attribute(_) => Self::Attribute,

Expr::Subscript(_) => Self::Subscript,

Expr::Starred(_) => Self::Starred,

Expr::Name(_) => Self::Name,

Expr::List(_) => Self::List,

Expr::Tuple(_) => Self::Tuple,

Expr::Lambda(_) => Self::Lambda,

Expr::Call(_) => Self::FunctionCall,

Expr::BoolOp(_)

| Expr::BinOp(_)

| Expr::UnaryOp(_)

| Expr::Slice(_)

| Expr::IpyEscapeCommand(_) => Self::Expression,

Expr::Generator(_) => Self::GeneratorExpression,

Expr::Yield(_) | Expr::YieldFrom(_) => Self::YieldExpression,

Expr::Await(_) => Self::AwaitExpression,

Expr::ListComp(_) => Self::ListComprehension,

Expr::SetComp(_) => Self::SetComprehension,

Expr::DictComp(_) => Self::DictComprehension,

Expr::Dict(_) => Self::DictLiteral,

Expr::Set(_) => Self::SetDisplay,

Expr::FString(_) => Self::FStringExpression,

Expr::TString(_) => Self::TStringExpression,

Expr::NoneLiteral(_) => Self::None,

Expr::BooleanLiteral(literal) if literal.value => Self::True,

Expr::BooleanLiteral(_) => Self::False,

Expr::EllipsisLiteral(_) => Self::Ellipsis,

Expr::StringLiteral(_) | Expr::BytesLiteral(_) | Expr::NumberLiteral(_) => {

Self::Literal

}

Expr::Compare(_) => Self::Comparison,

Expr::If(_) => Self::ConditionalExpression,

Expr::Named(_) => Self::NamedExpression,

Expr::Constant(constant) => match constant.value {

ConstantValue::None => Self::None,

ConstantValue::Boolean(true) => Self::True,

ConstantValue::Boolean(false) => Self::False,

ConstantValue::Ellipsis => Self::Ellipsis,

_ => Self::Literal,

},

}

}

fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

f.write_str(match self {

Self::Attribute => "attribute",

Self::Subscript => "subscript",

Self::Starred => "starred",

Self::Name => "name",

Self::List => "list",

Self::Tuple => "tuple",

Self::Lambda => "lambda",

Self::FunctionCall => "function call",

Self::Expression => "expression",

Self::GeneratorExpression => "generator expression",

Self::YieldExpression => "yield expression",

Self::AwaitExpression => "await expression",

Self::ListComprehension => "list comprehension",

Self::SetComprehension => "set comprehension",

Self::DictComprehension => "dict comprehension",

Self::DictLiteral => "dict literal",

Self::SetDisplay => "set display",

Self::FStringExpression => "f-string expression",

Self::TStringExpression => "t-string expression",

Self::None => "None",

Self::False => "False",

Self::True => "True",

Self::Ellipsis => "ellipsis",

Self::Literal => "literal",

Self::Comparison => "comparison",

Self::ConditionalExpression => "conditional expression",

Self::NamedExpression => "named expression",

})

}

If,

Elif,

Else,

For,

With,

While,

Try,

Except,

ExceptStar,

Finally,

Match,

Case,

/// A standalone case uses the generic invalid-block diagnostic.

StandaloneCase,

Class,

FunctionDef,

fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

f.write_str(match self {

Self::If => "'if' statement",

Self::Elif => "'elif' statement",

Self::Else => "'else' statement",

Self::For => "'for' statement",

Self::With => "'with' statement",

Self::While => "'while' statement",

Self::Try => "'try' statement",

Self::Except => "'except' statement",

Self::ExceptStar => "'except*' statement",

Self::Finally => "'finally' statement",

Self::Match => "'match' statement",

Self::Case | Self::StandaloneCase => "'case' statement",

Self::Class => "class definition",

Self::FunctionDef => "function definition",

})

}

pub(crate) fn from_interpolated_string_error(

error: InterpolatedStringErrorType,

string_kind: InterpolatedStringKind,

) -> Self {

match string_kind {

InterpolatedStringKind::FString => Self::FStringError(error),

InterpolatedStringKind::TString => Self::TStringError(error),

}

}

fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

match self {

ParseErrorType::OtherError(msg) => f.write_str(msg),

ParseErrorType::MissingCommaAfterConcatenatedLiteral { .. } => {

f.write_str("invalid syntax. Perhaps you forgot a comma?")

}

ParseErrorType::ExpectedIndentedBlock {

clause: BlockClause::StandaloneCase,

..

} => f.write_str("expected an indented block"),

ParseErrorType::ExpectedIndentedBlock { clause, line } => {

write!(

f,

"expected an indented block after {clause} on line {line}"

)

}

ParseErrorType::StringAnnotationError(msg) => f.write_str(msg),

ParseErrorType::ExpectedToken { found, expected } => match (*expected, *found) {

(TokenKind::Colon, TokenKind::Newline) => f.write_str("expected ':'"),

(TokenKind::Lpar, _) => f.write_str("expected '('"),

(TokenKind::Else, found) if found != TokenKind::Colon => {

f.write_str("expected 'else' after 'if' expression")

}

_ => f.write_str("invalid syntax"),

},

ParseErrorType::ExpectedForcedToken { expected, .. } => match expected {

TokenKind::Colon => f.write_str("expected ':'"),

TokenKind::Lpar => f.write_str("expected '('"),

expected => write!(f, "expected {expected}"),

},

ParseErrorType::Lexical(lex_error) => write!(f, "{lex_error}"),

ParseErrorType::SimpleStatementsOnSameLine => f.write_str("invalid syntax"),

ParseErrorType::SimpleAndCompoundStatementOnSameLine => f.write_str("invalid syntax"),

ParseErrorType::UnexpectedTokenAfterAsync(_) => f.write_str("invalid syntax"),

ParseErrorType::InvalidArgumentUnpackingOrder => {

f.write_str("iterable argument unpacking follows keyword argument unpacking")

}

ParseErrorType::IterableUnpackingInComprehension => {

f.write_str("iterable unpacking cannot be used in a comprehension")

}

ParseErrorType::UnparenthesizedNamedExpression => {

f.write_str("unparenthesized named expression cannot be used here")

}

ParseErrorType::UnparenthesizedTupleExpression => {

f.write_str("unparenthesized tuple expression cannot be used here")

}

ParseErrorType::UnparenthesizedGeneratorExpression => {

f.write_str("Generator expression must be parenthesized")

}

ParseErrorType::InvalidYieldExpressionUsage => {

f.write_str("yield expression cannot be used here")

}

ParseErrorType::InvalidLambdaExpressionUsage => {

f.write_str("lambda expression cannot be used here")

}

ParseErrorType::InvalidConditionalUnpacking { double_starred } => {

let kind = if *double_starred {

"double starred"

} else {

"starred"

};

write!(

f,

"invalid {kind} expression. Did you forget to wrap the conditional expression in parentheses?"

)

}

ParseErrorType::InvalidConditionalBranchUnpacking { double_starred } => {

if *double_starred {

f.write_str(

"cannot use dict unpacking on only part of a conditional expression",

)

} else {

f.write_str("cannot unpack only part of a conditional expression")

}

}

ParseErrorType::InvalidComprehensionDictUnpacking { generator } => {

let kind = if *generator {

"generator expression"

} else {

"list comprehension"

};

write!(f, "cannot use dict unpacking in {kind}")

}

ParseErrorType::InvalidDictKeyUnpacking { double_starred }

| ParseErrorType::InvalidDictValueUnpacking { double_starred } => {

let kind = if *double_starred {

"dict unpacking"

} else {

"a starred expression"

};

let position = if matches!(self, ParseErrorType::InvalidDictKeyUnpacking { .. }) {

"key"

} else {

"value"

};

write!(f, "cannot use {kind} in a dictionary {position}")

}

ParseErrorType::InvalidDictUnpacking => f.write_str("cannot use dict unpacking here"),

ParseErrorType::InvalidStarredExpressionUsage => f.write_str("invalid syntax"),

ParseErrorType::PositionalAfterKeywordArgument => {

f.write_str("positional argument follows keyword argument")

}

ParseErrorType::PositionalAfterKeywordUnpacking => {

f.write_str("positional argument follows keyword argument unpacking")

}

ParseErrorType::MissingRaiseException => {

f.write_str("did you forget an expression between 'raise' and 'from'?")

}

ParseErrorType::MissingRaiseCause => {

f.write_str("did you forget an expression after 'from'?")

}

ParseErrorType::TrailingCommaInWith => {

f.write_str("the last 'with' item has a trailing comma")

}

ParseErrorType::MisplacedLazyImport => {

f.write_str("use 'lazy from ... ' instead of 'from ... lazy import'")

}

ParseErrorType::EmptySlice => f.write_str("expected index or slice expression"),

ParseErrorType::EmptyGlobalNames

| ParseErrorType::EmptyNonlocalNames

| ParseErrorType::EmptyDeleteTargets => f.write_str("invalid syntax"),

ParseErrorType::EmptyImportNames => {

f.write_str("Expected one or more names after 'import'")

}

ParseErrorType::EmptyTypeParams => f.write_str("Type parameter list cannot be empty"),

ParseErrorType::ParamAfterVarKeywordParam => {

f.write_str("parameters cannot follow var-keyword parameter")

}

ParseErrorType::NonDefaultParamAfterDefaultParam => {

f.write_str("parameter without a default follows parameter with a default")

}

ParseErrorType::ExpectedKeywordParam => {

f.write_str("named parameters must follow bare *")

}

ParseErrorType::VarKeywordParameterWithDefault => {

f.write_str("var-keyword parameter cannot have default value")

}

ParseErrorType::ExpectedColonAfterDictionaryKey => {

f.write_str("':' expected after dictionary key")

}

ParseErrorType::VarParameterWithDefault => {

f.write_str("var-positional parameter cannot have default value")

}

ParseErrorType::InvalidStarPatternUsage => {

f.write_str("cannot use starred expression here")

}

ParseErrorType::InvalidMatchPatternTarget => f.write_str("cannot use '_' as a target"),

ParseErrorType::CaseOutsideMatch => {

f.write_str("case statement must be inside match statement")

}

ParseErrorType::ExpectedRealNumber => {

f.write_str("expected a real number in complex literal pattern")

}

ParseErrorType::ExpectedImaginaryNumber => {

f.write_str("expected an imaginary number in complex literal pattern")

}

ParseErrorType::ExpectedExpression | ParseErrorType::ExpectedIdentifier => {

f.write_str("invalid syntax")

}

ParseErrorType::UnexpectedIndentation => f.write_str("unexpected indent"),

ParseErrorType::InvalidAssignmentTarget {

kind,

maybe_comparison: false,

} => write!(f, "cannot assign to {kind}"),

ParseErrorType::InvalidAssignmentTarget {

kind,

maybe_comparison: true,

} => write!(

f,

"cannot assign to {kind} here. Maybe you meant '==' instead of '='?"

),

ParseErrorType::NamedExpressionWithoutParentheses => {

f.write_str("cannot use named expression without parentheses here")

}

ParseErrorType::MappingRestPatternNotLast => f.write_str(

"double star pattern must be the last (right-most) subpattern in the mapping pattern",

),

ParseErrorType::AssignmentInsteadOfComparison => {

f.write_str("invalid syntax. Maybe you meant '==' or ':=' instead of '='?")

}

ParseErrorType::AssignmentToYield => {

f.write_str("assignment to yield expression not possible")

}

ParseErrorType::InvalidAnnotatedAssignmentTarget => {

f.write_str("illegal target for annotation")

}

ParseErrorType::InvalidNamedAssignmentTarget(kind) => {

write!(f, "cannot use assignment expressions with {kind}")

}

ParseErrorType::InvalidAugmentedAssignmentTarget(kind) => {

write!(

f,

"'{kind}' is an illegal expression for augmented assignment"

)

}

ParseErrorType::InvalidDeleteTarget(kind) => write!(f, "cannot delete {kind}"),

ParseErrorType::InvalidImportTarget(kind) => {

write!(f, "cannot use {kind} as import target")

}

ParseErrorType::InvalidPatternTarget(kind) => {

write!(f, "cannot use {kind} as pattern target")

}

ParseErrorType::InvalidExceptTarget { kind, star } => {

let clause = if *star { "except*" } else { "except" };

write!(f, "cannot use {clause} statement with {kind}")

}

ParseErrorType::UnexpectedIpythonEscapeCommand => {

f.write_str("IPython escape commands are only allowed in `Mode::Ipython`")

}

ParseErrorType::FStringError(error) => {

write_interpolated_string_error(f, InterpolatedStringKind::FString, error)

}

ParseErrorType::TStringError(error) => {

write_interpolated_string_error(f, InterpolatedStringKind::TString, error)

}

ParseErrorType::UnexpectedExpressionToken => f.write_str("invalid syntax"),

}

}

/// The type of error that occurred.

error: LexicalErrorType,

/// The location of the error.

location: TextRange,

/// Creates a new `LexicalError` with the given error type and location.

pub fn new(error: LexicalErrorType, location: TextRange) -> Self {

Self { error, location }

}

pub fn error(&self) -> &LexicalErrorType {

&self.error

}

pub fn into_error(self) -> LexicalErrorType {

self.error

}

pub fn location(&self) -> TextRange {

self.location

}

type Target = LexicalErrorType;

fn deref(&self) -> &Self::Target {

self.error()

}

fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {

Some(self.error())

}

fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

write!(

f,

"{} at byte offset {}",

self.error(),

u32::from(self.location().start())

)

}

// TODO: Can probably be removed, the places it is used seem to be able

// to use the `UnicodeError` variant instead.

#[doc(hidden)]

StringError,

/// A string literal without the closing quote, detected at the given one-based line.

UnclosedStringError {

triple_quoted: bool,

/// The literal contains a backslash followed by its quote character.

escaped_end_quote: bool,

detected_line: u32,

},

/// The interpreter could not load the Unicode name provider for a `\N` escape.

UnicodeNameProviderUnavailable,

/// A format-spec decoder failure propagates its original exception, not `SyntaxError`.

FormatSpecDecodeError(Box<LexicalErrorType>),

/// An escape sequence in a string literal cannot be decoded. `start` and `end` are the

/// inclusive positions of the escape sequence in the string content, where a non-ASCII

/// character counts as its ten-character `\U` escape.

UnicodeEscapeError {

kind: UnicodeEscapeErrorKind,

start: u32,

end: u32,

},

/// A `\x` escape in a bytes literal at the given position of its content is not followed by

/// two hexadecimal digits.

BytesEscapeError { position: u32 },

/// A dedent does not match any outer indentation level.

IndentationError,

/// Tabs and spaces are mixed in a way that makes the indentation depend on the tab size.

TabError,

/// The indentation is nested too deeply.

TooDeepIndentation,

/// An unrecognized token was encountered.

UnrecognizedToken { tok: char },

/// An f-string error containing the [`InterpolatedStringErrorType`].

FStringError(InterpolatedStringErrorType),

/// A t-string error containing the [`InterpolatedStringErrorType`].

TStringError(InterpolatedStringErrorType),

/// Invalid character encountered in a byte literal.

InvalidByteLiteral,

/// An unexpected character was encountered after a line continuation.

LineContinuationError,

/// An unexpected end of file was encountered.

Eof,

/// A closing bracket without an opening bracket.

UnmatchedBracket { closing: char },

/// A closing bracket that does not match the innermost opening bracket. `opening_line` is the

/// line of the opening bracket if it is on another line.

MismatchedBracket {

closing: char,

opening: char,

opening_line: Option<u32>,

},

/// An opening bracket that is not closed by the end of the source.

///

/// `incomplete` is whether more input could still close it: the parser read to the end of the

/// source with the bracket open. Otherwise, the error is reported in place of an earlier syntax

/// error.

UnclosedBracket { opening: char, incomplete: bool },

/// Brackets are nested too deeply.

TooDeeplyNestedBrackets,

/// A malformed number literal, or one directly followed by a name.

InvalidNumberLiteral { kind: NumberLiteralKind },

/// A digit that is not valid in the octal or binary literal it appears in.

InvalidDigit {

digit: char,

kind: NumberLiteralKind,

},

/// A decimal integer literal with leading zeros.

LeadingZerosInDecimalInteger,

/// A string prefix that combines incompatible prefixes, such as `ub`.

IncompatibleStringPrefixes { first: char, second: char },

/// An unexpected error occurred.

OtherError(Box<str>),

Decimal,

Hexadecimal,

Octal,

Binary,

Imaginary,

fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {

f.write_str(match self {

Self::Decimal => "decimal",

Self::Hexadecimal => "hexadecimal",

Self::Octal => "octal",

Self::Binary => "binary",

Self::Imaginary => "imaginary",

})

}

use icu_properties::props::{EnumeratedProperty, GeneralCategory};

c == ' '

|| !matches!(

GeneralCategory::for_char(c),

GeneralCategory::SpaceSeparator

| GeneralCategory::LineSeparator

| GeneralCategory::ParagraphSeparator

| GeneralCategory::Control

| GeneralCategory::Format

| GeneralCategory::Surrogate

| GeneralCategory::PrivateUse

| GeneralCategory::Unassigned

)

/// Returns `true` if the error reports a string literal without its closing quotes.

pub(crate) fn is_unclosed_string_error(&self) -> bool {

matches!(

self,

Self::UnclosedStringError { .. }

| Self::FStringError(

InterpolatedStringErrorType::UnclosedLbrace

| InterpolatedStringErrorType::UnclosedLbraceOnLine { .. }

)

| Self::TStringError(

InterpolatedStringErrorType::UnclosedLbrace

| InterpolatedStringErrorType::UnclosedLbraceOnLine { .. }

)

)

}

/// Returns `true` if the error stops tokenization, as opposed to an error found while

/// decoding the content of a token.

pub fn is_tokenizer_error(&self) -> bool {

match self {

Self::StringError

| Self::FormatSpecDecodeError(_)

| Self::UnicodeNameProviderUnavailable

| Self::UnicodeEscapeError { .. }

| Self::BytesEscapeError { .. }

| Self::InvalidByteLiteral

| Self::OtherError(_) => false,

// An ASCII punctuation character is a token that the parser rejects.

Self::UnrecognizedToken { tok } => !tok.is_ascii() || !is_printable(*tok),

Self::FStringError(error) | Self::TStringError(error) => matches!(

error,

InterpolatedStringErrorType::UnterminatedString { .. }

| InterpolatedStringErrorType::UnterminatedTripleQuotedString { .. }

| InterpolatedStringErrorType::SingleRbrace

| InterpolatedStringErrorType::NewlineInFormatSpec

| InterpolatedStringErrorType::UnclosedLbrace

| InterpolatedStringErrorType::UnclosedLbraceOnLine { .. }

| InterpolatedStringErrorType::UnmatchedBracket(_)

),

Self::UnclosedStringError { .. }

| Self::IndentationError

| Self::TabError

| Self::TooDeepIndentation

| Self::LineContinuationError

| Self::Eof

| Self::UnmatchedBracket { .. }

| Self::MismatchedBracket { .. }

| Self::UnclosedBracket { .. }

| Self::TooDeeplyNestedBrackets

| Self::InvalidNumberLiteral { .. }

| Self::InvalidDigit { .. }

| Self::LeadingZerosInDecimalInteger

| Self::IncompatibleStringPrefixes { .. } => true,

}

}