pub trait Parsewhere
    Self: Sized,{
    // Required methods
    fn lex_starts_at(
        source: &str,
        offset: TextSize
    ) -> SoftKeywordTransformer<Lexer<Chars<'_>>>;
    fn parse_tokens(
        lxr: impl IntoIterator<Item = LexResult>,
        source_path: &str
    ) -> Result<Self, ParseError>;

    // Provided methods
    fn parse(source: &str, source_path: &str) -> Result<Self, ParseError> { ... }
    fn parse_without_path(source: &str) -> Result<Self, ParseError> { ... }
    fn parse_starts_at(
        source: &str,
        source_path: &str,
        offset: TextSize
    ) -> Result<Self, ParseError> { ... }
}
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 = LexResult>, source_path: &str ) -> Result<Self, ParseError>

Provided Methods§

source

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

source

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

source

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

Implementations on Foreign Types§

§

impl Parse for StmtWith

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtIf

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprCompare

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

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 = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprListComp

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprDict

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtExpr

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtFunctionDef

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtClassDef

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtAsyncFor

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtAnnAssign

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtTry

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtWhile

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtFor

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprIfExp

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprYield

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprBinOp

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtMatch

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

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 = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtAsyncFunctionDef

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprNamedExpr

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtTryStar

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprList

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprTuple

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtAugAssign

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprFormattedValue

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

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 = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprSubscript

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprJoinedStr

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

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 = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtImport

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtReturn

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtAssign

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtRaise

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprStarred

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

source§

impl Parse for Suite

source§

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

source§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

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 = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprSlice

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

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 = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtTypeAlias

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtBreak

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprName

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtImportFrom

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprYieldFrom

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtAsyncWith

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprUnaryOp

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtAssert

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprBoolOp

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtGlobal

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprGeneratorExp

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtNonlocal

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtPass

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtContinue

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprSet

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprCall

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for StmtDelete

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprLambda

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprSetComp

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

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 = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprDictComp

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprAttribute

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprAwait

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

§

impl Parse for ExprConstant

§

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

§

fn parse_tokens( lxr: impl IntoIterator<Item = LexResult>, source_path: &str ) -> Result<Self, ParseError>

Implementors§