use labels for AST selectors

Uses labels to select AST nodes, which is more accurate, requires less code (instead of checking individual kinds), and also fixes a bug where additional `TerminalKind`s of `PrecedenceOperator` are not taken into account.

Closes NomicFoundation#872
Closes NomicFoundation#986

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

@@ -4,7 +4,10 @@ use std::rc::Rc;
 use crate::compiler::analysis::{Analysis, ItemMetadata};
 use crate::compiler::version_set::VersionSet;
 use crate::internals::Spanned;
-use crate::model::{Identifier, SpannedItem, SpannedVersionSpecifier};
+use crate::model::{
+    Identifier, SpannedField, SpannedItem, SpannedOperatorModel, SpannedPrecedenceOperator,
+    SpannedVersionSpecifier,
+};
 
 pub(crate) fn analyze_definitions(analysis: &mut Analysis) {
     collect_top_level_items(analysis);
@@ -84,6 +87,15 @@ fn check_precedence_items(analysis: &mut Analysis) {
             }
 
             current_expressions.insert(name);
+
+            // Make sure all operators have the same structure, as they are represented using the same AST type:
+            let first_op = &precedence_expression.operators[0];
+            for second_op in precedence_expression.operators.iter().skip(1) {
+                if !compare_operators(analysis, first_op, second_op) {
+                    analysis.errors.add(name, &Errors::OperatorMismatch);
+                    continue;
+                }
+            }
         }
 
         for primary_expression in &item.primary_expressions {
@@ -98,6 +110,76 @@ fn check_precedence_items(analysis: &mut Analysis) {
     }
 }
 
+fn compare_operators(
+    analysis: &mut Analysis,
+    first_op: &SpannedPrecedenceOperator,
+    second_op: &SpannedPrecedenceOperator,
+) -> bool {
+    match (&*first_op.model, &*second_op.model) {
+        // Allow it if they are both prefixes:
+        (SpannedOperatorModel::Prefix, SpannedOperatorModel::Prefix)
+        // Allow it if they are both suffixes:
+        | (SpannedOperatorModel::Postfix, SpannedOperatorModel::Postfix)
+        // Allow it if they are both binary (regardless of associativity):
+        | (
+            SpannedOperatorModel::BinaryLeftAssociative
+            | SpannedOperatorModel::BinaryRightAssociative,
+            SpannedOperatorModel::BinaryLeftAssociative
+            | SpannedOperatorModel::BinaryRightAssociative,
+        ) => {}
+        _ => return false,
+    };
+
+    // Must have the same number of fields:
+    if first_op.fields.len() != second_op.fields.len() {
+        return false;
+    }
+
+    for ((first_key, first_field), (second_key, second_field)) in
+        first_op.fields.iter().zip(second_op.fields.iter())
+    {
+        // Must have the same labels:
+        if first_key != second_key {
+            return false;
+        }
+
+        let (
+            // Allow it if both are required:
+            (
+                SpannedField::Required { reference: first_ref },
+                SpannedField::Required { reference: second_ref },
+            )
+            // Allow it if both are optional (regardless of enablement):
+            | (
+                SpannedField::Optional { reference: first_ref, enabled: _ },
+                SpannedField::Optional { reference: second_ref, enabled: _ },
+            )
+        ) = (first_field, second_field)
+        else {
+            return false;
+        };
+
+        // Allow it if they both reference the same exact kind:
+        if first_ref == second_ref {
+            continue;
+        }
+
+        // Otherwise, allow it if both are terminals:
+        match (
+            &analysis.metadata[&**first_ref].item,
+            &analysis.metadata[&**second_ref].item,
+        ) {
+            (
+                SpannedItem::Keyword { .. } | SpannedItem::Token { .. },
+                SpannedItem::Keyword { .. } | SpannedItem::Token { .. },
+            ) => {}
+            _ => return false,
+        }
+    }
+
+    true
+}
+
 fn get_item_name(item: &SpannedItem) -> &Spanned<Identifier> {
     match item {
         SpannedItem::Struct { item } => &item.name,
@@ -169,4 +251,6 @@ enum Errors<'err> {
     ExistingVariant(&'err Identifier),
     #[error("An expression with the name '{0}' already exists.")]
     ExistingExpression(&'err Identifier),
+    #[error("All operators under the same expression must have the same model and type.")]
+    OperatorMismatch,
 }

crates/codegen/language/definition/src/model/manifest.rs

@@ -128,7 +128,9 @@ pub struct Topic {
     pub items: Vec<Item>,
 }
 
-#[derive(strum_macros::AsRefStr, strum_macros::EnumIter, strum_macros::VariantNames)]
+#[derive(
+    Clone, Copy, Debug, strum_macros::AsRefStr, strum_macros::EnumIter, strum_macros::VariantNames,
+)]
 #[strum(serialize_all = "snake_case")]
 pub enum BuiltInLabel {
     Item,

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

@@ -15,9 +15,27 @@ codegen_language_macros::compile!(Language(
                 Precedence(
                     name = Bar,
                     precedence_expressions = [
-                        PrecedenceExpression(name = Expression1, operators = []),
-                        PrecedenceExpression(name = Expression2, operators = []),
-                        PrecedenceExpression(name = Expression1, operators = [])
+                        PrecedenceExpression(
+                            name = Expression1,
+                            operators = [PrecedenceOperator(
+                                model = BinaryLeftAssociative,
+                                fields = (operator = Required(Baz))
+                            )]
+                        ),
+                        PrecedenceExpression(
+                            name = Expression2,
+                            operators = [PrecedenceOperator(
+                                model = BinaryLeftAssociative,
+                                fields = (operator = Required(Baz))
+                            )]
+                        ),
+                        PrecedenceExpression(
+                            name = Expression1,
+                            operators = [PrecedenceOperator(
+                                model = BinaryLeftAssociative,
+                                fields = (operator = Required(Baz))
+                            )]
+                        )
                     ],
                     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:20:53
+  --> src/fail/definitions/duplicate_expression_name/test.rs:33:36
    |
-20 |                         PrecedenceExpression(name = Expression1, operators = [])
-   |                                                     ^^^^^^^^^^^
+33 | ...                   name = Expression1,
+   |                              ^^^^^^^^^^^

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

@@ -0,0 +1,41 @@
+#![allow(unused_crate_dependencies)]
+
+codegen_language_macros::compile!(Language(
+    name = Foo,
+    documentation_dir = "foo/bar",
+    root_item = Bar,
+    leading_trivia = Sequence([]),
+    trailing_trivia = Sequence([]),
+    versions = ["1.0.0"],
+    sections = [Section(
+        title = "Section One",
+        topics = [Topic(
+            title = "Topic One",
+            items = [
+                Precedence(
+                    name = Expression,
+                    precedence_expressions = [PrecedenceExpression(
+                        name = Foo,
+                        operators = [
+                            PrecedenceOperator(
+                                model = BinaryLeftAssociative,
+                                fields = (operator = Required(Baz1))
+                            ),
+                            PrecedenceOperator(
+                                model = Prefix,
+                                fields = (operator = Required(Baz1))
+                            )
+                        ]
+                    )],
+                    primary_expressions = [PrimaryExpression(reference = Baz1)]
+                ),
+                Token(
+                    name = Baz1,
+                    definitions = [TokenDefinition(scanner = Atom("baz1"))]
+                )
+            ]
+        )]
+    )]
+));
+
+fn main() {}

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

@@ -0,0 +1,5 @@
+error: All operators under the same expression must have the same model and type.
+  --> src/fail/definitions/operator_mismatch/test.rs:18:32
+   |
+18 |                         name = Foo,
+   |                                ^^^