Remove "negative lookahead" misfeature.

Author: eddyb

Cargo.toml

@@ -31,7 +31,7 @@ doctest = false
 test = false
 
 [patch.'crates-io']
-grammer = { git = "https://github.com/lykenware/grammer", rev = "e108acbe83271761538bf5b2ff2daeaaafa5919c" }
+grammer = { git = "https://github.com/lykenware/grammer", rev = "ed4fc4f9be9aa2c1a6c3245ba4e91684ddff5f2f" }
 
 [workspace]
 members = [

src/generate/rust.rs

@@ -116,7 +116,7 @@ impl<Pat> RuleTypeMethods for Rule<Pat> {
 
     fn field_type(&self, path: &[usize]) -> Src {
         match self {
-            Rule::Empty | Rule::Eat(_) | Rule::NegativeLookahead(_) => {
+            Rule::Empty | Rule::Eat(_) => {
                 assert_eq!(path, []);
                 quote!(())
             }
@@ -199,7 +199,6 @@ impl<Pat: Ord + Hash + RustInputPat> RuleRuleMapMethods<Pat> for Rule<Pat> {
         match self {
             Rule::Empty => "".to_string(),
             Rule::Eat(pat) => pat.rust_matcher().to_pretty_string(),
-            Rule::NegativeLookahead(pat) => format!("!{}", pat.rust_matcher().to_pretty_string()),
             Rule::Call(r) => r.clone(),
             Rule::Concat([left, right]) => format!(
                 "({} {})",
@@ -246,7 +245,7 @@ impl<Pat: Ord + Hash + RustInputPat> RuleRuleMapMethods<Pat> for Rule<Pat> {
         rules: &RuleMap<'_, Pat>,
     ) -> ParseNodeShape<ParseNodeKind> {
         match &**rc_self {
-            Rule::Empty | Rule::Eat(_) | Rule::NegativeLookahead(_) => ParseNodeShape::Opaque,
+            Rule::Empty | Rule::Eat(_) => ParseNodeShape::Opaque,
             Rule::Call(_) => unreachable!(),
             Rule::Concat([left, right]) => {
                 ParseNodeShape::Split(left.parse_node_kind(rules), right.parse_node_kind(rules))
@@ -802,10 +801,6 @@ impl<Pat: Ord + Hash + RustInputPat> RuleGenerateMethods<Pat> for Rule<Pat> {
                 let pat = pat.rust_matcher();
                 check(quote!(let Some(_range) = p.input_consume_left(_range, &(#pat)))).apply(cont)
             }
-            (Rule::NegativeLookahead(pat), _) => {
-                let pat = pat.rust_matcher();
-                check(quote!(!p.input_lookahead_left(_range, &(#pat)))).apply(cont)
-            }
             (Rule::Call(r), _) => call(Rc::new(CodeLabel::NamedRule(r.clone()))).apply(cont),
             (Rule::Concat([left, right]), None) => {
                 (left.generate_parse(None) + right.generate_parse(None)).apply(cont)
@@ -902,7 +897,6 @@ impl<Pat: Ord + Hash + RustInputPat> RuleGenerateMethods<Pat> for Rule<Pat> {
         match self {
             Rule::Empty
             | Rule::Eat(_)
-            | Rule::NegativeLookahead(_)
             | Rule::Call(_)
             | Rule::RepeatMany(..)
             | Rule::RepeatMore(..) => {

src/parse_grammar.rs

@@ -67,9 +67,6 @@ impl Primary<'_, '_, TokenStream> {
     fn lower<Pat: From<SPat>>(self) -> grammer::RuleWithNamedFields<Pat> {
         match self {
             Primary::Eat(pat) => grammer::eat(pat.one().unwrap().lower()),
-            Primary::NegativeLookahead { pat } => {
-                grammer::negative_lookahead(pat.one().unwrap().lower())
-            }
             Primary::Call(name) => {
                 let name = match name.source() {
                     [FlatToken::Ident(ident)] => ident.to_string(),

src/runtime.rs

@@ -367,13 +367,6 @@ impl<'i, C: CodeStep<I>, I: Input> Parser<'i, C, I> {
         }
     }
 
-    pub fn input_lookahead_left<Pat>(&mut self, range: Range<'i>, pat: &'static Pat) -> bool
-    where
-        I::Slice: InputMatch<Pat>,
-    {
-        self.forest.input(range).match_left(pat).is_some()
-    }
-
     pub fn input_consume_right<Pat>(&self, range: Range<'i>, pat: &'static Pat) -> Option<Range<'i>>
     where
         I::Slice: InputMatch<Pat>,
@@ -385,13 +378,6 @@ impl<'i, C: CodeStep<I>, I: Input> Parser<'i, C, I> {
             .map(|n| Range(range.split_at(range.len() - n).0))
     }
 
-    pub fn input_lookbehind_right<Pat>(&self, range: Range<'i>, pat: &'static Pat) -> bool
-    where
-        I::Slice: InputMatch<Pat>,
-    {
-        self.forest.input(range).match_right(pat).is_some()
-    }
-
     pub fn forest_add_choice(
         &mut self,
         kind: C::ParseNodeKind,