cl-parser: Move precedence parser into its own module
This commit is contained in:
parent
1eb0516baf
commit
533436afc1
@ -36,7 +36,7 @@ impl<'t> Parser<'t> {
|
||||
}
|
||||
|
||||
/// Constructs an [Error]
|
||||
fn error(&self, reason: ErrorKind, while_parsing: Parsing) -> Error {
|
||||
pub fn error(&self, reason: ErrorKind, while_parsing: Parsing) -> Error {
|
||||
Error { reason, while_parsing, loc: self.loc }
|
||||
}
|
||||
|
||||
@ -191,6 +191,7 @@ macro path_like() {
|
||||
}
|
||||
|
||||
pub trait Parse<'t>: Sized {
|
||||
/// Parses a Self from the provided [Parser]
|
||||
fn parse(p: &mut Parser<'t>) -> PResult<Self>;
|
||||
}
|
||||
|
||||
@ -881,7 +882,7 @@ impl Parse<'_> for StmtKind {
|
||||
impl Parse<'_> for Expr {
|
||||
/// Parses an [Expr]
|
||||
///
|
||||
/// See also: [Parser::exprkind]
|
||||
/// See also: [ExprKind::parse]
|
||||
fn parse(p: &mut Parser) -> PResult<Expr> {
|
||||
let start = p.loc();
|
||||
Ok(Expr { kind: ExprKind::parse(p)?, extents: Span(start, p.loc()) })
|
||||
@ -892,16 +893,22 @@ impl Parse<'_> for ExprKind {
|
||||
/// Parses an [ExprKind] at the lowest precedence level
|
||||
// Implementer's note: Do not call this from within [Parser::exprkind]
|
||||
fn parse(p: &mut Parser<'_>) -> PResult<ExprKind> {
|
||||
exprkind(p, 0)
|
||||
prec::exprkind(p, 0)
|
||||
}
|
||||
}
|
||||
|
||||
mod prec {
|
||||
//! Parses an [ExprKind] using a modified pratt parser
|
||||
//!
|
||||
//! See also: [Expr::parse], [ExprKind::parse]
|
||||
//!
|
||||
//! Implementer's note: [ExprKind::parse] is the public API for parsing [ExprKind]s.
|
||||
//! Do not call it from within this function.
|
||||
|
||||
use super::{Parse, *};
|
||||
|
||||
/// Parses an [ExprKind]
|
||||
///
|
||||
/// See also: [Expr::parse]
|
||||
// Implementer's note: [ExprKind::parse] is the public API for parsing ExprKinds.
|
||||
// Do not call it from within this function.
|
||||
fn exprkind(p: &mut Parser, power: u8) -> PResult<ExprKind> {
|
||||
pub fn exprkind(p: &mut Parser, power: u8) -> PResult<ExprKind> {
|
||||
let parsing = Parsing::ExprKind;
|
||||
|
||||
// Prefix expressions
|
||||
@ -924,7 +931,8 @@ fn exprkind(p: &mut Parser, power: u8) -> PResult<ExprKind> {
|
||||
}
|
||||
|
||||
op => {
|
||||
let (kind, prec) = from_prefix(op).ok_or_else(|| p.error(Unexpected(op), parsing))?;
|
||||
let (kind, prec) =
|
||||
from_prefix(op).ok_or_else(|| p.error(Unexpected(op), parsing))?;
|
||||
let ((), after) = prec.prefix().expect("should have a precedence");
|
||||
p.consume_peeked();
|
||||
Unary { kind, tail: exprkind(p, after)?.into() }.into()
|
||||
@ -956,9 +964,13 @@ fn exprkind(p: &mut Parser, power: u8) -> PResult<ExprKind> {
|
||||
ExprKind::Index(Index { head: head.into(), indices })
|
||||
}
|
||||
TokenKind::LParen => {
|
||||
let exprs = sep(Expr::parse, TokenKind::Comma, TokenKind::RParen, parsing)(p)?;
|
||||
let exprs =
|
||||
sep(Expr::parse, TokenKind::Comma, TokenKind::RParen, parsing)(p)?;
|
||||
p.match_type(TokenKind::RParen, parsing)?;
|
||||
Binary { kind: BinaryKind::Call, parts: (head, Tuple { exprs }.into()).into() }
|
||||
Binary {
|
||||
kind: BinaryKind::Call,
|
||||
parts: (head, Tuple { exprs }.into()).into(),
|
||||
}
|
||||
.into()
|
||||
}
|
||||
TokenKind::Dot => {
|
||||
@ -1014,6 +1026,7 @@ fn exprkind(p: &mut Parser, power: u8) -> PResult<ExprKind> {
|
||||
break;
|
||||
}
|
||||
p.consume_peeked();
|
||||
|
||||
let ty = Ty::parse(p)?;
|
||||
head = Cast { head: head.into(), ty }.into();
|
||||
continue;
|
||||
@ -1130,6 +1143,148 @@ fn structor_body(p: &mut Parser, to: Path) -> PResult<Structor> {
|
||||
Ok(Structor { to, init })
|
||||
}
|
||||
|
||||
/// Precedence provides a total ordering among operators
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
pub enum Precedence {
|
||||
Assign,
|
||||
Compare,
|
||||
Range,
|
||||
Logic,
|
||||
Bitwise,
|
||||
Shift,
|
||||
Factor,
|
||||
Term,
|
||||
Unary,
|
||||
Index,
|
||||
Cast,
|
||||
Member, // left-associative
|
||||
Call,
|
||||
}
|
||||
|
||||
impl Precedence {
|
||||
#[inline]
|
||||
pub const fn level(self) -> u8 {
|
||||
(self as u8) << 1
|
||||
}
|
||||
|
||||
pub fn prefix(self) -> Option<((), u8)> {
|
||||
match self {
|
||||
Self::Assign => Some(((), self.level())),
|
||||
Self::Unary => Some(((), self.level())),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn infix(self) -> Option<(u8, u8)> {
|
||||
let level = self.level();
|
||||
match self {
|
||||
Self::Unary => None,
|
||||
Self::Assign => Some((level + 1, level)),
|
||||
_ => Some((level, level + 1)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn postfix(self) -> Option<(u8, ())> {
|
||||
match self {
|
||||
Self::Index | Self::Call | Self::Member => Some((self.level(), ())),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<ModifyKind> for Precedence {
|
||||
fn from(_value: ModifyKind) -> Self {
|
||||
Precedence::Assign
|
||||
}
|
||||
}
|
||||
|
||||
impl From<BinaryKind> for Precedence {
|
||||
fn from(value: BinaryKind) -> Self {
|
||||
use BinaryKind as Op;
|
||||
match value {
|
||||
Op::Call => Precedence::Call,
|
||||
Op::Mul | Op::Div | Op::Rem => Precedence::Term,
|
||||
Op::Add | Op::Sub => Precedence::Factor,
|
||||
Op::Shl | Op::Shr => Precedence::Shift,
|
||||
Op::BitAnd | Op::BitOr | Op::BitXor => Precedence::Bitwise,
|
||||
Op::LogAnd | Op::LogOr | Op::LogXor => Precedence::Logic,
|
||||
Op::RangeExc | Op::RangeInc => Precedence::Range,
|
||||
Op::Lt | Op::LtEq | Op::Equal | Op::NotEq | Op::GtEq | Op::Gt => {
|
||||
Precedence::Compare
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<UnaryKind> for Precedence {
|
||||
fn from(value: UnaryKind) -> Self {
|
||||
use UnaryKind as Op;
|
||||
match value {
|
||||
Op::Loop => Precedence::Assign,
|
||||
Op::Deref | Op::Neg | Op::Not | Op::At | Op::Tilde => Precedence::Unary,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates helper functions for turning TokenKinds into AST operators
|
||||
macro operator($($name:ident ($takes:ident => $returns:ident) {$($t:ident => $p:ident),*$(,)?};)*) {$(
|
||||
pub fn $name (value: $takes) -> Option<($returns, Precedence)> {
|
||||
match value {
|
||||
$($takes::$t => Some(($returns::$p, Precedence::from($returns::$p))),)*
|
||||
_ => None?,
|
||||
}
|
||||
})*
|
||||
}
|
||||
|
||||
operator! {
|
||||
from_prefix (TokenKind => UnaryKind) {
|
||||
Loop => Loop,
|
||||
Star => Deref,
|
||||
Minus => Neg,
|
||||
Bang => Not,
|
||||
At => At,
|
||||
Tilde => Tilde,
|
||||
};
|
||||
|
||||
from_modify(TokenKind => ModifyKind) {
|
||||
AmpEq => And,
|
||||
BarEq => Or,
|
||||
XorEq => Xor,
|
||||
LtLtEq => Shl,
|
||||
GtGtEq => Shr,
|
||||
PlusEq => Add,
|
||||
MinusEq => Sub,
|
||||
StarEq => Mul,
|
||||
SlashEq => Div,
|
||||
RemEq => Rem,
|
||||
};
|
||||
|
||||
from_infix (TokenKind => BinaryKind) {
|
||||
Lt => Lt,
|
||||
LtEq => LtEq,
|
||||
EqEq => Equal,
|
||||
BangEq => NotEq,
|
||||
GtEq => GtEq,
|
||||
Gt => Gt,
|
||||
DotDot => RangeExc,
|
||||
DotDotEq => RangeInc,
|
||||
AmpAmp => LogAnd,
|
||||
BarBar => LogOr,
|
||||
XorXor => LogXor,
|
||||
Amp => BitAnd,
|
||||
Bar => BitOr,
|
||||
Xor => BitXor,
|
||||
LtLt => Shl,
|
||||
GtGt => Shr,
|
||||
Plus => Add,
|
||||
Minus => Sub,
|
||||
Star => Mul,
|
||||
Slash => Div,
|
||||
Rem => Rem,
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
impl Parse<'_> for Let {
|
||||
fn parse(p: &mut Parser) -> PResult<Let> {
|
||||
p.consume_peeked();
|
||||
@ -1297,142 +1452,3 @@ fn ret_body(p: &mut Parser, while_parsing: Parsing) -> PResult<Option<Box<Expr>>
|
||||
_ => Some(Expr::parse(p)?.into()),
|
||||
})
|
||||
}
|
||||
|
||||
/// Precedence provides a total ordering among operators
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
|
||||
pub enum Precedence {
|
||||
Assign,
|
||||
Compare,
|
||||
Range,
|
||||
Logic,
|
||||
Bitwise,
|
||||
Shift,
|
||||
Factor,
|
||||
Term,
|
||||
Unary,
|
||||
Index,
|
||||
Cast,
|
||||
Member, // left-associative
|
||||
Call,
|
||||
}
|
||||
|
||||
impl Precedence {
|
||||
#[inline]
|
||||
pub const fn level(self) -> u8 {
|
||||
(self as u8) << 1
|
||||
}
|
||||
|
||||
pub fn prefix(self) -> Option<((), u8)> {
|
||||
match self {
|
||||
Self::Assign => Some(((), self.level())),
|
||||
Self::Unary => Some(((), self.level())),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn infix(self) -> Option<(u8, u8)> {
|
||||
let level = self.level();
|
||||
match self {
|
||||
Self::Unary => None,
|
||||
Self::Assign => Some((level + 1, level)),
|
||||
_ => Some((level, level + 1)),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn postfix(self) -> Option<(u8, ())> {
|
||||
match self {
|
||||
Self::Index | Self::Call | Self::Member => Some((self.level(), ())),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<ModifyKind> for Precedence {
|
||||
fn from(_value: ModifyKind) -> Self {
|
||||
Precedence::Assign
|
||||
}
|
||||
}
|
||||
|
||||
impl From<BinaryKind> for Precedence {
|
||||
fn from(value: BinaryKind) -> Self {
|
||||
use BinaryKind as Op;
|
||||
match value {
|
||||
Op::Call => Precedence::Call,
|
||||
Op::Mul | Op::Div | Op::Rem => Precedence::Term,
|
||||
Op::Add | Op::Sub => Precedence::Factor,
|
||||
Op::Shl | Op::Shr => Precedence::Shift,
|
||||
Op::BitAnd | Op::BitOr | Op::BitXor => Precedence::Bitwise,
|
||||
Op::LogAnd | Op::LogOr | Op::LogXor => Precedence::Logic,
|
||||
Op::RangeExc | Op::RangeInc => Precedence::Range,
|
||||
Op::Lt | Op::LtEq | Op::Equal | Op::NotEq | Op::GtEq | Op::Gt => Precedence::Compare,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl From<UnaryKind> for Precedence {
|
||||
fn from(value: UnaryKind) -> Self {
|
||||
use UnaryKind as Op;
|
||||
match value {
|
||||
Op::Loop => Precedence::Assign,
|
||||
Op::Deref | Op::Neg | Op::Not | Op::At | Op::Tilde => Precedence::Unary,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates helper functions for turning TokenKinds into AST operators
|
||||
macro operator($($name:ident ($takes:ident => $returns:ident) {$($t:ident => $p:ident),*$(,)?};)*) {$(
|
||||
pub fn $name (value: $takes) -> Option<($returns, Precedence)> {
|
||||
match value {
|
||||
$($takes::$t => Some(($returns::$p, Precedence::from($returns::$p))),)*
|
||||
_ => None?,
|
||||
}
|
||||
})*
|
||||
}
|
||||
|
||||
operator! {
|
||||
from_prefix (TokenKind => UnaryKind) {
|
||||
Loop => Loop,
|
||||
Star => Deref,
|
||||
Minus => Neg,
|
||||
Bang => Not,
|
||||
At => At,
|
||||
Tilde => Tilde,
|
||||
};
|
||||
|
||||
from_modify(TokenKind => ModifyKind) {
|
||||
AmpEq => And,
|
||||
BarEq => Or,
|
||||
XorEq => Xor,
|
||||
LtLtEq => Shl,
|
||||
GtGtEq => Shr,
|
||||
PlusEq => Add,
|
||||
MinusEq => Sub,
|
||||
StarEq => Mul,
|
||||
SlashEq => Div,
|
||||
RemEq => Rem,
|
||||
};
|
||||
|
||||
from_infix (TokenKind => BinaryKind) {
|
||||
Lt => Lt,
|
||||
LtEq => LtEq,
|
||||
EqEq => Equal,
|
||||
BangEq => NotEq,
|
||||
GtEq => GtEq,
|
||||
Gt => Gt,
|
||||
DotDot => RangeExc,
|
||||
DotDotEq => RangeInc,
|
||||
AmpAmp => LogAnd,
|
||||
BarBar => LogOr,
|
||||
XorXor => LogXor,
|
||||
Amp => BitAnd,
|
||||
Bar => BitOr,
|
||||
Xor => BitXor,
|
||||
LtLt => Shl,
|
||||
GtGt => Shr,
|
||||
Plus => Add,
|
||||
Minus => Sub,
|
||||
Star => Mul,
|
||||
Slash => Div,
|
||||
Rem => Rem,
|
||||
};
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user