remove named parsers from codegen (#529)

Based on recent CST updates, we promoted named structures to top-level
productions, thus making them redundant.

This PR removes them, along with a lot of special cases to handle them
in other parts of the codebase.

crates/codegen/ebnf/src/parser.rs

@@ -4,12 +4,7 @@ use crate::{nodes::EbnfNode, serialization::GenerateEbnf};
 
 impl GenerateEbnf for ParserRef {
     fn generate_ebnf(&self) -> EbnfNode {
-        let definition = self.definition.generate_ebnf();
-
-        return match &self.name {
-            None => definition,
-            Some(name) => EbnfNode::sub_statement(name.to_owned(), None, definition),
-        };
+        return self.definition.generate_ebnf();
     }
 }
 

crates/codegen/schema/src/types/parser.rs

@@ -8,8 +8,6 @@ pub type ParserRef = std::rc::Rc<Parser>;
 #[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, PartialEq, Eq, Hash)]
 #[serde(deny_unknown_fields)]
 pub struct Parser {
-    #[serde(default)]
-    pub name: Option<String>,
     #[serde(flatten)]
     pub definition: ParserDefinition,
 }

crates/codegen/schema/src/validation/rules/definitions/mod.rs

@@ -1,13 +1,13 @@
 mod keywords;
-mod parsers;
+mod operators;
 mod productions;
 mod versions;
 
 use crate::{
     types::LanguageDefinitionRef,
     validation::{
         rules::definitions::{
-            keywords::Keywords, parsers::Parsers, productions::Productions, versions::Versions,
+            keywords::Keywords, operators::Operators, productions::Productions, versions::Versions,
         },
         visitors::Reporter,
     },
@@ -17,10 +17,10 @@ use codegen_utils::errors::CodegenResult;
 pub fn run(language: &LanguageDefinitionRef) -> CodegenResult<()> {
     let mut reporter = Reporter::new();
 
+    Keywords::validate(language, &mut reporter);
+    Operators::validate(language, &mut reporter);
     Productions::validate(language, &mut reporter);
     Versions::validate(language, &mut reporter);
-    Parsers::validate(language, &mut reporter);
-    Keywords::validate(language, &mut reporter);
 
     return reporter.to_result();
 }

crates/codegen/schema/src/validation/rules/definitions/operators/mod.rs

@@ -0,0 +1,103 @@
+use std::collections::HashMap;
+
+use crate::{
+    types::{LanguageDefinitionRef, PrecedenceParserRef, ProductionRef},
+    validation::visitors::{run_visitor, LocationRef, Reporter, Visitor},
+};
+
+pub struct Operators {
+    language: LanguageDefinitionRef,
+    current_production: Option<ProductionRef>,
+    operators_already_seen: HashMap<String, ProductionRef>,
+}
+
+impl Operators {
+    pub fn validate(language: &LanguageDefinitionRef, reporter: &mut Reporter) {
+        let mut instance = Self {
+            language: language.to_owned(),
+
+            current_production: None,
+            operators_already_seen: HashMap::new(),
+        };
+
+        run_visitor(&mut instance, language, reporter);
+    }
+}
+
+impl Visitor for Operators {
+    fn visit_production(
+        &mut self,
+        production: &ProductionRef,
+        _location: &LocationRef,
+        _reporter: &mut Reporter,
+    ) -> bool {
+        self.current_production = Some(production.to_owned());
+        return true;
+    }
+
+    fn visit_parser(
+        &mut self,
+        _parser: &crate::types::ParserRef,
+        _location: &LocationRef,
+        _reporter: &mut Reporter,
+    ) -> bool {
+        return false; // skip
+    }
+
+    fn visit_scanner(
+        &mut self,
+        _scanner: &crate::types::ScannerRef,
+        _location: &LocationRef,
+        _reporter: &mut Reporter,
+    ) -> bool {
+        return false; // skip
+    }
+
+    fn visit_precedence_parser(
+        &mut self,
+        parser: &PrecedenceParserRef,
+        location: &LocationRef,
+        reporter: &mut Reporter,
+    ) -> bool {
+        for operator in parser.operators.iter() {
+            let name = &operator.name;
+            if self.language.productions.contains_key(name) {
+                reporter.report(location, Errors::OperatorNamedAsProduction(name.to_owned()));
+                continue;
+            }
+
+            let current_production = self.current_production.as_ref().unwrap();
+
+            match self.operators_already_seen.get(name) {
+                Some(existing_production) => {
+                    if current_production.name == existing_production.name {
+                        // Operators can share a common name under the same production.
+                        continue;
+                    }
+
+                    reporter.report(
+                        location,
+                        Errors::OperatorDefinedInAnotherProduction(
+                            name.to_owned(),
+                            existing_production.name.to_owned(),
+                        ),
+                    );
+                }
+                None => {
+                    self.operators_already_seen
+                        .insert(name.to_owned(), current_production.to_owned());
+                }
+            };
+        }
+
+        return false;
+    }
+}
+
+#[derive(thiserror::Error, Debug)]
+enum Errors {
+    #[error("Operator '{0}' cannot have the same name as a top-level production.")]
+    OperatorNamedAsProduction(String),
+    #[error("Operator '{0}' is defined in another production '{1}'.")]
+    OperatorDefinedInAnotherProduction(String, String),
+}

crates/codegen/schema/src/validation/rules/lints/children_count.rs

@@ -53,7 +53,7 @@ impl Visitor for ChildrenCount {
     ) -> bool {
         match &parser.definition {
             ParserDefinition::Choice(children) | ParserDefinition::Sequence(children) => {
-                if parser.name.is_none() && children.len() < 2 {
+                if children.len() < 2 {
                     reporter.report(location, Errors::MinChildrenCount(2));
                 }
             }

crates/codegen/schema/src/validation/rules/lints/consistent_shape.rs

@@ -80,10 +80,6 @@ impl Visitor for ConsistentShape {
 
 impl ConsistentShape {
     fn is_single_named(&self, parser: &ParserRef) -> bool {
-        if parser.name.is_some() {
-            return true;
-        }
-
         match &parser.definition {
             ParserDefinition::Choice(_)
             | ParserDefinition::DelimitedBy { .. }