Struct Parser 

pub struct Parser<'sess, 'ast> {
    pub sess: &'sess Session,
    pub arena: &'ast Arena,
    pub token: Token,
    pub prev_token: Token,
    /* private fields */
}

Solidity and Yul parser.

Examples

use solar::{
    ast,
    interface::{Session, diagnostics::EmittedDiagnostics},
    parse::Parser,
};
use std::path::Path;

#[test]
fn main() -> Result<(), EmittedDiagnostics> {
    let path = Path::new("src/Counter.sol");

    // Create a new session with a buffer emitter.
    // This is required to capture the emitted diagnostics and to return them at the end.
    let sess = Session::builder().with_buffer_emitter(solar::interface::ColorChoice::Auto).build();

    // Enter the context and parse the file.
    let _ = sess.enter(|| -> solar::interface::Result<()> {
        // Set up the parser.
        let arena = ast::Arena::new();
        let mut parser = Parser::from_file(&sess, &arena, path)?;

        // Parse the file.
        let ast = parser.parse_file().map_err(|e| e.emit())?;
        println!("parsed {path:?}: {ast:#?}");
        Ok(())
    });

    // Return the emitted diagnostics as a `Result<(), _>`.
    // If any errors were emitted, this returns `Err(_)`, otherwise `Ok(())`.
    // Note that this discards warnings and other non-error diagnostics.
    sess.emitted_errors().unwrap()
}

Fields

sess: &'sess Session

The parser session.

arena: &'ast Arena

The arena where the AST nodes are allocated.

token: Token

The current token.

prev_token: Token

The previous token.

Implementations

impl<'sess, 'ast> Parser<'sess, 'ast>

pub fn parse_expr(&mut self) -> PResult<'sess, Box<'ast, Expr<'ast>>>

Parses an expression.

impl<'sess, 'ast> Parser<'sess, 'ast>

pub fn parse_file(&mut self) -> PResult<'sess, SourceUnit<'ast>>

Parses a source unit.

pub fn parse_item(&mut self) -> PResult<'sess, Option<Item<'ast>>>

Parses an item.

pub fn parse_semver_req(&mut self) -> PResult<'sess, SemverReq<'ast>>

Parses a SemVer version requirement.

See crates/ast/src/ast/semver.rs for more details on the implementation.

impl<'sess, 'ast> Parser<'sess, 'ast>

pub fn parse_lit( &mut self, with_subdenomination: bool, ) -> PResult<'sess, (Lit<'ast>, Option<SubDenomination>)>

Parses a literal with an optional subdenomination.

Note that the subdenomination gets applied to the literal directly, and is returned just for display reasons.

Returns None if no subdenomination was parsed or if the literal is not a number or rational.

pub fn parse_subdenomination(&mut self) -> Option<SubDenomination>

Parses a subdenomination.

impl<'sess, 'ast> Parser<'sess, 'ast>

pub fn parse_stmt(&mut self) -> PResult<'sess, Stmt<'ast>>

Parses a statement.

pub fn parse_stmt_boxed(&mut self) -> PResult<'sess, Box<'ast, Stmt<'ast>>>

Parses a statement into a new allocation.

impl<'sess, 'ast> Parser<'sess, 'ast>

pub fn parse_type(&mut self) -> PResult<'sess, Type<'ast>>

Parses a type.

impl<'sess, 'ast> Parser<'sess, 'ast>

pub fn parse_yul_file_object(&mut self) -> PResult<'sess, Object<'ast>>

Parses a Yul object or plain block.

The plain block gets returned as a Yul object named “object”, with a single code block. See: https://github.com/argotorg/solidity/blob/eff410eb746f202fe756a2473fd0c8a718348457/libyul/ObjectParser.cpp#L50

pub fn parse_yul_object( &mut self, docs: DocComments<'ast>, ) -> PResult<'sess, Object<'ast>>

Parses a Yul object.

Reference: https://docs.soliditylang.org/en/latest/yul.html#specification-of-yul-object

pub fn parse_yul_stmt(&mut self) -> PResult<'sess, Stmt<'ast>>

Parses a Yul statement.

pub fn parse_yul_stmt_unchecked(&mut self) -> PResult<'sess, Stmt<'ast>>

Parses a Yul statement, without setting in_yul.

pub fn parse_yul_block(&mut self) -> PResult<'sess, Block<'ast>>

Parses a Yul block.

pub fn parse_yul_block_unchecked(&mut self) -> PResult<'sess, Block<'ast>>

Parses a Yul block, without setting in_yul.

impl<'sess, 'ast> Parser<'sess, 'ast>

pub fn new(sess: &'sess Session, arena: &'ast Arena, tokens: Vec<Token>) -> Self

Creates a new parser.

pub fn from_source_code( sess: &'sess Session, arena: &'ast Arena, filename: FileName, src: impl Into<String>, ) -> Result<Self>

Creates a new parser from a source code string.

pub fn from_file( sess: &'sess Session, arena: &'ast Arena, path: &Path, ) -> Result<Self>

Creates a new parser from a file.

The file will not be read if it has already been added into the source map.

pub fn from_lazy_source_code( sess: &'sess Session, arena: &'ast Arena, filename: FileName, get_src: impl FnOnce() -> Result<String>, ) -> Result<Self>

Creates a new parser from a source code closure.

The closure will not be called if the file name has already been added into the source map.

pub fn from_source_file( sess: &'sess Session, arena: &'ast Arena, file: &SourceFile, ) -> Self

Creates a new parser from a source file.

Note that the source file must be added to the source map before calling this function. Prefer using from_source_code or from_file instead.

pub fn from_lexer(arena: &'ast Arena, lexer: Lexer<'sess, '_>) -> Self

Creates a new parser from a lexer.

pub fn dcx(&self) -> &'sess DiagCtxt

Returns the diagnostic context.

pub fn alloc<T>(&self, value: T) -> Box<'ast, T>

Allocates an object on the AST arena.

pub fn alloc_path(&self, segments: &[Ident]) -> AstPath<'ast>

Allocates a list of objects on the AST arena.

Panics

Panics if the list is empty.

pub fn alloc_vec<T>(&self, values: Vec<T>) -> BoxSlice<'ast, T>

Allocates a list of objects on the AST arena.

pub fn alloc_smallvec<A: Array>( &self, values: SmallVec<A>, ) -> BoxSlice<'ast, A::Item>

Allocates a list of objects on the AST arena.

pub fn unexpected<T>(&mut self) -> PResult<'sess, T>

Returns an “unexpected token” error in a PResult for the current token.

pub fn unexpected_error(&mut self) -> PErr<'sess>

Returns an “unexpected token” error for the current token.

pub fn expect(&mut self, tok: TokenKind) -> PResult<'sess, Recovered>

Expects and consumes the token t. Signals an error if the next token is not t.

pub fn expect_one_of( &mut self, edible: &[TokenKind], inedible: &[TokenKind], ) -> PResult<'sess, Recovered>

Expect next token to be edible or inedible token. If edible, then consume it; if inedible, then return without consuming anything. Signal a fatal error if next token is unexpected.

pub fn eat_noexpect(&mut self, tok: TokenKind) -> bool

Consumes a token ‘tok’ if it exists. Returns whether the given token was present.

the main purpose of this function is to reduce the cluttering of the suggestions list which using the normal eat method could introduce in some cases.

pub fn eat(&mut self, tok: TokenKind) -> bool

Consumes a token ‘tok’ if it exists. Returns whether the given token was present.

pub fn eat_keyword(&mut self, kw: Symbol) -> bool

If the next token is the given keyword, eats it and returns true. Otherwise, returns false. An expectation is also added for diagnostics purposes.

pub fn bump(&mut self)

Advance the parser by one token.

pub fn bump_with(&mut self, next: Token)

Advance the parser by one token using provided token as the next one.

Panics

Panics if the provided token is a comment.

pub fn look_ahead(&self, dist: usize) -> Token

Returns the token dist tokens ahead of the current one.

Eof will be returned if the look-ahead is any distance past the end of the tokens.

pub fn look_ahead_with<R>(&self, dist: usize, f: impl FnOnce(Token) -> R) -> R

Calls f with the token dist tokens ahead of the current one.

See look_ahead for more information.

pub fn with_recursion_limit<T>( &mut self, context: &str, f: impl FnOnce(&mut Self) -> PResult<'sess, T>, ) -> PResult<'sess, T>

Runs f with recursion depth tracking and limit enforcement.

impl<'sess, 'ast> Parser<'sess, 'ast>

Common parsing methods.

pub fn parse_spanned<T>( &mut self, f: impl FnOnce(&mut Self) -> PResult<'sess, T>, ) -> PResult<'sess, (Span, T)>

Provides a spanned parser.

pub fn parse_doc_comments(&mut self) -> DocComments<'ast>

Parses contiguous doc comments. Can be empty.

pub fn parse_path(&mut self) -> PResult<'sess, AstPath<'ast>>

Parses a qualified identifier: foo.bar.baz.

pub fn parse_path_with(&mut self, first: Ident) -> PResult<'sess, AstPath<'ast>>

Parses a qualified identifier starting with the given identifier.

pub fn parse_path_any(&mut self) -> PResult<'sess, AstPath<'ast>>

Parses a qualified identifier: foo.bar.baz.

pub fn parse_ident(&mut self) -> PResult<'sess, Ident>

Parses an identifier.

pub fn parse_ident_any(&mut self) -> PResult<'sess, Ident>

Parses an identifier. Does not check if the identifier is a reserved keyword.

pub fn parse_ident_opt(&mut self) -> PResult<'sess, Option<Ident>>

Parses an optional identifier.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 100 bytes