Struct cl_parser::parser::Parser

pub struct Parser<'t> { /* private fields */ }

Parses a sequence of Tokens into an AST

Implementations

impl<'t> Parser<'t>

Basic parser functionality

pub fn new(lexer: Lexer<'t>) -> Self

pub fn loc(&self) -> Loc

Gets the location of the last consumed Token

pub fn peek(&mut self, while_parsing: Parsing) -> PResult<&Token>

Looks ahead one token

Stores the token in an internal lookahead buffer

pub fn peek_kind(&mut self, while_parsing: Parsing) -> PResult<TokenKind>

Looks ahead at the next Token’s TokenKind

pub fn consume_peeked(&mut self) -> Option<Token>

Consumes a previously peeked Token, returning it. Returns None when there is no peeked token.

This avoids the overhead of constructing an Error

pub fn consume(&mut self, while_parsing: Parsing) -> PResult<Token>

Consumes one Token

pub fn match_type( &mut self, want: TokenKind, while_parsing: Parsing ) -> PResult<Token>

Consumes the next Token if it matches the pattern TokenKind

pub fn match_op( &mut self, want: Punct, while_parsing: Parsing ) -> PResult<Token>

impl<'t> Parser<'t>

Top level parsing

pub fn file(&mut self) -> PResult<File>

Parses a [File]

pub fn item(&mut self) -> PResult<Item>

Parses an [Item]

See also: Parser::itemkind

pub fn ty(&mut self) -> PResult<Ty>

Parses a [Ty]

See also: Parser::tykind

pub fn path(&mut self) -> PResult<Path>

Parses a [Path]

See also: Parser::path_part, Parser::identifier

[Path] = :: RelativePath? | RelativePath
RelativePath = [PathPart] (:: [PathPart])*

pub fn stmt(&mut self) -> PResult<Stmt>

Parses a [Stmt]

See also: Parser::stmtkind

pub fn expr(&mut self) -> PResult<Expr>

Parses an [Expr]

See also: Parser::exprkind

impl<'t> Parser<'t>

Attribute parsing

pub fn attributes(&mut self) -> PResult<Attrs>

Parses an attribute set

pub fn meta(&mut self) -> PResult<Meta>

Parses a single attribute

pub fn meta_kind(&mut self) -> PResult<MetaKind>

Parses data associated with a [Meta] attribute

impl<'t> Parser<'t>

Item parsing

pub fn itemkind(&mut self) -> PResult<ItemKind>

Parses an [ItemKind]

See also: Parser::item

pub fn parse_alias(&mut self) -> PResult<Alias>

Parses a type alias

pub fn parse_const(&mut self) -> PResult<Const>

Parses a compile-time constant

pub fn parse_static(&mut self) -> PResult<Static>

Parses a static item

pub fn parse_module(&mut self) -> PResult<Module>

Parses a [Module]

pub fn modulekind(&mut self) -> PResult<ModuleKind>

Parses the item list associated with a [Module], if present

pub fn parse_function(&mut self) -> PResult<Function>

Parses a [Function] definition

pub fn parse_params(&mut self) -> PResult<(Vec<Param>, Vec<TyKind>)>

Parses the parameters associated with a Function

pub fn parse_param(&mut self) -> PResult<(Param, TyKind)>

Parses a single function parameter

pub fn parse_struct(&mut self) -> PResult<Struct>

Parses a struct definition

pub fn structkind_tuple(&mut self) -> PResult<StructKind>

Parses a tuple-struct’s members

pub fn structkind_struct(&mut self) -> PResult<StructKind>

Parses a structs members

pub fn struct_member(&mut self) -> PResult<StructMember>

Parses a single [StructMember]

pub fn parse_enum(&mut self) -> PResult<Enum>

Parses an enum definition

pub fn enum_variant(&mut self) -> PResult<Variant>

Parses an enum [Variant]

pub fn variantkind_clike(&mut self) -> PResult<VariantKind>

Parses a C-like enum [Variant]

pub fn variantkind_struct(&mut self) -> PResult<VariantKind>

Parses a struct-like enum [Variant]

pub fn variantkind_tuple(&mut self) -> PResult<VariantKind>

Parses a tuple-like enum [Variant]

pub fn parse_impl(&mut self) -> PResult<Impl>

pub fn parse_impl_kind(&mut self) -> PResult<ImplKind>

pub fn parse_use(&mut self) -> PResult<Use>

pub fn parse_use_tree(&mut self) -> PResult<UseTree>

pub fn visibility(&mut self) -> Visibility

[Visibility] = pub?

pub fn mutability(&mut self) -> Mutability

[Mutability] = mut?

impl<'t> Parser<'t>

Type parsing

pub fn tykind(&mut self) -> PResult<TyKind>

Parses a [TyKind]

See also: Parser::ty

pub fn tytuple(&mut self) -> PResult<TyTuple>

[TyTuple] = ( ([Ty] ,)* [Ty]? )

pub fn tyref(&mut self) -> PResult<TyRef>

[TyRef] = (&|&&)* [Path]

pub fn tyfn(&mut self) -> PResult<TyFn>

[TyFn] = fn [TyTuple] (-> [Ty])?

pub fn parse_rety(&mut self) -> PResult<Option<Ty>>

pub fn tyfn_args(&mut self) -> PResult<Vec<TyKind>>

impl<'t> Parser<'t>

Path parsing

pub fn path_part(&mut self) -> PResult<PathPart>

[PathPart] = super | self | Identifier

pub fn identifier(&mut self) -> PResult<Sym>

[Sym] = Identifier

impl<'t> Parser<'t>

Statement parsing

pub fn stmtkind(&mut self) -> PResult<StmtKind>

Parses a [StmtKind]

See also: Parser::stmt

pub fn parse_let(&mut self) -> PResult<Let>

impl<'t> Parser<'t>

Expression parsing

pub fn expr_from( &mut self, f: impl Fn(&mut Self) -> PResult<ExprKind> ) -> PResult<Expr>

Creates an [Expr] with the given [ExprKind]-parser

pub fn exprkind(&mut self, power: u8) -> PResult<ExprKind>

Parses an [ExprKind]

See also: Parser::expr

pub fn access(&mut self) -> PResult<MemberKind>

pub fn exprkind_pathlike(&mut self) -> PResult<ExprKind>

Parses an expression beginning with a [Path] (i.e. [Path] or [Structor])

pub fn structor_body(&mut self, to: Path) -> PResult<Structor>

[Structor]Body = { ([Fielder] ,)* [Fielder]? }

pub fn fielder(&mut self) -> PResult<Fielder>

[Fielder] = Identifier (: [Expr])?

pub fn exprkind_arraylike(&mut self) -> PResult<ExprKind>

[Array] = ‘[’ ([Expr] ‘,’)* [Expr]? ‘]’

Array and ArrayRef are ambiguous until the second token, so they can’t be independent subexpressions

pub fn exprkind_array_rep(&mut self) -> PResult<ExprKind>

[ArrayRep] = [ [Expr] ; [Expr] ]

pub fn exprkind_tuplelike(&mut self) -> PResult<ExprKind>

[Group] = ((Empty|[Expr]|[Tuple]))

[ExprKind::Empty] and [Group] are special cases of [Tuple]

pub fn exprkind_group(&mut self) -> PResult<ExprKind>

[Group] = ((Empty|[Expr]|[Tuple]))

impl<'t> Parser<'t>

Subexpressions

pub fn addrof(&mut self) -> PResult<AddrOf>

[AddrOf] = (&|&&)* [Expr]

pub fn literal(&mut self) -> PResult<Literal>

[Literal] = LITERAL | true | false

pub fn block(&mut self) -> PResult<Block>

[Block] = { [Stmt]* }

impl<'t> Parser<'t>

Control flow subexpressions

pub fn parse_break(&mut self) -> PResult<Break>

[Break] = break (unconsumed ; | [Expr])

pub fn parse_return(&mut self) -> PResult<Return>

[Return] = return (unconsumed ; | [Expr])

pub fn parse_while(&mut self) -> PResult<While>

[While] = while [Expr] [Block] [Else]?

pub fn parse_if(&mut self) -> PResult<If>

[If] = if [Expr] [Block] [Else]?

pub fn parse_for(&mut self) -> PResult<For>

[For]: for Pattern (TODO) in [Expr] [Block] [Else]?

pub fn parse_else(&mut self) -> PResult<Else>

[Else]: (else [Block])?

Trait Implementations

impl<'t> Debug for Parser<'t>

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

Formats the value using the given formatter.