move precedence into SuccessfulParse

We are going to need access to it when we recurse.
Besides, the code looks cleaner this way!

Author: nikomatsakis

crates/formality-core/src/parse.rs

@@ -24,7 +24,7 @@ pub trait CoreParse<L: Language>: Sized + Debug + Clone + Eq + 'static {
 }
 
 mod parser;
-pub use parser::{skip_whitespace, ActiveVariant, Parser};
+pub use parser::{skip_whitespace, ActiveVariant, Parser, Precedence};
 
 /// Parses `text` as a term with the given bindings in scope.
 ///
@@ -76,21 +76,15 @@ pub struct SuccessfulParse<'t, T> {
     /// reduction.
     reductions: Vec<&'static str>,
 
+    /// The precedence of this parse, which is derived from the value given
+    /// to `parse_variant`.
+    precedence: Precedence,
+
     /// The value produced.
     value: T,
 }
 
 impl<'t, T> SuccessfulParse<'t, T> {
-    #[track_caller]
-    pub fn new(text: &'t str, reductions: Vec<&'static str>, value: T) -> Self {
-        // assert!(!reductions.is_empty());
-        Self {
-            text,
-            reductions,
-            value,
-        }
-    }
-
     /// Extract the value parsed and the remaining text,
     /// ignoring the reductions.
     pub fn finish(self) -> (T, &'t str) {
@@ -103,6 +97,7 @@ impl<'t, T> SuccessfulParse<'t, T> {
         SuccessfulParse {
             text: self.text,
             reductions: self.reductions,
+            precedence: self.precedence,
             value: op(self.value),
         }
     }
@@ -117,6 +112,7 @@ where
         SuccessfulParse {
             text: term.text,
             reductions: term.reductions,
+            precedence: term.precedence,
             value: term.value.upcast(),
         }
     }

crates/formality-core/src/parse/parser.rs

@@ -30,12 +30,12 @@ where
     scope: &'s Scope<L>,
     start_text: &'t str,
     nonterminal_name: &'static str,
-    successes: Vec<(SuccessfulParse<'t, T>, Precedence)>,
+    successes: Vec<SuccessfulParse<'t, T>>,
     failures: Set<ParseError<'t>>,
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
-struct Precedence(usize);
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
+pub struct Precedence(usize);
 
 /// The "active variant" struct is the main struct
 /// you will use if you are writing custom parsing logic.
@@ -152,6 +152,8 @@ where
         );
         let guard = span.enter();
 
+        let variant_precedence = Precedence(variant_precedence);
+
         let mut active_variant = ActiveVariant {
             scope: self.scope,
             text: self.start_text,
@@ -172,14 +174,12 @@ where
                     active_variant.reductions.push(variant_name);
                 }
 
-                self.successes.push((
-                    SuccessfulParse {
-                        text: active_variant.text,
-                        reductions: active_variant.reductions,
-                        value,
-                    },
-                    Precedence(variant_precedence),
-                ));
+                self.successes.push(SuccessfulParse {
+                    text: active_variant.text,
+                    reductions: active_variant.reductions,
+                    precedence: variant_precedence,
+                    value,
+                });
                 tracing::trace!("success: {:?}", self.successes.last().unwrap());
             }
 
@@ -242,7 +242,7 @@ where
                 .zip(0..)
                 .all(|(s_j, j)| i == j || Self::is_preferable(s_i, s_j))
             {
-                let (s_i, _) = self.successes.into_iter().skip(i).next().unwrap();
+                let s_i = self.successes.into_iter().skip(i).next().unwrap();
                 // It's better to print this result alongside the main parsing section.
                 drop(guard);
                 tracing::trace!("best parse = `{:?}`", s_i);
@@ -257,19 +257,13 @@ where
         );
     }
 
-    fn is_preferable(
-        s_i: &(SuccessfulParse<T>, Precedence),
-        s_j: &(SuccessfulParse<T>, Precedence),
-    ) -> bool {
-        let (parse_i, prec_i) = s_i;
-        let (parse_j, prec_j) = s_j;
-
+    fn is_preferable(s_i: &SuccessfulParse<T>, s_j: &SuccessfulParse<T>) -> bool {
         fn has_prefix<T: Eq>(l1: &[T], l2: &[T]) -> bool {
             l1.len() > l2.len() && (0..l2.len()).all(|i| l1[i] == l2[i])
         }
 
-        prec_i > prec_j
-            || (prec_i == prec_j && has_prefix(&parse_i.reductions, &parse_j.reductions))
+        s_i.precedence > s_j.precedence
+            || (s_i.precedence == s_j.precedence && has_prefix(&s_i.reductions, &s_j.reductions))
     }
 }
 
@@ -686,6 +680,7 @@ where
         let SuccessfulParse {
             text,
             reductions,
+            precedence: _,
             value,
         } = op(self.scope, self.text)?;