yeast: Consolidate multiple captures appropriately

Getting even more into the weeds of the query matching semantics, what
should something like
```
(foo bar: (bar) @item
     baz: (baz) @@item
)
```
do?

Or what about something like
```
(foo bar: (bar) @item
     baz: (baz)* @item
)
```
?

At present, we permit captures to have multiple occurrences in a query.
Each occurrence simply pushes yet another value into the capture.
With this in mind, the sensible semantics (which we implement in this
commit) seem to be the following:

- If any of the captures (with a given identifier) are raw, then so is
  the entire capture.
- If we capture both individual items and lists, then the entire capture
  is a list.

Note that we don't actually (as far as I know) use these constructions
anywhere, but the previous behaviour would just cause weird things to
potentially happen. At least now the behaviour should be a bit more
predictable.

Author: tausbn

shared/yeast-macros/src/lower.rs

@@ -193,8 +193,27 @@ impl Pattern {
     }
 
     fn captures(&self) -> Vec<BoundCapture> {
-        let mut captures = Vec::new();
-        self.collect_captures(Cardinality::SINGLE, &mut captures);
+        let mut occurrences = Vec::new();
+        self.collect_captures(Cardinality::SINGLE, &mut occurrences);
+
+        let mut captures: Vec<BoundCapture> = Vec::new();
+        for occurrence in occurrences {
+            if let Some(existing) = captures
+                .iter_mut()
+                .find(|capture| capture.capture.name == occurrence.capture.name)
+            {
+                // Two capture sites can both contribute values, so their
+                // combined binding is necessarily a vector even when each
+                // occurrence captures at most one node.
+                existing.cardinality.multiple = true;
+                existing.cardinality.required &= occurrence.cardinality.required;
+                // Captures are stored by name at runtime. If any occurrence is
+                // raw, the whole bucket must remain untranslated.
+                existing.capture.raw |= occurrence.capture.raw;
+            } else {
+                captures.push(occurrence);
+            }
+        }
         captures
     }
 

shared/yeast/tests/test.rs

@@ -468,6 +468,50 @@ fn test_query_repeated_capture() {
     assert_eq!(captures.get_all("names").len(), 3);
 }
 
+#[test]
+fn test_reused_capture_name_is_promoted_to_vector() {
+    let rules: Vec<Rule> = vec![yeast::rule!(
+        (assignment
+            left: (_) @items
+            right: (_) @items)
+        =>
+        identifier {
+            let items: Vec<yeast::Id> = items;
+            tree!((identifier #{items.len()}))
+        }
+    )];
+
+    assert_dump_eq(
+        &run_and_dump("x = 1", rules),
+        r#"
+        program
+          identifier "2"
+    "#,
+    );
+}
+
+#[test]
+fn test_reused_capture_name_combines_single_and_repeated_sites() {
+    let rules: Vec<Rule> = vec![yeast::rule!(
+        (assignment
+            "="? @@items
+            left: (identifier)* @@items)
+        =>
+        identifier {
+            let items: Vec<yeast::Id> = items;
+            tree!((identifier #{items.len()}))
+        }
+    )];
+
+    assert_dump_eq(
+        &run_and_dump("x = 1", rules),
+        r#"
+        program
+          identifier "2"
+    "#,
+    );
+}
+
 #[test]
 fn test_capture_unnamed_node_parenthesized() {
     // `("=") @op` captures the unnamed `=` token between left and right.