Update gll and grammer. (#65)

Update gll and grammer.

Author: eddyb

Cargo.toml

@@ -33,5 +33,5 @@ name = "snapshots"
 path = "src/bin/snapshots.rs"
 
 [patch.'crates-io']
-gll = { git = "https://github.com/rust-lang/gll", rev = "617ecfc58a554c92226ec276063c99a09678fb05" }
-grammer = { git = "https://github.com/lykenware/grammer", rev = "eb47b51a9332c0e82d7c02d988e203d2a01f3654" }
+gll = { git = "https://github.com/rust-lang/gll", rev = "26d42a0117b9c48538ef20c872742e05070bb55e" }
+grammer = { git = "https://github.com/lykenware/grammer", rev = "6f6f1320336d84b75805907fb302a28cb6d4cfb0" }

build.rs

@@ -17,9 +17,9 @@ fn main() {
         .filter(|entry| entry.path().extension().map_or(false, |ext| ext == "lyg"));
 
     // Start with the builtin rules for proc-macro grammars.
-    let mut cx = gll::proc_macro::Context::new();
+    let mut cx = gll::grammer::proc_macro::Context::new();
     let cx = &mut cx;
-    let mut grammar = gll::proc_macro::builtin(cx);
+    let mut grammar = gll::grammer::proc_macro::builtin(cx);
 
     // Add in each grammar fragment to the grammar.
     for fragment in fragments {

src/bin/coverage.rs

@@ -9,10 +9,7 @@ use std::{
 };
 
 use derive_more::Add;
-use gll::{
-    forest::{MoreThanOne, GrammarReflector},
-    parse_node::ParseNodeShape,
-};
+use gll::grammer::forest::{GrammarReflector, MoreThanOne, NodeShape};
 use rayon::prelude::*;
 use rust_grammar::parse;
 use serde::{Deserialize, Serialize};
@@ -72,26 +69,29 @@ enum Command {
     },
 }
 
-type ModuleContentsResult = Result<ModuleContentsHandle, Error<proc_macro2::Span>>;
+type ProcMacroPat =
+    gll::grammer::proc_macro::Pat<&'static [gll::grammer::proc_macro::FlatTokenPat<&'static str>]>;
+
+type ModuleContentsResult = Result<ModuleContentsHandle, Error<proc_macro2::Span, ProcMacroPat>>;
 
 type ModuleContentsHandle = parse::OwnedHandle<
     proc_macro2::TokenStream,
     parse::ModuleContents<'static, 'static, proc_macro2::TokenStream>,
 >;
 
-enum Error<A> {
+enum Error<A, Pat> {
     Lex(proc_macro2::LexError),
-    Parse(gll::parser::ParseError<A>),
+    Parse(gll::grammer::parser::ParseError<A, Pat>),
 }
 
-impl<A> From<proc_macro2::LexError> for Error<A> {
+impl<A, Pat> From<proc_macro2::LexError> for Error<A, Pat> {
     fn from(error: proc_macro2::LexError) -> Self {
         Error::Lex(error)
     }
 }
 
-impl<A> From<gll::parser::ParseError<A>> for Error<A> {
-    fn from(error: gll::parser::ParseError<A>) -> Self {
+impl<A, Pat> From<gll::grammer::parser::ParseError<A, Pat>> for Error<A, Pat> {
+    fn from(error: gll::grammer::parser::ParseError<A, Pat>) -> Self {
         Error::Parse(error)
     }
 }
@@ -139,15 +139,9 @@ fn report_file_result(
                     "(missing location information; \
                      set `RUSTFLAGS='--cfg procmacro2_semver_exempt'`)"
                 );
-
             }
 
-            // HACK(eddyb) this is inefficient - `expected` should be already
-            // sorted for us, so this is a temporary workaround.
-            let mut expected = error.expected.clone();
-            expected.sort_by_cached_key(|x| format!("{:?}", x));
-
-            eprintln!("Expected: {:?}", expected);
+            eprintln!("Expected: {:?}", error.expected);
         }
         (Err(Error::Lex(e)), _) => eprintln!("FAIL ({:?})", e),
     }
@@ -169,16 +163,16 @@ fn ambiguity_check(handle: &ModuleContentsHandle) -> Result<(), MoreThanOne> {
                     }
                 }
             };
-            match forest.grammar.parse_node_shape(source.kind) {
-                ParseNodeShape::Opaque => {}
-                ParseNodeShape::Alias(_) => add_children(&[forest.unpack_alias(source)]),
-                ParseNodeShape::Opt(_) => {
+            match forest.grammar.node_shape(source.kind) {
+                NodeShape::Opaque => {}
+                NodeShape::Alias(_) => add_children(&[forest.unpack_alias(source)]),
+                NodeShape::Opt(_) => {
                     if let Some(child) = forest.unpack_opt(source) {
                         add_children(&[child]);
                     }
                 }
-                ParseNodeShape::Choice => add_children(&[forest.one_choice(source)?]),
-                ParseNodeShape::Split(..) => {
+                NodeShape::Choice => add_children(&[forest.one_choice(source)?]),
+                NodeShape::Split(..) => {
                     let (left, right) = forest.one_split(source)?;
                     add_children(&[left, right])
                 }

src/bin/snapshots.rs

@@ -9,15 +9,13 @@ use {
     walkdir::WalkDir,
 };
 
+type ProcMacroPat =
+    gll::grammer::proc_macro::Pat<&'static [gll::grammer::proc_macro::FlatTokenPat<&'static str>]>;
+
 fn parse_result_to_str<T: Debug>(
-    mut result: Result<T, gll::parser::ParseError<proc_macro2::Span>>,
+    result: Result<T, gll::grammer::parser::ParseError<proc_macro2::Span, ProcMacroPat>>,
 ) -> String {
-    if let Err(error) = &mut result {
-        // HACK(eddyb) this is inefficient - `expected` should be already
-        // sorted for us, so this is a temporary workaround.
-        error.expected.sort_by_cached_key(|x| format!("{:?}", x));
-    }
-
+    // FIXME(eddyb) print the location properly in case of error.
     format!("{:#?}", result)
 }