yeast: Reject duplicate capture names

Currently, it's legal to write something like
```
(foo bar: (bar) @item
     baz: (baz) @item
)
```
with the effect that `item` gets both the `bar` and the `baz` that were
matched. This is not behaviour that we actually use, and it also goes
somewhat against the "pattern matching" semantics that queries/patterns
are intended to have. Since it's not a feature that we're actually using
anywhere, I decided the easiest solution would be to simply make
multiple occurrences of the same capture variable a compile-time error.

Author: tausbn

shared/yeast-macros/src/lower.rs

@@ -190,6 +190,7 @@ impl Pattern {
             }
         }
     }
+
     fn captures(&self) -> Vec<CaptureBinding> {
         let mut captures = Vec::new();
         self.collect_captures(Cardinality::SINGLE, &mut captures);

shared/yeast-macros/src/rule_parse.rs

@@ -1,4 +1,5 @@
 use proc_macro2::{Delimiter, Ident, Span, TokenStream, TokenTree};
+use std::collections::BTreeSet;
 use std::iter::Peekable;
 
 use crate::ast::{Cardinality, Pattern, Replacement, ReturnAnnotation, Rule};
@@ -15,9 +16,46 @@ pub(crate) fn parse_pattern(input: TokenStream) -> Result<Pattern> {
             "unexpected token after query",
         ));
     }
+    validate_unique_capture_names(&pattern, &mut BTreeSet::new())?;
     Ok(pattern)
 }
 
+fn validate_unique_capture_names(
+    pattern: &Pattern,
+    capture_names: &mut BTreeSet<String>,
+) -> Result<()> {
+    match pattern {
+        Pattern::Any { .. } | Pattern::Unnamed(_) => {}
+        Pattern::Node { fields, .. } => {
+            for (_, pattern) in fields {
+                validate_unique_capture_names(pattern, capture_names)?;
+            }
+        }
+        Pattern::Capture { name, pattern, .. } => {
+            validate_unique_capture_names(pattern, capture_names)?;
+            let name_string = name.to_string();
+            if !capture_names.insert(name_string.clone()) {
+                return Err(syn::Error::new_spanned(
+                    name,
+                    format!(
+                        "capture `{name_string}` is used more than once; \
+                         use a distinct name for each capture site"
+                    ),
+                ));
+            }
+        }
+        Pattern::Sequence(patterns) => {
+            for pattern in patterns {
+                validate_unique_capture_names(pattern, capture_names)?;
+            }
+        }
+        Pattern::Repeated { pattern, .. } => {
+            validate_unique_capture_names(pattern, capture_names)?;
+        }
+    }
+    Ok(())
+}
+
 pub(crate) fn parse_rule(input: TokenStream) -> Result<Rule> {
     let (pattern_and_guard, replacement) = split_arrow(input)?;
     let (pattern, guard) = split_guard(pattern_and_guard)?;
@@ -590,6 +628,22 @@ mod tests {
         );
     }
 
+    #[test]
+    fn rejects_duplicate_capture_names() {
+        let result = parse_pattern(quote! {
+            (assignment
+                left: (_) @item
+                right: (_) @item)
+        });
+        let Err(error) = result else {
+            panic!("expected duplicate capture name to be rejected");
+        };
+        assert_eq!(
+            error.to_string(),
+            "capture `item` is used more than once; use a distinct name for each capture site"
+        );
+    }
+
     #[test]
     fn parses_literal_led_repeated_sequence() {
         let pattern = parse_pattern(quote!((root ("+" ",")*))).unwrap();