Struct Parser 

pub struct Parser {
    rules: Vec<(Rule, usize)>,
    recursion_depth: u32,
}

Fields

rules: Vec<(Rule, usize)>

recursion_depth: u32

Implementations

impl Parser

pub const fn new() -> Self

fn reset(&mut self)

fn push_rule_span(&mut self, rule: Rule, lexer: &mut Lexer<'_>)

fn pop_rule_span(&mut self, lexer: &Lexer<'_>) -> Span

fn peek_rule_span(&mut self, lexer: &Lexer<'_>) -> Span

fn race_rules(&self, rule0: Rule, rule1: Rule) -> Option<Rule>

fn track_recursion<'a, F, R>(&mut self, f: F) -> Result<R, Box<Error<'a>>>

where F: FnOnce(&mut Self) -> Result<R, Box<Error<'a>>>,

fn switch_value<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<SwitchValue<'a>, Box<Error<'a>>>

fn arguments<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Vec<Handle<Expression<'a>>>, Box<Error<'a>>>

Expects name to be consumed (not in lexer).

fn enclosed_expression<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

fn ident_expr<'a>( &mut self, name: &'a str, name_span: Span, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> IdentExpr<'a>

fn primary_expression<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, token: (Token<'a>, Span), ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

fn component_or_swizzle_specifier<'a>( &mut self, expr_start: Span, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, expr: Handle<Expression<'a>>, ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

fn unary_expression<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

Parse a unary_expression.

fn lhs_expression<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, token: Option<(Token<'a>, Span)>, expected_token: ExpectedToken<'a>, ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

Parse a lhs_expression.

LHS expressions only support the & and * operators and the [] and . postfix selectors.

fn singular_expression<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, token: (Token<'a>, Span), ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

Parse a singular_expression.

fn equality_expression<'a>( &mut self, lexer: &mut Lexer<'a>, context: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

fn expression<'a>( &mut self, lexer: &mut Lexer<'a>, context: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

fn optionally_typed_ident<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<(Ident<'a>, Option<TemplateElaboratedIdent<'a>>), Box<Error<'a>>>

fn variable_decl<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<GlobalVariable<'a>, Box<Error<'a>>>

‘var’ _disambiguate_template template_list? optionally_typed_ident

fn struct_body<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Vec<StructMember<'a>>, Box<Error<'a>>>

fn maybe_template_list<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<(Vec<Handle<Expression<'a>>>, Span), Box<Error<'a>>>

fn template_elaborated_ident<'a>( &mut self, word: &'a str, span: Span, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<TemplateElaboratedIdent<'a>, Box<Error<'a>>>

fn type_specifier<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<TemplateElaboratedIdent<'a>, Box<Error<'a>>>

fn variable_updating_statement<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, block: &mut Block<'a>, token: (Token<'a>, Span), expected_token: ExpectedToken<'a>, ) -> Result<(), Box<Error<'a>>>

Parses assignment, increment and decrement statements

This does not consume or require a final ; token. In the update expression of a C-style for loop header, there is no terminating ;.

fn maybe_func_call_statement<'a>( &mut self, lexer: &mut Lexer<'a>, context: &mut ExpressionContext<'a, '_, '_>, block: &mut Block<'a>, token: (Token<'a>, Span), ) -> Result<bool, Box<Error<'a>>>

Parse a function call statement.

This assumes that token has been consumed from the lexer.

This does not consume or require a final ; token. In the update expression of a C-style for loop header, there is no terminating ;.

fn func_call_or_variable_updating_statement<'a>( &mut self, lexer: &mut Lexer<'a>, context: &mut ExpressionContext<'a, '_, '_>, block: &mut Block<'a>, token: (Token<'a>, Span), expected_token: ExpectedToken<'a>, ) -> Result<(), Box<Error<'a>>>

Parses func_call_statement and variable_updating_statement

This does not consume or require a final ; token. In the update expression of a C-style for loop header, there is no terminating ;.

fn variable_or_value_or_func_call_or_variable_updating_statement<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, block: &mut Block<'a>, token: (Token<'a>, Span), expected_token: ExpectedToken<'a>, ) -> Result<(), Box<Error<'a>>>

Parses variable_or_value_statement, func_call_statement and variable_updating_statement.

This is equivalent to the for_init production in the WGSL spec, but it’s also used for parsing these forms when they appear within a block, hence the longer name.

This does not consume the following ; token.

fn statement<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, block: &mut Block<'a>, brace_nesting_level: u8, ) -> Result<(), Box<Error<'a>>>

fn loop<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, brace_nesting_level: u8, ) -> Result<StatementKind<'a>, Box<Error<'a>>>

fn block<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, brace_nesting_level: u8, ) -> Result<(Block<'a>, Span), Box<Error<'a>>>

compound_statement

fn varying_binding<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Option<Binding<'a>>, Box<Error<'a>>>

fn function_decl<'a>( &mut self, lexer: &mut Lexer<'a>, diagnostic_filter_leaf: Option<Handle<DiagnosticFilterNode>>, must_use: Option<Span>, out: &mut TranslationUnit<'a>, dependencies: &mut FastIndexSet<Dependency<'a>>, ) -> Result<Function<'a>, Box<Error<'a>>>

fn directive_ident_list<'a>( &self, lexer: &mut Lexer<'a>, handler: impl FnMut(&'a str, Span) -> Result<(), Box<Error<'a>>>, ) -> Result<(), Box<Error<'a>>>

fn global_decl<'a>( &mut self, lexer: &mut Lexer<'a>, out: &mut TranslationUnit<'a>, ) -> Result<(), Box<Error<'a>>>

pub fn parse<'a>( &mut self, source: &'a str, options: &Options, ) -> Result<TranslationUnit<'a>, Box<Error<'a>>>

fn increase_brace_nesting( brace_nesting_level: u8, brace_span: Span, ) -> Result<u8, Box<Error<'static>>>

fn diagnostic_filter<'a>( &self, lexer: &mut Lexer<'a>, ) -> Result<DiagnosticFilter, Box<Error<'a>>>

pub(crate) fn write_diagnostic_filters( arena: &mut Arena<DiagnosticFilterNode>, filters: DiagnosticFilterMap, parent: Option<Handle<DiagnosticFilterNode>>, ) -> Option<Handle<DiagnosticFilterNode>>