refactor: replace nom-language to pratt-parser

Author: KKould

Cargo.lock

@@ -555,8 +555,8 @@ gix = "0.71.0"
 indent = "0.1.1"
 logos = "0.12.1"
 nom = "8.0.0"
-nom-language = "0.1.0"
 nom-rule = "0.5.1"
+pratt = "0.4.0"
 rspack-codespan-reporting = "0.11"
 rustc-demangle = "0.1"
 strsim = "0.10"

Cargo.toml

@@ -19,10 +19,10 @@ indent = { workspace = true }
 itertools = { workspace = true }
 logos = { workspace = true }
 nom = { workspace = true }
-nom-language = { workspace = true }
 nom-rule = { workspace = true }
 ordered-float = { workspace = true }
 percent-encoding = { workspace = true }
+pratt = { workspace = true }
 pretty_assertions = { workspace = true }
 recursive = { workspace = true }
 rspack-codespan-reporting = { workspace = true }

src/query/ast/Cargo.toml

@@ -18,11 +18,11 @@ fn main() {
 
 // bench                     fastest       │ slowest       │ median        │ mean          │ samples │ iters
 // ╰─ dummy                                │               │               │               │         │
-// ├─ deep_function_call  242.8 µs      │ 525.3 µs      │ 258.9 µs      │ 262.8 µs      │ 100     │ 100
-// ├─ deep_query          235.6 µs      │ 364.8 µs      │ 244.8 µs      │ 249.3 µs      │ 100     │ 100
-// ├─ large_query         362.9 µs      │ 451.6 µs      │ 376.5 µs      │ 379.7 µs      │ 100     │ 100
-// ├─ large_statement     364.8 µs      │ 418.4 µs      │ 380.2 µs      │ 382.8 µs      │ 100     │ 100
-// ╰─ wide_expr           96.97 µs      │ 270.2 µs      │ 102.8 µs      │ 105.3 µs      │ 100     │ 100
+// ├─ deep_function_call  174.4 µs      │ 405.3 µs      │ 186.3 µs      │ 189.7 µs      │ 100     │ 100
+// ├─ deep_query          226.1 µs      │ 396.8 µs      │ 239.3 µs      │ 242.2 µs      │ 100     │ 100
+// ├─ large_query         270.5 µs      │ 362.8 µs      │ 289.7 µs      │ 294 µs        │ 100     │ 100
+// ├─ large_statement     283.4 µs      │ 313.5 µs      │ 294.6 µs      │ 295 µs        │ 100     │ 100
+// ╰─ wide_expr           38.01 µs      │ 189 µs        │ 39.04 µs      │ 40.81 µs      │ 100     │ 100
 
 #[divan::bench_group(max_time = 0.5)]
 mod dummy {

src/query/ast/benches/bench.rs

@@ -20,6 +20,8 @@ use derive_visitor::DriveMut;
 use educe::Educe;
 use enum_as_inner::EnumAsInner;
 use ethnum::i256;
+use pratt::Affix;
+use pratt::Associativity;
 
 use super::ColumnRef;
 use super::OrderByExpr;
@@ -30,8 +32,6 @@ use crate::ast::write_dot_separated_list;
 use crate::ast::Identifier;
 use crate::ast::Indirection;
 use crate::ast::Query;
-use crate::precedence::Affix;
-use crate::precedence::Associativity;
 use crate::span::merge_span;
 use crate::ParseError;
 use crate::Result;

src/query/ast/src/ast/expr.rs

@@ -18,7 +18,6 @@
 pub mod ast;
 pub mod parser;
 mod parser_error;
-pub mod precedence;
 pub mod span;
 mod visitor;
 

src/query/ast/src/lib.rs

@@ -12,18 +12,23 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use std::cell::RefCell;
+use std::rc::Rc;
+
 pub use nom::branch::alt;
 pub use nom::branch::permutation;
 pub use nom::combinator::consumed;
 pub use nom::combinator::map;
 pub use nom::combinator::not;
 pub use nom::combinator::value;
-use nom::error::Error as NomError;
-use nom::error::ErrorKind as NomErrorKind;
 pub use nom::multi::many1;
 use nom::sequence::terminated;
+use nom::Offset;
 use nom::Parser;
 use nom_rule::rule;
+use pratt::PrattError;
+use pratt::PrattParser;
+use pratt::Precedence;
 
 pub fn parser_fn<'a, O, P>(mut parser: P) -> impl FnMut(Input<'a>) -> IResult<'a, O>
 where P: nom::Parser<Input<'a>, Output = O, Error = Error<'a>> {
@@ -44,78 +49,11 @@ use crate::parser::query::with_options;
 use crate::parser::token::*;
 use crate::parser::Error;
 use crate::parser::ErrorKind;
-pub use crate::precedence::Affix;
-pub use crate::precedence::Associativity;
-pub use crate::precedence::Precedence;
 use crate::Range;
 use crate::Span;
 
 pub type IResult<'a, Output> = nom::IResult<Input<'a>, Output, Error<'a>>;
 
-pub type ElementsInput<'a, T> = &'a [WithSpan<'a, T>];
-pub type ElementsError<'a, T> = NomError<ElementsInput<'a, T>>;
-pub type ElementsResult<'a, T, O> = nom::IResult<ElementsInput<'a, T>, O, ElementsError<'a, T>>;
-
-pub fn match_prefix<'a, T>(
-    affix_fn: impl Fn(&T) -> Affix + Copy,
-    precedence: Precedence,
-) -> impl FnMut(ElementsInput<'a, T>) -> ElementsResult<'a, T, WithSpan<'a, T>>
-where
-    T: Clone,
-{
-    match_affix(
-        affix_fn,
-        move |affix| matches!(affix, Affix::Prefix(p) if p == precedence),
-    )
-}
-
-pub fn match_postfix<'a, T>(
-    affix_fn: impl Fn(&T) -> Affix + Copy,
-    precedence: Precedence,
-) -> impl FnMut(ElementsInput<'a, T>) -> ElementsResult<'a, T, WithSpan<'a, T>>
-where
-    T: Clone,
-{
-    match_affix(
-        affix_fn,
-        move |affix| matches!(affix, Affix::Postfix(p) if p == precedence),
-    )
-}
-
-pub fn match_binary<'a, T>(
-    affix_fn: impl Fn(&T) -> Affix + Copy,
-    precedence: Precedence,
-    associativity: Associativity,
-) -> impl FnMut(ElementsInput<'a, T>) -> ElementsResult<'a, T, WithSpan<'a, T>>
-where
-    T: Clone,
-{
-    match_affix(
-        affix_fn,
-        move |affix| matches!(affix, Affix::Infix(p, assoc) if p == precedence && assoc == associativity),
-    )
-}
-
-pub fn match_nilfix<'a, T>(
-    affix_fn: impl Fn(&T) -> Affix + Copy,
-) -> impl FnMut(ElementsInput<'a, T>) -> ElementsResult<'a, T, WithSpan<'a, T>>
-where T: Clone {
-    match_affix(affix_fn, |affix| matches!(affix, Affix::Nilfix))
-}
-
-fn match_affix<'a, T>(
-    affix_fn: impl Fn(&T) -> Affix + Copy,
-    predicate: impl Fn(Affix) -> bool + Copy,
-) -> impl FnMut(ElementsInput<'a, T>) -> ElementsResult<'a, T, WithSpan<'a, T>>
-where
-    T: Clone,
-{
-    move |input| match input.split_first() {
-        Some((elem, rest)) if predicate(affix_fn(&elem.elem)) => Ok((rest, elem.clone())),
-        _ => Err(nom::Err::Error(NomError::new(input, NomErrorKind::Tag))),
-    }
-}
-
 pub fn match_text(text: &'static str) -> impl FnMut(Input) -> IResult<&Token> {
     move |i| match i.tokens.first().filter(|token| token.text() == text) {
         Some(token) => Ok((i.slice(1..), token)),
@@ -667,6 +605,104 @@ pub fn transform_span(tokens: &[Token]) -> Span {
     })
 }
 
+pub(crate) trait IterProvider<'a> {
+    type Item;
+    type Iter: Iterator<Item = Self::Item> + ExactSizeIterator;
+
+    fn create_iter(self, span: Rc<RefCell<Option<Input<'a>>>>) -> Self::Iter;
+}
+
+impl<'a, T> IterProvider<'a> for Vec<WithSpan<'a, T>>
+where T: Clone
+{
+    type Item = WithSpan<'a, T>;
+    type Iter = ErrorSpan<'a, T, std::vec::IntoIter<WithSpan<'a, T>>>;
+
+    fn create_iter(self, span: Rc<RefCell<Option<Input<'a>>>>) -> Self::Iter {
+        ErrorSpan::new(self.into_iter(), span)
+    }
+}
+
+pub(crate) struct ErrorSpan<'a, T, I: Iterator<Item = WithSpan<'a, T>>> {
+    iter: I,
+    span: Rc<RefCell<Option<Input<'a>>>>,
+}
+
+impl<'a, T, I: Iterator<Item = WithSpan<'a, T>>> ErrorSpan<'a, T, I> {
+    fn new(iter: I, span: Rc<RefCell<Option<Input<'a>>>>) -> Self {
+        Self { iter, span }
+    }
+}
+
+impl<'a, T, I: Iterator<Item = WithSpan<'a, T>>> Iterator for ErrorSpan<'a, T, I> {
+    type Item = WithSpan<'a, T>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter
+            .next()
+            .inspect(|item| *self.span.borrow_mut() = Some(item.span))
+    }
+}
+
+impl<'a, T, I: Iterator<Item = WithSpan<'a, T>>> ExactSizeIterator for ErrorSpan<'a, T, I> {}
+
+pub fn run_pratt_parser<'a, I, P, E, T>(
+    mut parser: P,
+    parsers: T,
+    rest: Input<'a>,
+    input: Input<'a>,
+) -> IResult<'a, P::Output>
+where
+    E: std::fmt::Debug,
+    P: PrattParser<I, Input = WithSpan<'a, E>, Error = &'static str>,
+    I: Iterator<Item = P::Input> + ExactSizeIterator,
+    T: IterProvider<'a, Item = P::Input, Iter = I>,
+{
+    let span = Rc::new(RefCell::new(None));
+    let mut iter = parsers.create_iter(span.clone()).peekable();
+    let expr = parser
+        .parse_input(&mut iter, Precedence(0))
+        .map_err(|err| {
+            // Rollback parsing footprint on unused expr elements.
+            input.backtrace.clear();
+
+            let err_kind = match err {
+                PrattError::EmptyInput => ErrorKind::Other("expecting an operand"),
+                PrattError::UnexpectedNilfix(i) => {
+                    *span.borrow_mut() = Some(i.span);
+                    ErrorKind::Other("unable to parse the element")
+                }
+                PrattError::UnexpectedPrefix(i) => {
+                    *span.borrow_mut() = Some(i.span);
+                    ErrorKind::Other("unable to parse the prefix operator")
+                }
+                PrattError::UnexpectedInfix(i) => {
+                    *span.borrow_mut() = Some(i.span);
+                    ErrorKind::Other("missing lhs or rhs for the binary operator")
+                }
+                PrattError::UnexpectedPostfix(i) => {
+                    *span.borrow_mut() = Some(i.span);
+                    ErrorKind::Other("unable to parse the postfix operator")
+                }
+                PrattError::UserError(err) => ErrorKind::Other(err),
+            };
+
+            let span = span
+                .take()
+                // It's safe to slice one more token because input must contain EOI.
+                .unwrap_or_else(|| rest.slice(..1));
+
+            nom::Err::Error(Error::from_error_kind(span, err_kind))
+        })?;
+    if let Some(elem) = iter.peek() {
+        // Rollback parsing footprint on unused expr elements.
+        input.backtrace.clear();
+        Ok((input.slice(input.offset(&elem.span)..), expr))
+    } else {
+        Ok((rest, expr))
+    }
+}
+
 pub fn check_template_mode<'a, O, F>(mut parser: F) -> impl FnMut(Input<'a>) -> IResult<'a, O>
 where F: nom::Parser<Input<'a>, Output = O, Error = Error<'a>> {
     move |input: Input| {