C#: Fix typed capture type resolution and improve type system (#7126)

* C#: Remove RewriteRule.Rewrite(TemplateStringHandler) shorthand

The `Rewrite(TemplateStringHandler, TemplateStringHandler)` overload
created patterns without `usings`, so typed captures with generic types
(e.g., `IDictionary<TKey, TValue>`) silently failed — the scaffold had
no semantic model and type constraints fell back to string matching.

Removing the shorthand forces callers through the explicit
`CSharpPattern`/`CSharpTemplate` API where `usings` is visible.

Also adds two new tests exercising typed captures with `typeParameters`
through `ToVisitor()`: `UseContainsKeyRecipe` (IDictionary) and
`UseElementAtRecipe` (IEnumerable).

* C#: Add implicit usings to scaffold compilations

DependencyWorkspace.CreateSemanticModel now includes a synthetic
GlobalUsings source file mirroring the .NET 6+ implicit usings.
Without this, types like Dictionary<,> didn't resolve in scaffold
compilations unless the caller explicitly added using directives.

Also adds a test verifying Dictionary<string, int> resolves without
an explicit using System.Collections.Generic directive.

* C#: Map System.String as JavaType.Class instead of JavaType.Primitive

System.String is a reference type with interfaces (IEnumerable<char>,
IComparable<string>, IEquatable<string>, etc.) that
TypeUtils.IsAssignableTo needs to walk. Mapping it as Primitive lost
this hierarchy information.

Now MapPrimitive skips System_String, so the type mapper builds a full
JavaType.Class with supertypes and interfaces. J.Literal and J.Primitive
(the syntax node for the `string` keyword) still use
JavaType.Primitive(String) directly and are unaffected.

* C#: Add test that string type argument is mapped as JavaType.Class

Verifies that List<string>'s type parameter is JavaType.Class("System.String"),
not JavaType.Primitive(String), confirming the type mapper preserves the full
type hierarchy for string.

* C#: Handle array type assignability in TypeUtils

T[] implements a known set of non-generic (System.Array, IList, ICloneable,
etc.) and generic (IEnumerable<T>, IList<T>, IReadOnlyList<T>, etc.)
supertypes. TypeUtils.IsAssignableTo now recognizes these by synthesizing
the parameterized interfaces on the fly when encountering a JavaType.Array.

* C#: Move TypeUtils and MethodMatcher to OpenRewrite.CSharp namespace

Both contain .NET-specific logic (array interface knowledge, string alias
resolution, C# method matching) rather than Java concepts.

* C#: Always create semantic model for scaffold compilations

Previously the semantic model was only created when explicit usings or
dependencies were provided. This meant scaffolds without usings got no
type attribution at all, even though DependencyWorkspace now includes
implicit usings. Always creating the semantic model ensures types resolve
consistently. Reference resolution is cached so the cost is negligible.

* C#: Fix MethodMatcher short name matching after String type change

MethodMatcher patterns like "Aes Create(String)" failed to match when
the parameter type is JavaType.Class("System.String") because the regex
only matched the full FQN or keyword aliases. Now TypeArgMatcher also
tries matching the simple name (last segment of the FQN), so "String"
matches "System.String".

Author: knutwannheden

rewrite-csharp/csharp/OpenRewrite/CSharp/CSharpTypeMapping.cs

@@ -321,6 +321,11 @@ private JavaType.Variable MapVariable(ISymbol symbol, string name, JavaType? own
 
     private static JavaType.Primitive? MapPrimitive(INamedTypeSymbol symbol)
     {
+        // System.String is intentionally omitted: it is a reference type with interfaces
+        // (IEnumerable<char>, IComparable<string>, etc.) that TypeUtils.IsAssignableTo needs
+        // to walk. Mapping it as JavaType.Class preserves the full type hierarchy.
+        // J.Literal and J.Primitive (the syntax node for the `string` keyword) still use
+        // JavaType.Primitive(String) directly — they don't go through this method.
         return symbol.SpecialType switch
         {
             SpecialType.System_Boolean => JavaType.Primitive.Of(JavaType.PrimitiveKind.Boolean),
@@ -332,7 +337,6 @@ private JavaType.Variable MapVariable(ISymbol symbol, string name, JavaType? own
             SpecialType.System_Int64 => JavaType.Primitive.Of(JavaType.PrimitiveKind.Long),
             SpecialType.System_Int16 => JavaType.Primitive.Of(JavaType.PrimitiveKind.Short),
             SpecialType.System_Void => JavaType.Primitive.Of(JavaType.PrimitiveKind.Void),
-            SpecialType.System_String => JavaType.Primitive.Of(JavaType.PrimitiveKind.String),
             _ => null
         };
     }

…csharp/OpenRewrite/Java/MethodMatcher.cs …harp/OpenRewrite/CSharp/MethodMatcher.csrewrite-csharp/csharp/OpenRewrite/Java/MethodMatcher.cs renamed to rewrite-csharp/csharp/OpenRewrite/CSharp/MethodMatcher.cs rewrite-csharp/csharp/OpenRewrite/Java/MethodMatcher.cs renamed to rewrite-csharp/csharp/OpenRewrite/CSharp/MethodMatcher.cs

@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 using System.Text.RegularExpressions;
+using OpenRewrite.Java;
 
-namespace OpenRewrite.Java;
+namespace OpenRewrite.CSharp;
 
 /// <summary>
 /// Matches method invocations and declarations against AspectJ-style method patterns.
@@ -323,6 +324,15 @@ public override bool Matches(JavaType paramType)
             {
                 if (_pattern.IsMatch(fqn)) return true;
                 if (_fqnPattern != null && _fqnPattern.IsMatch(fqn)) return true;
+
+                // Match the simple name (last segment) against the pattern.
+                // This allows patterns like "String" to match "System.String".
+                var lastDot = fqn.LastIndexOf('.');
+                if (lastDot >= 0)
+                {
+                    var simpleName = fqn[(lastDot + 1)..];
+                    if (_pattern.IsMatch(simpleName)) return true;
+                }
             }
 
             // Also match simple name for primitives/keywords

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

@@ -32,6 +32,24 @@ internal static class DependencyWorkspace
 {
     private static readonly ConcurrentDictionary<string, ImmutableArray<MetadataReference>> ReferencesCache = new();
 
+    /// <summary>
+    /// Synthetic source file mirroring the <c>GlobalUsings.g.cs</c> that MSBuild generates
+    /// when <c>&lt;ImplicitUsings&gt;enable&lt;/ImplicitUsings&gt;</c> is set (.NET 6+ default).
+    /// Added to scaffold compilations so types like <c>Dictionary&lt;,&gt;</c> resolve
+    /// without explicit <c>using</c> directives.
+    /// </summary>
+    private static readonly SyntaxTree ImplicitUsingsSyntaxTree = CSharpSyntaxTree.ParseText(
+        """
+        global using System;
+        global using System.Collections.Generic;
+        global using System.IO;
+        global using System.Linq;
+        global using System.Net.Http;
+        global using System.Threading;
+        global using System.Threading.Tasks;
+        """,
+        path: "__GlobalUsings__.g.cs");
+
     /// <summary>
     /// Resolve NuGet dependencies into metadata references.
     /// Results are cached by the sorted dependency set.
@@ -46,6 +64,8 @@ internal static ImmutableArray<MetadataReference> ResolveReferences(
     /// <summary>
     /// Create a Roslyn <see cref="SemanticModel"/> for the given source code,
     /// with NuGet package references resolved for type attribution.
+    /// Includes .NET 6+ implicit usings so types like <c>Dictionary&lt;,&gt;</c>
+    /// resolve without explicit <c>using</c> directives in the scaffold.
     /// </summary>
     internal static SemanticModel CreateSemanticModel(string source,
         IReadOnlyDictionary<string, string> dependencies)
@@ -55,7 +75,7 @@ internal static SemanticModel CreateSemanticModel(string source,
         var compilation = CSharpCompilation.Create("TemplateCompilation")
             .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
             .AddReferences(references)
-            .AddSyntaxTrees(syntaxTree);
+            .AddSyntaxTrees(ImplicitUsingsSyntaxTree, syntaxTree);
         return compilation.GetSemanticModel(syntaxTree);
     }
 

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

@@ -21,13 +21,14 @@ namespace OpenRewrite.CSharp.Template;
 
 /// <summary>
 /// A declarative rewrite rule that pairs structural pattern matching with template application.
-/// Create rules with <see cref="RewriteRule.Rewrite(TemplateStringHandler, TemplateStringHandler)"/>
-/// or <see cref="RewriteRule.Rewrite(CSharpPattern, CSharpTemplate)"/>.
+/// Create rules with <see cref="RewriteRule.Rewrite(CSharpPattern, CSharpTemplate)"/>.
 /// </summary>
 /// <example>
 /// <code>
 /// var expr = Capture.Expression("expr");
-/// var rule = RewriteRule.Rewrite($"Console.Write({expr})", $"Console.WriteLine({expr})");
+/// var rule = RewriteRule.Rewrite(
+///     CSharpPattern.Expression($"Console.Write({expr})"),
+///     CSharpTemplate.Expression($"Console.WriteLine({expr})"));
 ///
 /// // In a visitor method:
 /// return rule.TryOn(Cursor, node) ?? node;
@@ -59,7 +60,9 @@ public interface IRewriteRule
     /// public override ITreeVisitor&lt;ExecutionContext&gt; GetVisitor()
     /// {
     ///     var x = Capture.Expression("x");
-    ///     return RewriteRule.Rewrite($"Console.Write({x})", $"Console.WriteLine({x})")
+    ///     return RewriteRule.Rewrite(
+    ///             CSharpPattern.Expression($"Console.Write({x})"),
+    ///             CSharpTemplate.Expression($"Console.WriteLine({x})"))
     ///         .ToVisitor();
     /// }
     /// </code>
@@ -72,25 +75,15 @@ public interface IRewriteRule
 /// </summary>
 public static class RewriteRule
 {
-    /// <summary>
-    /// Create a rewrite rule from interpolated strings. Uses <see cref="ScaffoldKind.Expression"/>
-    /// scaffolding — suitable for matching within expression-level visitor methods.
-    /// </summary>
-    /// <example>
-    /// <code>
-    /// using static OpenRewrite.CSharp.Template.RewriteRule;
-    ///
-    /// var expr = Capture.Expression("expr");
-    /// var rule = Rewrite($"Console.Write({expr})", $"Console.WriteLine({expr})");
-    /// return rule.TryOn(cursor, node) ?? node;
-    /// </code>
-    /// </example>
-    public static IRewriteRule Rewrite(TemplateStringHandler before, TemplateStringHandler after) =>
-        Rewrite(CSharpPattern.Expression(before), CSharpTemplate.Expression(after));
-
     /// <summary>
     /// Create a rewrite rule from a <see cref="CSharpPattern"/> and <see cref="CSharpTemplate"/>.
-    /// Use this when you need explicit scaffold control (e.g., <see cref="CSharpPattern.Statement"/>).
+    /// <para>
+    /// When using typed captures with <c>typeParameters</c>, the pattern's <c>usings</c> must
+    /// include the namespaces needed for the capture type to resolve (e.g.,
+    /// <c>"System.Collections.Generic"</c> for <c>IDictionary&lt;TKey, TValue&gt;</c>).
+    /// Without proper usings, the scaffold has no semantic model and type constraints
+    /// fall back to string matching, which cannot handle generic types.
+    /// </para>
     /// </summary>
     public static IRewriteRule Rewrite(CSharpPattern before, CSharpTemplate after) =>
         new RewriteRuleImpl(before, after);

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

@@ -100,18 +100,13 @@ private static J ParseInternal(string code, ScaffoldPreamble preamble,
         var scaffold = BuildScaffold(code, preamble, usings, context, scaffoldKind);
         var parser = new CSharpParser();
 
-        CompilationUnit cu;
-        if (dependencies.Count > 0 || usings.Count > 0)
-        {
-            // When usings or dependencies are provided, create a semantic model
-            // so the scaffold gets type attribution (needed for semantic matching).
-            var semanticModel = DependencyWorkspace.CreateSemanticModel(scaffold, dependencies);
-            cu = parser.Parse(scaffold, "__template__.cs", semanticModel);
-        }
-        else
-        {
-            cu = parser.Parse(scaffold, "__template__.cs");
-        }
+        // Always create a semantic model so the scaffold gets type attribution.
+        // DependencyWorkspace includes .NET 6+ implicit usings (System,
+        // System.Collections.Generic, etc.) via a synthetic global-using source file,
+        // so common types resolve even without explicit usings in the pattern.
+        // Reference resolution is cached, so repeated calls are cheap.
+        var semanticModel = DependencyWorkspace.CreateSemanticModel(scaffold, dependencies);
+        var cu = parser.Parse(scaffold, "__template__.cs", semanticModel);
 
         var result = ExtractTemplateNode(cu, code, scaffoldKind);
 

…arp/csharp/OpenRewrite/Java/TypeUtils.cs …p/csharp/OpenRewrite/CSharp/TypeUtils.csrewrite-csharp/csharp/OpenRewrite/Java/TypeUtils.cs renamed to rewrite-csharp/csharp/OpenRewrite/CSharp/TypeUtils.cs rewrite-csharp/csharp/OpenRewrite/Java/TypeUtils.cs renamed to rewrite-csharp/csharp/OpenRewrite/CSharp/TypeUtils.cs

@@ -13,7 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-namespace OpenRewrite.Java;
+using OpenRewrite.Java;
+
+namespace OpenRewrite.CSharp;
 
 /// <summary>
 /// Utility methods for working with <see cref="JavaType"/> instances.
@@ -46,6 +48,10 @@ public static bool IsAssignableTo(JavaType? type, string fullyQualifiedName)
             return primFqn != null && string.Equals(primFqn, fullyQualifiedName, StringComparison.Ordinal);
         }
 
+        // Arrays implement a known set of non-generic interfaces
+        if (type is JavaType.Array)
+            return IsArrayAssignableTo(fullyQualifiedName);
+
         var cls = AsClass(type);
         if (cls == null) return false;
 
@@ -354,6 +360,12 @@ private static void CollectParameterizedMatches(JavaType? type, string targetFqn
                 }
             }
         }
+        else if (type is JavaType.Array arr)
+        {
+            // T[] implements IEnumerable<T>, IList<T>, etc. — synthesize matches
+            if (arr.ElemType != null)
+                CollectArrayParameterizedMatches(arr.ElemType, targetFqn, results);
+        }
         else if (type is JavaType.Class cls)
         {
             if (!seen.Add(cls.FullyQualifiedName)) return;
@@ -501,6 +513,62 @@ private static bool TypeParametersMatch(IList<JavaType>? candidateParams, IList<
         _ => null
     };
 
+    // ===============================================================
+    // Array type support
+    // ===============================================================
+
+    /// <summary>
+    /// Non-generic supertypes of single-dimensional .NET arrays.
+    /// </summary>
+    private static readonly HashSet<string> ArrayNonGenericSupertypes =
+    [
+        "System.Array",
+        "System.Object",
+        "System.ICloneable",
+        "System.Collections.IList",
+        "System.Collections.ICollection",
+        "System.Collections.IEnumerable",
+        "System.Collections.IStructuralComparable",
+        "System.Collections.IStructuralEquatable"
+    ];
+
+    /// <summary>
+    /// FQNs of generic interfaces that single-dimensional .NET arrays implement,
+    /// parameterized by the element type.
+    /// </summary>
+    private static readonly string[] ArrayGenericInterfaceFqns =
+    [
+        "System.Collections.Generic.IEnumerable",
+        "System.Collections.Generic.ICollection",
+        "System.Collections.Generic.IList",
+        "System.Collections.Generic.IReadOnlyCollection",
+        "System.Collections.Generic.IReadOnlyList"
+    ];
+
+    /// <summary>
+    /// Check if a <see cref="JavaType.Array"/> is assignable to a non-generic target FQN.
+    /// </summary>
+    private static bool IsArrayAssignableTo(string fqn) => ArrayNonGenericSupertypes.Contains(fqn);
+
+    /// <summary>
+    /// Synthesize the generic interfaces that <c>T[]</c> implements as
+    /// <see cref="JavaType.Parameterized"/> instances with the element type substituted.
+    /// Used by <see cref="CollectParameterizedMatches"/> to handle array assignability.
+    /// </summary>
+    private static void CollectArrayParameterizedMatches(JavaType elemType, string targetFqn,
+        List<JavaType.Parameterized> results)
+    {
+        foreach (var ifaceFqn in ArrayGenericInterfaceFqns)
+        {
+            if (string.Equals(ifaceFqn, targetFqn, StringComparison.Ordinal))
+            {
+                // Synthesize Parameterized(IFoo<elemType>)
+                var rawClass = new JavaType.Class { FullyQualifiedName = ifaceFqn };
+                results.Add(new JavaType.Parameterized(rawClass, [elemType]));
+            }
+        }
+    }
+
     private static JavaType? TryGetTypeDynamic(Expression expr)
     {
         try

rewrite-csharp/csharp/OpenRewrite/Tests/CSharp/CSharpTypeMappingTests.cs

@@ -30,6 +30,18 @@ public class CSharpTypeMappingTests : RewriteTest
     /// <summary>
     /// Parse source code with reference assemblies and return the CompilationUnit.
     /// </summary>
+    private static readonly SyntaxTree ImplicitUsingsSyntaxTree = CSharpSyntaxTree.ParseText(
+        """
+        global using System;
+        global using System.Collections.Generic;
+        global using System.IO;
+        global using System.Linq;
+        global using System.Net.Http;
+        global using System.Threading;
+        global using System.Threading.Tasks;
+        """,
+        path: "__GlobalUsings__.g.cs");
+
     private static CompilationUnit ParseWithSemanticModel(string code)
     {
         var refs = Assemblies.Net90.ResolveAsync(LanguageNames.CSharp, CancellationToken.None)
@@ -38,7 +50,7 @@ private static CompilationUnit ParseWithSemanticModel(string code)
         var compilation = CSharpCompilation.Create("TestCompilation")
             .WithOptions(new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary))
             .AddReferences(refs)
-            .AddSyntaxTrees(syntaxTree);
+            .AddSyntaxTrees(ImplicitUsingsSyntaxTree, syntaxTree);
         var semanticModel = compilation.GetSemanticModel(syntaxTree);
 
         var parser = new CSharpParser();
@@ -194,6 +206,32 @@ void M()
         }
     }
 
+    [Fact]
+    public void ImplicitUsings_ShortNameResolvesWithoutExplicitUsing()
+    {
+        // In .NET 6+, System.Collections.Generic is an implicit using.
+        // Test whether Dictionary (short name, no using directive) gets
+        // type attribution. This will fail if implicit usings are not
+        // configured in the compilation.
+        var cu = ParseWithSemanticModel("""
+            class Test
+            {
+                void M()
+                {
+                    Dictionary<string, int> dict = new Dictionary<string, int>();
+                }
+            }
+            """);
+
+        var varDecl = FindVariableDeclaration(cu, "dict");
+        Assert.NotNull(varDecl);
+        var declType = varDecl!.TypeExpression?.Type;
+        // If implicit usings work, this should be Parameterized.
+        // If not, it will be null or Unknown (unresolved).
+        Assert.NotNull(declType);
+        Assert.IsType<JavaType.Parameterized>(declType);
+    }
+
     [Fact]
     public void DictionaryClass_HasFormalTypeParameters()
     {
@@ -227,4 +265,29 @@ void M()
         var formal1 = Assert.IsType<JavaType.GenericTypeVariable>(dictClass.TypeParameters[1]);
         Assert.Equal("TValue", formal1.Name);
     }
+
+    [Fact]
+    public void StringTypeArgument_IsMappedAsClass()
+    {
+        // System.String should be mapped as JavaType.Class (not Primitive) when used
+        // as a type argument, so TypeUtils.IsAssignableTo can walk its interface chain.
+        var cu = ParseWithSemanticModel("""
+            using System.Collections.Generic;
+            class Test
+            {
+                void M()
+                {
+                    List<string> items = new List<string>();
+                }
+            }
+            """);
+
+        var varDecl = FindVariableDeclaration(cu, "items");
+        Assert.NotNull(varDecl);
+
+        var paramType = Assert.IsType<JavaType.Parameterized>(varDecl!.TypeExpression?.Type);
+        Assert.NotNull(paramType.TypeParameters);
+        var stringArg = Assert.IsType<JavaType.Class>(Assert.Single(paramType.TypeParameters!));
+        Assert.Equal("System.String", stringArg.FullyQualifiedName);
+    }
 }