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>>

Object Safety§

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§