fix ebnf writer bugs

- `Scanner::Not` was serialized to a sequence, not a choice.
- render negative lookaheads, as it was hidden.
- change `Expression::Range` to primary expression.

crates/codegen/ebnf/src/builder.rs

@@ -466,7 +466,7 @@ impl Builder {
                 let expression = if chars.len() == 1 {
                     Expression::new_atom(chars[0].to_string())
                 } else {
-                    Expression::new_sequence(
+                    Expression::new_choice(
                         chars
                             .iter()
                             .map(|ch| Expression::new_atom(ch.to_string()))
@@ -485,8 +485,11 @@ impl Builder {
             Scanner::Atom { atom } => Expression::new_atom(atom.clone()),
             Scanner::TrailingContext {
                 scanner,
-                not_followed_by: _,
-            } => Self::build_scanner(scanner),
+                not_followed_by,
+            } => Expression::new_sequence(vec![
+                Self::build_scanner(scanner),
+                Expression::new_negative_look_ahead(Self::build_scanner(not_followed_by).into()),
+            ]),
             Scanner::Fragment { reference } => Self::build_ref(None, reference),
         }
     }

crates/codegen/ebnf/src/model.rs

@@ -89,6 +89,9 @@ pub enum Expression {
     Atom {
         atom: String,
     },
+    NegativeLookAhead {
+        expression: Box<Self>,
+    },
     Reference {
         leading_comment: Option<String>,
         reference: Identifier,
@@ -101,7 +104,7 @@ impl Expression {
         // This separates members of the same precedence, like both "a b (c | d)" and "a | b | (c d)".
         match self {
             // Binary
-            Self::Choice { .. } | Self::Range { .. } | Self::Sequence { .. } => 1,
+            Self::Choice { .. } | Self::Sequence { .. } => 1,
 
             // Prefix
             Self::Not { .. } => 2,
@@ -110,7 +113,10 @@ impl Expression {
             Self::OneOrMore { .. } | Self::Optional { .. } | Self::ZeroOrMore { .. } => 3,
 
             // Primary
-            Self::Atom { .. } | Self::Reference { .. } => 4,
+            Self::Range { .. }
+            | Self::Atom { .. }
+            | Self::NegativeLookAhead { .. }
+            | Self::Reference { .. } => 4,
         }
     }
 }

crates/codegen/ebnf/src/serializer.rs

@@ -140,13 +140,18 @@ impl<'s, W: EbnfWriter> Serializer<'s, W> {
                 inclusive_start,
                 inclusive_end,
             } => {
-                self.serialize_child_expr(parent, inclusive_start)?;
+                self.serialize_expr(inclusive_start)?;
                 self.serialize_punctuation("…")?;
-                self.serialize_child_expr(parent, inclusive_end)?;
+                self.serialize_expr(inclusive_end)?;
             }
             Expression::Atom { atom } => {
                 self.serialize_string_literal(atom)?;
             }
+            Expression::NegativeLookAhead { expression } => {
+                self.serialize_punctuation("(?!")?;
+                self.serialize_expr(expression)?;
+                self.serialize_punctuation(")")?;
+            }
             Expression::Reference {
                 leading_comment,
                 reference,