fix(ebnf): round-trip negation and lookahead assertions

ebnf/ebnf.go

@@ -41,15 +41,19 @@ type Term struct {
 func (t *Term) sealed() {}
 
 func (t *Term) String() string {
+	negation := ""
+	if t.Negation {
+		negation = "~"
+	}
 	switch {
 	case t.Name != "":
-		return t.Name + t.Repetition
+		return negation + t.Name + t.Repetition
 	case t.Literal != "":
-		return t.Literal + t.Repetition
+		return negation + t.Literal + t.Repetition
 	case t.Token != "":
-		return "<" + t.Token + ">" + t.Repetition
+		return negation + "<" + t.Token + ">" + t.Repetition
 	case t.Group != nil:
-		return t.Group.String() + t.Repetition
+		return negation + t.Group.String() + t.Repetition
 	default:
 		panic("??")
 	}
@@ -92,7 +96,7 @@ func (s *SubExpression) sealed() {}
 func (s *SubExpression) String() string {
 	out := "("
 	if s.Lookahead != LookaheadAssertionNone {
-		out += "?" + string(s.Lookahead)
+		out += "?" + string(s.Lookahead) + " "
 	}
 	out += s.Expr.String() + ")"
 	return out

ebnf/ebnf_test.go

@@ -13,3 +13,28 @@ func TestEBNF(t *testing.T) {
 	require.NoError(t, err, input)
 	require.Equal(t, input, ast.String())
 }
+
+func TestEBNFRoundTrip(t *testing.T) {
+	tests := []struct {
+		name  string
+		input string
+	}{
+		{"NegatedLiteral", `Term = ~"a" .`},
+		{"NegatedToken", `Term = ~<ident> .`},
+		{"NegatedProduction", `Term = ~Production .`},
+		{"NegatedGroup", `Term = ~("a" | "b") .`},
+		{"NegatedRepetition", `Term = ~"a"+ .`},
+		{"PositiveLookahead", `Term = (?= "a") "b" .`},
+		{"NegativeLookahead", `Term = (?! "a") "b" .`},
+		// Verbatim output of Parser.String() for the grammar in
+		// TestEBNF_Other in the root package.
+		{"ParserOutput", `Grammar = ((?= "good") <ident>) | ((?! "bad" | "worse") <ident>) | ~("anything" | "but") .`},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			ast, err := ParseString(test.input)
+			require.NoError(t, err, test.input)
+			require.Equal(t, test.input, ast.String())
+		})
+	}
+}