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 constructor_type<'a>( &mut self, lexer: &mut Lexer<'a>, word: &'a str, span: Span, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Option<ConstructorType<'a>>, Box<Error<'a>>>

Decide if we’re looking at a construction expression, and return its type if so.

If the identifier word is a type-defining keyword, then return a ConstructorType value describing the type to build. Return an error if the type is not constructible (like sampler).

If word isn’t a type name, then return None.

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 function_call<'a>( &mut self, lexer: &mut Lexer<'a>, name: &'a str, name_span: Span, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

Expects Rule::PrimaryExpr or Rule::SingularExpr on top; does not pop it. Expects name to be consumed (not in lexer).

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, '_, '_>, ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

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

fn const_generic_expression<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'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, '_, '_>, ) -> 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, '_, '_>, ) -> 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 general_expression<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, ) -> Result<Handle<Expression<'a>>, Box<Error<'a>>>

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

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

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

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

Parses <T>, returning T and span of T

fn matrix_with_type<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, columns: VectorSize, rows: VectorSize, ) -> Result<Type<'a>, Box<Error<'a>>>

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

fn check_texture_sample_type( scalar: Scalar, span: Span, ) -> Result<(), Box<Error<'static>>>

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

Parse type declaration of a given name.

fn assignment_op_and_rhs<'a>( &mut self, lexer: &mut Lexer<'a>, ctx: &mut ExpressionContext<'a, '_, '_>, block: &mut Block<'a>, target: Handle<Expression<'a>>, span_start: usize, ) -> Result<(), Box<Error<'a>>>

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

Parse an assignment statement (will also parse increment and decrement statements)

fn function_statement<'a>( &mut self, lexer: &mut Lexer<'a>, ident: &'a str, ident_span: Span, span_start: usize, context: &mut ExpressionContext<'a, '_, '_>, block: &mut Block<'a>, ) -> Result<(), Box<Error<'a>>>

Parse a function call statement. Expects ident to be consumed (not in the lexer).

fn function_call_or_assignment_statement<'a>( &mut self, lexer: &mut Lexer<'a>, context: &mut ExpressionContext<'a, '_, '_>, block: &mut Block<'a>, ) -> Result<(), Box<Error<'a>>>

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