Clean up precedence parser codegen since DSL v2

.changeset/breezy-otters-heal.md

@@ -0,0 +1,5 @@
+---
+"@nomicfoundation/slang": minor
+---
+
+Remove `ProductionKind` in favor of `RuleKind`

.changeset/new-monkeys-scream.md

@@ -0,0 +1,5 @@
+---
+"@nomicfoundation/slang": minor
+---
+
+Allow parsing individual precedence expressions, like `ShiftExpression`

crates/codegen/grammar/src/precedence_parser_definition.rs

@@ -1,9 +1,7 @@
 use std::fmt::Debug;
 use std::rc::Rc;
 
-use super::{
-    GrammarVisitor, ParserDefinitionNode, ParserDefinitionRef, VersionQualityRange, Visitable,
-};
+use super::{GrammarVisitor, ParserDefinitionNode, Visitable};
 
 pub trait PrecedenceParserDefinition: Debug {
     fn name(&self) -> &'static str;
@@ -24,11 +22,11 @@ impl Visitable for PrecedenceParserDefinitionRef {
 pub struct PrecedenceParserDefinitionNode {
     pub primary_expression: Box<ParserDefinitionNode>,
     pub operators: Vec<(
-        Vec<VersionQualityRange>,
         PrecedenceOperatorModel,
         &'static str, // name
-        ParserDefinitionRef,
+        ParserDefinitionNode,
     )>,
+    pub precedence_expression_names: Vec<&'static str>,
 }
 
 impl Visitable for PrecedenceParserDefinitionNode {

crates/codegen/language/definition/src/compiler/analysis/references.rs

@@ -171,11 +171,7 @@ fn check_precedence(
     let enablement = update_enablement(analysis, enablement, enabled);
 
     for precedence_expression in precedence_expressions {
-        let SpannedPrecedenceExpression {
-            name: _,
-            rule_name: _,
-            operators,
-        } = precedence_expression;
+        let SpannedPrecedenceExpression { name: _, operators } = precedence_expression;
 
         for operator in operators {
             let SpannedPrecedenceOperator {

crates/codegen/language/definition/src/model/non_terminals/precedence.rs

@@ -20,9 +20,6 @@ pub struct PrecedenceItem {
 pub struct PrecedenceExpression {
     pub name: Identifier,
 
-    // TODO(#638): Remove this, once we adapt the DSL v1 codegen model to the new v2 definition.
-    pub rule_name: Identifier,
-
     pub operators: Vec<PrecedenceOperator>,
 }
 
@@ -37,7 +34,7 @@ pub struct PrecedenceOperator {
     pub fields: IndexMap<Identifier, Field>,
 }
 
-#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Hash, PartialOrd, Ord, Serialize)]
 #[derive_spanned_type(ParseInputTokens, WriteOutputTokens)]
 pub enum OperatorModel {
     Prefix,

crates/codegen/language/tests/src/fail/definitions/duplicate_expression_name/test.rs

@@ -14,9 +14,9 @@ codegen_language_macros::compile!(Language(
                 Precedence(
                     name = Bar,
                     precedence_expressions = [
-                        PrecedenceExpression(name = Expression1, rule_name = X, operators = []),
-                        PrecedenceExpression(name = Expression2, rule_name = X, operators = []),
-                        PrecedenceExpression(name = Expression1, rule_name = X, operators = [])
+                        PrecedenceExpression(name = Expression1, operators = []),
+                        PrecedenceExpression(name = Expression2, operators = []),
+                        PrecedenceExpression(name = Expression1, operators = [])
                     ],
                     primary_expressions = [PrimaryExpression(reference = Baz)]
                 ),

crates/codegen/language/tests/src/fail/definitions/duplicate_expression_name/test.stderr

@@ -1,5 +1,5 @@
 error: An expression with the name 'Expression1' already exists.
   --> src/fail/definitions/duplicate_expression_name/test.rs:19:53
    |
-19 |                         PrecedenceExpression(name = Expression1, rule_name = X, operators = [])
+19 |                         PrecedenceExpression(name = Expression1, operators = [])
    |                                                     ^^^^^^^^^^^

crates/codegen/parser/generator/src/code_generator.rs

@@ -7,8 +7,8 @@ use std::{
 use anyhow::Result;
 use codegen_grammar::{
     Grammar, GrammarVisitor, ParserDefinitionNode, ParserDefinitionRef,
-    PrecedenceParserDefinitionNode, PrecedenceParserDefinitionRef, ScannerDefinitionNode,
-    ScannerDefinitionRef, TriviaParserDefinitionRef,
+    PrecedenceParserDefinitionRef, ScannerDefinitionNode, ScannerDefinitionRef,
+    TriviaParserDefinitionRef,
 };
 use infra_utils::{cargo::CargoWorkspace, codegen::Codegen};
 use quote::{format_ident, quote};
@@ -27,7 +27,6 @@ pub struct CodeGenerator {
 
     rule_kinds: BTreeSet<&'static str>,
     token_kinds: BTreeSet<&'static str>,
-    production_kinds: BTreeSet<&'static str>,
     trivia_kinds: BTreeSet<&'static str>,
 
     top_level_scanner_names: BTreeSet<&'static str>,
@@ -216,7 +215,6 @@ impl GrammarVisitor for CodeGenerator {
 
     fn trivia_parser_definition_enter(&mut self, parser: &TriviaParserDefinitionRef) {
         self.set_current_context(parser.context());
-        self.production_kinds.insert(parser.name());
         self.rule_kinds.insert(parser.name());
         self.trivia_kinds.insert(parser.name());
         self.parser_functions.push((
@@ -234,7 +232,6 @@ impl GrammarVisitor for CodeGenerator {
         // Have to set this regardless so that we can collect referenced scanners
         self.set_current_context(parser.context());
         if !parser.is_inline() {
-            self.production_kinds.insert(parser.name());
             self.rule_kinds.insert(parser.name());
             let code = parser.to_parser_code();
             self.parser_functions.push((
@@ -250,11 +247,17 @@ impl GrammarVisitor for CodeGenerator {
 
     fn precedence_parser_definition_enter(&mut self, parser: &PrecedenceParserDefinitionRef) {
         self.set_current_context(parser.context());
-        self.production_kinds.insert(parser.name());
         self.rule_kinds.insert(parser.name());
-        for (_, _, name, _) in &parser.node().operators {
+        for (_, name, _) in &parser.node().operators {
             self.rule_kinds.insert(name);
         }
+
+        // While it's not common to parse a precedence expression as a standalone rule,
+        // we generate a function for completeness.
+        for (name, code) in parser.to_precedence_expression_parser_code() {
+            self.parser_functions.push((name, code.to_string()));
+        }
+
         self.parser_functions.push((
             parser.name(),
             {
@@ -315,12 +318,4 @@ impl GrammarVisitor for CodeGenerator {
             _ => {}
         };
     }
-
-    fn precedence_parser_definition_node_enter(&mut self, node: &PrecedenceParserDefinitionNode) {
-        for operator in &node.operators {
-            for vqr in &operator.0 {
-                self.referenced_versions.insert(vqr.from.clone());
-            }
-        }
-    }
 }

crates/codegen/parser/generator/src/parser_definition.rs

@@ -259,7 +259,6 @@ impl ParserDefinitionNodeExtensions for ParserDefinitionNode {
 
 pub trait VersionQualityRangeVecExtensions {
     fn wrap_code(&self, if_true: TokenStream, if_false: Option<TokenStream>) -> TokenStream;
-    fn disambiguating_name_suffix(&self) -> String;
 }
 
 impl VersionQualityRangeVecExtensions for Vec<VersionQualityRange> {
@@ -282,15 +281,4 @@ impl VersionQualityRangeVecExtensions for Vec<VersionQualityRange> {
             quote! { if #(#flags)&&* { #if_true } #else_part }
         }
     }
-
-    fn disambiguating_name_suffix(&self) -> String {
-        let mut suffix = String::new();
-        for vqr in self {
-            suffix.push('_');
-            suffix.push_str(&vqr.quality.to_string().to_lowercase());
-            suffix.push_str("_from_");
-            suffix.push_str(&vqr.from.to_string().replace('.', "_"));
-        }
-        suffix
-    }
 }