cl-parser: Move precedence parser into its own module

compiler/cl-parser/src/parser.rs

@@ -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)
     }
 }
 
-/// Parses an [ExprKind]
+mod prec {
-///
+    //! Parses an [ExprKind] using a modified pratt parser
-/// See also: [Expr::parse]
+    //!
-// Implementer's note: [ExprKind::parse] is the public API for parsing ExprKinds.
+    //! See also: [Expr::parse], [ExprKind::parse]
-// Do not call it from within this function.
+    //!
-fn exprkind(p: &mut Parser, power: u8) -> PResult<ExprKind> {
+    //! 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]
+    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;
@@ -1023,13 +1036,13 @@ fn exprkind(p: &mut Parser, power: u8) -> PResult<ExprKind> {
         }
 
         Ok(head)
-}
+    }
 
-/// [Array] = '[' ([Expr] ',')* [Expr]? ']'
+    /// [Array] = '[' ([Expr] ',')* [Expr]? ']'
-///
+    ///
-/// Array and ArrayRef are ambiguous until the second token,
+    /// Array and ArrayRef are ambiguous until the second token,
-/// so they can't be independent subexpressions
+    /// so they can't be independent subexpressions
-fn exprkind_arraylike(p: &mut Parser) -> PResult<ExprKind> {
+    fn exprkind_arraylike(p: &mut Parser) -> PResult<ExprKind> {
         const P: Parsing = Parsing::Array;
         const START: TokenKind = TokenKind::LBrack;
         const END: TokenKind = TokenKind::RBrack;
@@ -1041,10 +1054,10 @@ fn exprkind_arraylike(p: &mut Parser) -> PResult<ExprKind> {
         };
         p.match_type(END, P)?;
         Ok(out)
-}
+    }
 
-/// [ArrayRep] = `[` [Expr] `;` [Expr] `]`
+    /// [ArrayRep] = `[` [Expr] `;` [Expr] `]`
-fn exprkind_array_rep(p: &mut Parser) -> PResult<ExprKind> {
+    fn exprkind_array_rep(p: &mut Parser) -> PResult<ExprKind> {
         const P: Parsing = Parsing::Array;
         const END: TokenKind = TokenKind::RBrack;
 
@@ -1070,12 +1083,12 @@ fn exprkind_array_rep(p: &mut Parser) -> PResult<ExprKind> {
             .into(),
             ty => Err(p.error(Unexpected(ty), P))?,
         })
-}
+    }
 
-/// [Group] = `(`([Empty](ExprKind::Empty)|[Expr]|[Tuple])`)`
+    /// [Group] = `(`([Empty](ExprKind::Empty)|[Expr]|[Tuple])`)`
-///
+    ///
-/// [ExprKind::Empty] and [Group] are special cases of [Tuple]
+    /// [ExprKind::Empty] and [Group] are special cases of [Tuple]
-fn exprkind_tuplelike(p: &mut Parser) -> PResult<ExprKind> {
+    fn exprkind_tuplelike(p: &mut Parser) -> PResult<ExprKind> {
         p.match_type(TokenKind::LParen, Parsing::Group)?;
         let out = match p.peek_kind(Parsing::Group)? {
             TokenKind::RParen => Ok(ExprKind::Empty),
@@ -1083,10 +1096,10 @@ fn exprkind_tuplelike(p: &mut Parser) -> PResult<ExprKind> {
         };
         p.match_type(TokenKind::RParen, Parsing::Group)?;
         out
-}
+    }
 
-/// [Group] = `(`([Empty](ExprKind::Empty)|[Expr]|[Tuple])`)`
+    /// [Group] = `(`([Empty](ExprKind::Empty)|[Expr]|[Tuple])`)`
-fn exprkind_group(p: &mut Parser) -> PResult<ExprKind> {
+    fn exprkind_group(p: &mut Parser) -> PResult<ExprKind> {
         let first = Expr::parse(p)?;
         match p.peek_kind(Parsing::Group)? {
             TokenKind::Comma => {
@@ -1103,19 +1116,19 @@ fn exprkind_group(p: &mut Parser) -> PResult<ExprKind> {
             }
             _ => Ok(Group { expr: first.kind.into() }.into()),
         }
-}
+    }
 
-/// Parses an expression beginning with a [Path] (i.e. [Path] or [Structor])
+    /// Parses an expression beginning with a [Path] (i.e. [Path] or [Structor])
-fn exprkind_pathlike(p: &mut Parser) -> PResult<ExprKind> {
+    fn exprkind_pathlike(p: &mut Parser) -> PResult<ExprKind> {
         let head = Path::parse(p)?;
         Ok(match p.match_type(TokenKind::Colon, Parsing::Path) {
             Ok(_) => ExprKind::Structor(structor_body(p, head)?),
             Err(_) => ExprKind::Path(head),
         })
-}
+    }
 
-/// [Structor]Body = `{` ([Fielder] `,`)* [Fielder]? `}`
+    /// [Structor]Body = `{` ([Fielder] `,`)* [Fielder]? `}`
-fn structor_body(p: &mut Parser, to: Path) -> PResult<Structor> {
+    fn structor_body(p: &mut Parser, to: Path) -> PResult<Structor> {
         let init = delim(
             sep(
                 Fielder::parse,
@@ -1128,6 +1141,148 @@ fn structor_body(p: &mut Parser, to: Path) -> PResult<Structor> {
         )(p)?;
 
         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 {
@@ -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,
-    };
-}