Trait Parse

Source
pub trait Parse: Sized {
    // Required methods
    fn lex_starts_at(
        source: &str,
        offset: TextSize,
    ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>;
    fn parse_tokens(
        lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>,
        source_path: &str,
    ) -> Result<Self, BaseError<ParseErrorType>>;

    // Provided methods
    fn parse(
        source: &str,
        source_path: &str,
    ) -> Result<Self, BaseError<ParseErrorType>> { ... }
    fn parse_without_path(
        source: &str,
    ) -> Result<Self, BaseError<ParseErrorType>> { ... }
    fn parse_starts_at(
        source: &str,
        source_path: &str,
        offset: TextSize,
    ) -> Result<Self, BaseError<ParseErrorType>> { ... }
}
Expand description

Parse Python code string to implementor’s type.

§Example

For example, parsing a simple function definition and a call to that function:

use rustpython_parser::{self as parser, ast, Parse};
let source = r#"
def foo():
   return 42

print(foo())
"#;
let program = ast::Suite::parse(source, "<embedded>");
assert!(program.is_ok());

Parsing a single expression denoting the addition of two numbers, but this time specifying a different, somewhat silly, location:

use rustpython_parser::{self as parser, ast, Parse, text_size::TextSize};

let expr = ast::Expr::parse_starts_at("1 + 2", "<embedded>", TextSize::from(400));
assert!(expr.is_ok());

Required Methods§

Source

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<Self, BaseError<ParseErrorType>>

Provided Methods§

Source

fn parse( source: &str, source_path: &str, ) -> Result<Self, BaseError<ParseErrorType>>

Source

fn parse_without_path(source: &str) -> Result<Self, BaseError<ParseErrorType>>

Source

fn parse_starts_at( source: &str, source_path: &str, offset: TextSize, ) -> Result<Self, BaseError<ParseErrorType>>

Dyn Compatibility§

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types§

Source§

impl Parse for Constant

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<Constant, BaseError<ParseErrorType>>

Source§

impl Parse for Expr

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<Expr, BaseError<ParseErrorType>>

Source§

impl Parse for Stmt

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<Stmt, BaseError<ParseErrorType>>

Source§

impl Parse for Vec<Stmt>

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<Vec<Stmt>, BaseError<ParseErrorType>>

Source§

impl Parse for Identifier

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<Identifier, BaseError<ParseErrorType>>

Source§

impl Parse for ExprAttribute

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprAttribute, BaseError<ParseErrorType>>

Source§

impl Parse for ExprAwait

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprAwait, BaseError<ParseErrorType>>

Source§

impl Parse for ExprBinOp

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprBinOp, BaseError<ParseErrorType>>

Source§

impl Parse for ExprBoolOp

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprBoolOp, BaseError<ParseErrorType>>

Source§

impl Parse for ExprCall

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprCall, BaseError<ParseErrorType>>

Source§

impl Parse for ExprCompare

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprCompare, BaseError<ParseErrorType>>

Source§

impl Parse for ExprConstant

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprConstant, BaseError<ParseErrorType>>

Source§

impl Parse for ExprDict

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprDict, BaseError<ParseErrorType>>

Source§

impl Parse for ExprDictComp

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprDictComp, BaseError<ParseErrorType>>

Source§

impl Parse for ExprFormattedValue

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprFormattedValue, BaseError<ParseErrorType>>

Source§

impl Parse for ExprGeneratorExp

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprGeneratorExp, BaseError<ParseErrorType>>

Source§

impl Parse for ExprIfExp

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprIfExp, BaseError<ParseErrorType>>

Source§

impl Parse for ExprJoinedStr

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprJoinedStr, BaseError<ParseErrorType>>

Source§

impl Parse for ExprLambda

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprLambda, BaseError<ParseErrorType>>

Source§

impl Parse for ExprList

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprList, BaseError<ParseErrorType>>

Source§

impl Parse for ExprListComp

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprListComp, BaseError<ParseErrorType>>

Source§

impl Parse for ExprName

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprName, BaseError<ParseErrorType>>

Source§

impl Parse for ExprNamedExpr

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprNamedExpr, BaseError<ParseErrorType>>

Source§

impl Parse for ExprSet

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprSet, BaseError<ParseErrorType>>

Source§

impl Parse for ExprSetComp

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprSetComp, BaseError<ParseErrorType>>

Source§

impl Parse for ExprSlice

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprSlice, BaseError<ParseErrorType>>

Source§

impl Parse for ExprStarred

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprStarred, BaseError<ParseErrorType>>

Source§

impl Parse for ExprSubscript

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprSubscript, BaseError<ParseErrorType>>

Source§

impl Parse for ExprTuple

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprTuple, BaseError<ParseErrorType>>

Source§

impl Parse for ExprUnaryOp

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprUnaryOp, BaseError<ParseErrorType>>

Source§

impl Parse for ExprYield

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprYield, BaseError<ParseErrorType>>

Source§

impl Parse for ExprYieldFrom

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ExprYieldFrom, BaseError<ParseErrorType>>

Source§

impl Parse for ModExpression

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ModExpression, BaseError<ParseErrorType>>

Source§

impl Parse for ModInteractive

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ModInteractive, BaseError<ParseErrorType>>

Source§

impl Parse for ModModule

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<ModModule, BaseError<ParseErrorType>>

Source§

impl Parse for StmtAnnAssign

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtAnnAssign, BaseError<ParseErrorType>>

Source§

impl Parse for StmtAssert

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtAssert, BaseError<ParseErrorType>>

Source§

impl Parse for StmtAssign

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtAssign, BaseError<ParseErrorType>>

Source§

impl Parse for StmtAsyncFor

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtAsyncFor, BaseError<ParseErrorType>>

Source§

impl Parse for StmtAsyncFunctionDef

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtAsyncFunctionDef, BaseError<ParseErrorType>>

Source§

impl Parse for StmtAsyncWith

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtAsyncWith, BaseError<ParseErrorType>>

Source§

impl Parse for StmtAugAssign

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtAugAssign, BaseError<ParseErrorType>>

Source§

impl Parse for StmtBreak

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtBreak, BaseError<ParseErrorType>>

Source§

impl Parse for StmtClassDef

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtClassDef, BaseError<ParseErrorType>>

Source§

impl Parse for StmtContinue

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtContinue, BaseError<ParseErrorType>>

Source§

impl Parse for StmtDelete

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtDelete, BaseError<ParseErrorType>>

Source§

impl Parse for StmtExpr

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtExpr, BaseError<ParseErrorType>>

Source§

impl Parse for StmtFor

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtFor, BaseError<ParseErrorType>>

Source§

impl Parse for StmtFunctionDef

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtFunctionDef, BaseError<ParseErrorType>>

Source§

impl Parse for StmtGlobal

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtGlobal, BaseError<ParseErrorType>>

Source§

impl Parse for StmtIf

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtIf, BaseError<ParseErrorType>>

Source§

impl Parse for StmtImport

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtImport, BaseError<ParseErrorType>>

Source§

impl Parse for StmtImportFrom

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtImportFrom, BaseError<ParseErrorType>>

Source§

impl Parse for StmtMatch

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtMatch, BaseError<ParseErrorType>>

Source§

impl Parse for StmtNonlocal

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtNonlocal, BaseError<ParseErrorType>>

Source§

impl Parse for StmtPass

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtPass, BaseError<ParseErrorType>>

Source§

impl Parse for StmtRaise

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtRaise, BaseError<ParseErrorType>>

Source§

impl Parse for StmtReturn

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtReturn, BaseError<ParseErrorType>>

Source§

impl Parse for StmtTry

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtTry, BaseError<ParseErrorType>>

Source§

impl Parse for StmtTryStar

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtTryStar, BaseError<ParseErrorType>>

Source§

impl Parse for StmtTypeAlias

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtTypeAlias, BaseError<ParseErrorType>>

Source§

impl Parse for StmtWhile

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtWhile, BaseError<ParseErrorType>>

Source§

impl Parse for StmtWith

Source§

fn lex_starts_at( source: &str, offset: TextSize, ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>

Source§

fn parse_tokens( lxr: impl IntoIterator<Item = Result<(Tok, TextRange), LexicalError>>, source_path: &str, ) -> Result<StmtWith, BaseError<ParseErrorType>>

Implementors§