C#: Allow Capture objects as MatchResult keys (#7074)

Add ICapture interface so MatchResult.Of() can accept Capture objects
as keys instead of only strings. This enables working with unnamed
(auto-generated) captures without manually synchronizing string names
between template creation and value binding.

Author: knutwannheden

rewrite-csharp/csharp/OpenRewrite/CSharp/Template/Capture.cs

@@ -32,14 +32,23 @@ internal enum CaptureKind
     Name,
 }
 
+/// <summary>
+/// Non-generic interface for captures, providing access to the capture name
+/// without requiring knowledge of the captured type.
+/// </summary>
+public interface ICapture
+{
+    string Name { get; }
+}
+
 /// <summary>
 /// A named placeholder for pattern matching and template substitution.
 /// When used in an interpolated string passed to <see cref="CSharpTemplate.Create"/>
 /// or <see cref="CSharpPattern.Create"/>, the <see cref="TemplateStringHandler"/>
 /// intercepts it and registers the capture automatically.
 /// </summary>
 /// <typeparam name="T">The type of AST node this capture matches.</typeparam>
-public sealed class Capture<T> where T : J
+public sealed class Capture<T> : ICapture where T : J
 {
     public string Name { get; }
     public bool IsVariadic { get; }

rewrite-csharp/csharp/OpenRewrite/CSharp/Template/MatchResult.cs

@@ -52,6 +52,31 @@ public static MatchResult Of(params (string name, J value)[] captures)
         return new MatchResult(dict);
     }
 
+    /// <summary>
+    /// Create a <see cref="MatchResult"/> from <see cref="ICapture"/> keys.
+    /// This allows using unnamed captures (with auto-generated names) as keys,
+    /// avoiding the need to manually synchronize string names between template
+    /// creation and value binding.
+    /// </summary>
+    /// <example>
+    /// <code>
+    /// var left = Capture.Expression();
+    /// var right = Capture.Expression();
+    /// var template = CSharpTemplate.Expression($"{left} &amp;&amp; {right}");
+    /// var values = MatchResult.Of((left, outerCond), (right, innerCond));
+    /// var result = template.Apply(cursor, values: values);
+    /// </code>
+    /// </example>
+    public static MatchResult Of(params (ICapture capture, J value)[] captures)
+    {
+        var dict = new Dictionary<string, object>(captures.Length);
+        foreach (var (capture, value) in captures)
+        {
+            dict[capture.Name] = value;
+        }
+        return new MatchResult(dict);
+    }
+
     /// <summary>
     /// Get a captured value by name.
     /// </summary>
@@ -64,6 +89,13 @@ public static MatchResult Of(params (string name, J value)[] captures)
     public T? Get<T>(Capture<T> capture) where T : class, J
         => Get<T>(capture.Name);
 
+    /// <summary>
+    /// Get a captured value by its <see cref="ICapture"/> object.
+    /// Useful when the capture's type parameter doesn't match the desired return type.
+    /// </summary>
+    public T? Get<T>(ICapture capture) where T : class, J
+        => Get<T>(capture.Name);
+
     /// <summary>
     /// Get a variadic capture result as a list.
     /// Handles both IReadOnlyList&lt;T&gt; and IReadOnlyList&lt;object&gt; (from pattern matcher).
@@ -84,5 +116,10 @@ public IReadOnlyList<T> GetList<T>(string name) where T : class, J
     /// </summary>
     public bool Has(string name) => _captures.ContainsKey(name);
 
+    /// <summary>
+    /// Check if a capture was bound.
+    /// </summary>
+    public bool Has(ICapture capture) => _captures.ContainsKey(capture.Name);
+
     internal Dictionary<string, object> AsDict() => _captures;
 }

rewrite-csharp/csharp/OpenRewrite/Tests/Template/ScaffoldStrategyTests.cs

@@ -236,6 +236,22 @@ public void MatchResultOfCreatesManualBindings()
         Assert.Equal(42, lit!.Value);
     }
 
+    [Fact]
+    public void MatchResultOfWithUnnamedCaptures()
+    {
+        var x = Capture.Expression();
+        var y = Capture.Expression();
+        var lit1 = new Literal(Guid.NewGuid(), Space.Empty, Markers.Empty, 1, "1", null, null);
+        var lit2 = new Literal(Guid.NewGuid(), Space.Empty, Markers.Empty, 2, "2", null, null);
+
+        var values = MatchResult.Of((x, lit1), (y, lit2));
+
+        Assert.True(values.Has(x));
+        Assert.True(values.Has(y));
+        Assert.Equal(1, values.Get<Literal>(x)!.Value);
+        Assert.Equal(2, values.Get<Literal>(y)!.Value);
+    }
+
     // === Cache isolation ===
 
     [Fact]