Struct Parser

pub struct Parser {
    comments: Vec<Comment>,
    context: ParserContext,
    items: Vec<ParseItem>,
    source: String,
    fmt: FormatterConfig,
}

The documentation parser. This type implements a [Visitor] trait.

While walking the parse tree, Parser will collect relevant source items and corresponding doc comments. The resulting ParseItems can be accessed by calling Parser::items.

Fields

comments: Vec<Comment>

Initial comments from solang parser.

context: ParserContext

Parser context.

items: Vec<ParseItem>

Parsed results.

source: String

Source file.

fmt: FormatterConfig

The formatter config.

Implementations

impl Parser

pub fn new(comments: Vec<SolangComment>, source: String) -> Self

Create a new instance of Parser.

pub fn with_fmt(self, fmt: FormatterConfig) -> Self

Set formatter config on the Parser

pub fn items(self) -> Vec<ParseItem>

Return the parsed items. Consumes the parser.

fn with_parent( &mut self, parent: ParseItem, visit: impl FnMut(&mut Self) -> ParserResult<()>, ) -> ParserResult<ParseItem>

Visit the children elements with parent context. This function memoizes the previous parent, sets the context to a new one and invokes a visit function. The context will be reset to the previous parent at the end of the function.

fn add_element_to_parent( &mut self, source: ParseSource, loc: Loc, ) -> ParserResult<()>

Adds a child element to the parent item if it exists. Otherwise the element will be added to a top-level items collection. Moves the doc comment pointer to the end location of the child element.

fn new_item( &mut self, source: ParseSource, loc_start: usize, ) -> ParserResult<ParseItem>

Create new ParseItem with comments and formatted code.

fn parse_docs(&mut self, end: usize) -> ParserResult<Comments>

Parse the doc comments from the current start location.

fn parse_docs_range( &mut self, start: usize, end: usize, ) -> ParserResult<Comments>

Parse doc comments from the within specified range.

Trait Implementations

impl Debug for Parser

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

Formats the value using the given formatter.

impl Default for Parser

fn default() -> Parser

Returns the “default value” for a type.

impl Visitor for Parser

type Error = ParserError

fn visit_source_unit( &mut self, source_unit: &mut SourceUnit, ) -> ParserResult<()>

fn visit_enum(&mut self, enumerable: &mut EnumDefinition) -> ParserResult<()>

fn visit_var_definition( &mut self, var: &mut VariableDefinition, ) -> ParserResult<()>

fn visit_function(&mut self, func: &mut FunctionDefinition) -> ParserResult<()>

fn visit_struct(&mut self, structure: &mut StructDefinition) -> ParserResult<()>

fn visit_event(&mut self, event: &mut EventDefinition) -> ParserResult<()>

fn visit_error(&mut self, error: &mut ErrorDefinition) -> ParserResult<()>

fn visit_type_definition( &mut self, def: &mut TypeDefinition, ) -> ParserResult<()>

fn visit_source(&mut self, _loc: Loc) -> Result<(), Self::Error>

fn visit_contract( &mut self, _contract: &mut ContractDefinition, ) -> Result<(), Self::Error>

fn visit_annotation( &mut self, annotation: &mut Annotation, ) -> Result<(), Self::Error>

fn visit_pragma( &mut self, loc: Loc, _ident: &mut Option<Identifier>, _str: &mut Option<StringLiteral>, ) -> Result<(), Self::Error>

fn visit_import_plain( &mut self, _loc: Loc, _import: &mut ImportPath, ) -> Result<(), Self::Error>

fn visit_import_global( &mut self, _loc: Loc, _global: &mut ImportPath, _alias: &mut Identifier, ) -> Result<(), Self::Error>

fn visit_import_renames( &mut self, _loc: Loc, _imports: &mut [(Identifier, Option<Identifier>)], _from: &mut ImportPath, ) -> Result<(), Self::Error>

fn visit_assembly( &mut self, loc: Loc, _dialect: &mut Option<StringLiteral>, _block: &mut YulBlock, _flags: &mut Option<Vec<StringLiteral>>, ) -> Result<(), Self::Error>

fn visit_block( &mut self, loc: Loc, _unchecked: bool, _statements: &mut Vec<Statement>, ) -> Result<(), Self::Error>

fn visit_args( &mut self, loc: Loc, _args: &mut Vec<NamedArgument>, ) -> Result<(), Self::Error>

fn visit_expr( &mut self, loc: Loc, _expr: &mut Expression, ) -> Result<(), Self::Error>

Don’t write semicolon at the end because expressions can appear as both part of other node and a statement in the function body

fn visit_ident( &mut self, loc: Loc, _ident: &mut Identifier, ) -> Result<(), Self::Error>

fn visit_ident_path( &mut self, idents: &mut IdentifierPath, ) -> Result<(), Self::Error>

fn visit_emit( &mut self, loc: Loc, _event: &mut Expression, ) -> Result<(), Self::Error>

fn visit_var_definition_stmt( &mut self, loc: Loc, _declaration: &mut VariableDeclaration, _expr: &mut Option<Expression>, ) -> Result<(), Self::Error>

fn visit_var_declaration( &mut self, var: &mut VariableDeclaration, ) -> Result<(), Self::Error>

fn visit_return( &mut self, loc: Loc, _expr: &mut Option<Expression>, ) -> Result<(), Self::Error>

fn visit_revert( &mut self, loc: Loc, _error: &mut Option<IdentifierPath>, _args: &mut Vec<Expression>, ) -> Result<(), Self::Error>

fn visit_revert_named_args( &mut self, loc: Loc, _error: &mut Option<IdentifierPath>, _args: &mut Vec<NamedArgument>, ) -> Result<(), Self::Error>

fn visit_break(&mut self, loc: Loc, _semicolon: bool) -> Result<(), Self::Error>

fn visit_continue( &mut self, loc: Loc, _semicolon: bool, ) -> Result<(), Self::Error>

fn visit_try( &mut self, loc: Loc, _expr: &mut Expression, _returns: &mut Option<(Vec<(Loc, Option<Parameter>)>, Box<Statement>)>, _clauses: &mut Vec<CatchClause>, ) -> Result<(), Self::Error>

fn visit_if( &mut self, loc: Loc, _cond: &mut Expression, _if_branch: &mut Box<Statement>, _else_branch: &mut Option<Box<Statement>>, _is_first_stmt: bool, ) -> Result<(), Self::Error>

fn visit_do_while( &mut self, loc: Loc, _body: &mut Statement, _cond: &mut Expression, ) -> Result<(), Self::Error>

fn visit_while( &mut self, loc: Loc, _cond: &mut Expression, _body: &mut Statement, ) -> Result<(), Self::Error>

fn visit_for( &mut self, loc: Loc, _init: &mut Option<Box<Statement>>, _cond: &mut Option<Box<Expression>>, _update: &mut Option<Box<Expression>>, _body: &mut Option<Box<Statement>>, ) -> Result<(), Self::Error>

fn visit_function_attribute( &mut self, attribute: &mut FunctionAttribute, ) -> Result<(), Self::Error>

fn visit_var_attribute( &mut self, attribute: &mut VariableAttribute, ) -> Result<(), Self::Error>

fn visit_base(&mut self, base: &mut Base) -> Result<(), Self::Error>

fn visit_parameter( &mut self, parameter: &mut Parameter, ) -> Result<(), Self::Error>

fn visit_event_parameter( &mut self, param: &mut EventParameter, ) -> Result<(), Self::Error>

fn visit_error_parameter( &mut self, param: &mut ErrorParameter, ) -> Result<(), Self::Error>

fn visit_stray_semicolon(&mut self) -> Result<(), Self::Error>

fn visit_opening_paren(&mut self) -> Result<(), Self::Error>

fn visit_closing_paren(&mut self) -> Result<(), Self::Error>

fn visit_newline(&mut self) -> Result<(), Self::Error>

fn visit_using(&mut self, using: &mut Using) -> Result<(), Self::Error>

fn visit_yul_block( &mut self, loc: Loc, _stmts: &mut Vec<YulStatement>, _attempt_single_line: bool, ) -> Result<(), Self::Error>

fn visit_yul_expr( &mut self, expr: &mut YulExpression, ) -> Result<(), Self::Error>

fn visit_yul_assignment<T>( &mut self, loc: Loc, _exprs: &mut Vec<T>, _expr: &mut Option<&mut YulExpression>, ) -> Result<(), Self::Error>

where T: Visitable + CodeLocationExt,

fn visit_yul_for(&mut self, stmt: &mut YulFor) -> Result<(), Self::Error>

fn visit_yul_function_call( &mut self, stmt: &mut YulFunctionCall, ) -> Result<(), Self::Error>

fn visit_yul_fun_def( &mut self, stmt: &mut YulFunctionDefinition, ) -> Result<(), Self::Error>

fn visit_yul_if( &mut self, loc: Loc, _expr: &mut YulExpression, _block: &mut YulBlock, ) -> Result<(), Self::Error>

fn visit_yul_leave(&mut self, loc: Loc) -> Result<(), Self::Error>

fn visit_yul_switch(&mut self, stmt: &mut YulSwitch) -> Result<(), Self::Error>

fn visit_yul_var_declaration( &mut self, loc: Loc, _idents: &mut Vec<YulTypedIdentifier>, _expr: &mut Option<YulExpression>, ) -> Result<(), Self::Error>

fn visit_yul_typed_ident( &mut self, ident: &mut YulTypedIdentifier, ) -> Result<(), Self::Error>

fn visit_parser_error(&mut self, loc: Loc) -> Result<(), Self::Error>

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: 984 bytes