C#: Pass classpath via environment variable instead of -cp argument (#7345)

* C#: Pass classpath via environment variable instead of -cp argument

Avoids command-line length limits on Windows by setting the CLASSPATH
environment variable instead of passing it as a -cp argument to the
Java RPC test server process.

* C#: Fix PreconditionsCheckTest flaky failure from RPC static state leak

PreconditionsCheckTest expects LocalUsesType (local fallback) but when
RPC tests run first, RewriteRpcServer.Current is non-null, causing
UsesType to return an RpcVisitor that fails silently. Save/restore the
static in the test fixture to ensure isolation.

* C#: Remove LocalUsesType fallback, always delegate preconditions to Java via RPC

UsesType/UsesMethod now require an RPC connection and delegate to Java's
HasType/HasMethod. This eliminates the static state leak that caused flaky
test failures — tests using preconditions are inherently RPC-bound and must
run sequentially via RpcRewriteTest/[Collection("RPC")].

Also fix rpcTestClasspath to include processResources output directories so
Java's ServiceLoader discovers CSharpRpcCodec when the C# test fixture
spawns a Java RPC process.

Author: macsux

rewrite-csharp/build.gradle.kts

@@ -98,14 +98,18 @@ val rpcTestClasspath by tasks.registering {
         .withNormalizer(ClasspathNormalizer::class)
     inputs.files(tasks.named<JavaCompile>("compileJava").flatMap { it.destinationDirectory })
     inputs.files(tasks.named<JavaCompile>("compileTestJava").flatMap { it.destinationDirectory })
+    inputs.files(tasks.named("processResources"))
+    inputs.files(tasks.named("processTestResources"))
 
     val classpathFile = layout.buildDirectory.file("rpc-test-server-classpath.txt")
     outputs.file(classpathFile)
 
     doLast {
         val cp = configurations["testRuntimeClasspath"].resolve().joinToString(File.pathSeparator) +
                 File.pathSeparator + tasks.named<JavaCompile>("compileJava").get().destinationDirectory.get().asFile +
-                File.pathSeparator + tasks.named<JavaCompile>("compileTestJava").get().destinationDirectory.get().asFile
+                File.pathSeparator + tasks.named<JavaCompile>("compileTestJava").get().destinationDirectory.get().asFile +
+                File.pathSeparator + tasks.named("processResources").get().outputs.files.singleFile +
+                File.pathSeparator + tasks.named("processTestResources").get().outputs.files.singleFile
         classpathFile.get().asFile.writeText(cp)
     }
 }

rewrite-csharp/csharp/OpenRewrite/Java/Search/LocalUsesType.cs

@@ -21,55 +21,50 @@
 namespace OpenRewrite.Java.Search;
 
 /// <summary>
-/// Search-based precondition visitors.
-/// When connected to Java via RPC, delegates to Java's implementations.
-/// Otherwise falls back to local implementations.
+/// Search-based precondition visitors that delegate to Java's implementations via RPC.
+/// Requires an active RPC connection to a Java process.
 /// </summary>
 public static class Preconditions
 {
     /// <summary>
-    /// Creates a UsesType precondition. If connected to Java via RPC, delegates to
-    /// Java's org.openrewrite.java.search.HasType. Otherwise falls back to local implementation.
+    /// Creates a UsesType precondition that delegates to Java's
+    /// org.openrewrite.java.search.HasType via RPC.
     /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when no RPC connection is available.</exception>
     public static ITreeVisitor<ExecutionContext> UsesType(string fullyQualifiedTypeName)
     {
-        var rpc = RewriteRpcServer.Current;
-        if (rpc != null)
-        {
-            var response = rpc.PrepareRecipeOnRemote(
-                "org.openrewrite.java.search.HasType",
-                new Dictionary<string, object?>
-                {
-                    ["fullyQualifiedTypeName"] = fullyQualifiedTypeName,
-                    ["checkAssignability"] = false
-                }
-            );
-            return new RpcVisitor(rpc, response.EditVisitor);
-        }
+        var rpc = RewriteRpcServer.Current
+                  ?? throw new InvalidOperationException("UsesType requires an RPC connection to Java");
 
-        return new LocalUsesType<ExecutionContext>(fullyQualifiedTypeName);
+        var response = rpc.PrepareRecipeOnRemote(
+            "org.openrewrite.java.search.HasType",
+            new Dictionary<string, object?>
+            {
+                ["fullyQualifiedTypeName"] = fullyQualifiedTypeName,
+                ["checkAssignability"] = false
+            }
+        );
+        return new RpcVisitor(rpc, response.EditVisitor);
     }
 
     /// <summary>
-    /// Creates a UsesMethod precondition. If connected to Java via RPC, delegates to
-    /// Java's org.openrewrite.java.search.HasMethod.
+    /// Creates a UsesMethod precondition that delegates to Java's
+    /// org.openrewrite.java.search.HasMethod via RPC.
     /// </summary>
+    /// <exception cref="InvalidOperationException">Thrown when no RPC connection is available.</exception>
     public static ITreeVisitor<ExecutionContext> UsesMethod(string methodPattern)
     {
-        var rpc = RewriteRpcServer.Current;
-        if (rpc != null)
-        {
-            var response = rpc.PrepareRecipeOnRemote(
-                "org.openrewrite.java.search.HasMethod",
-                new Dictionary<string, object?>
-                {
-                    ["methodPattern"] = methodPattern,
-                    ["matchOverrides"] = false
-                }
-            );
-            return new RpcVisitor(rpc, response.EditVisitor);
-        }
+        var rpc = RewriteRpcServer.Current
+                  ?? throw new InvalidOperationException("UsesMethod requires an RPC connection to Java");
 
-        throw new InvalidOperationException("UsesMethod requires an RPC connection to Java");
+        var response = rpc.PrepareRecipeOnRemote(
+            "org.openrewrite.java.search.HasMethod",
+            new Dictionary<string, object?>
+            {
+                ["methodPattern"] = methodPattern,
+                ["matchOverrides"] = false
+            }
+        );
+        return new RpcVisitor(rpc, response.EditVisitor);
     }
 }

rewrite-csharp/csharp/OpenRewrite/Java/Search/Preconditions.cs

@@ -80,15 +80,16 @@ private static ProcessStartInfo CreateJavaProcessStartInfo()
                          "Run './gradlew :rewrite-csharp:rpcTestClasspath' to generate the classpath file.");
 
         var classpath = File.ReadAllText(cpFile).Trim();
-        return new ProcessStartInfo("java",
-            $"-cp \"{classpath}\" org.openrewrite.maven.rpc.JavaRewriteRpc")
+        var psi = new ProcessStartInfo("java", "org.openrewrite.maven.rpc.JavaRewriteRpc")
         {
             RedirectStandardInput = true,
             RedirectStandardOutput = true,
             RedirectStandardError = true,
             UseShellExecute = false,
             CreateNoWindow = true
         };
+        psi.Environment["CLASSPATH"] = classpath;
+        return psi;
     }
 
     public void Dispose()

rewrite-csharp/csharp/OpenRewrite/Test/RpcFixture.cs

@@ -24,46 +24,12 @@
 
 namespace OpenRewrite.Tests.Recipe;
 
-public class PreconditionsCheckTest : RewriteTest
+/// <summary>
+/// Tests for Preconditions.Check with RPC-backed precondition visitors.
+/// These tests require a Java RPC connection for UsesType/UsesMethod.
+/// </summary>
+public class PreconditionsCheckTest(RpcFixture fixture) : RpcRewriteTest(fixture)
 {
-    /// <summary>
-    /// Directly test that LocalUsesType finds the type and Check delegates to visitor.
-    /// </summary>
-    [Fact]
-    public async Task CheckDelegatesToVisitorWhenPreconditionMatches()
-    {
-        var parser = new CSharpParser();
-        var syntaxTree = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(
-            "using System; class T { void M() { Console.WriteLine(\"hi\"); } }", path: "source.cs");
-        var refs = await Assemblies.Net90
-            .ResolveAsync(Microsoft.CodeAnalysis.LanguageNames.CSharp, System.Threading.CancellationToken.None);
-        var compilation = Microsoft.CodeAnalysis.CSharp.CSharpCompilation.Create("Test")
-            .WithOptions(new Microsoft.CodeAnalysis.CSharp.CSharpCompilationOptions(Microsoft.CodeAnalysis.OutputKind.DynamicallyLinkedLibrary))
-            .AddReferences(refs)
-            .AddSyntaxTrees(syntaxTree);
-        var semanticModel = compilation.GetSemanticModel(syntaxTree);
-        var source = parser.Parse(
-            "using System; class T { void M() { Console.WriteLine(\"hi\"); } }",
-            semanticModel: semanticModel);
-
-        // Step 1: Verify LocalUsesType finds System.Console
-        var precondition = UsesType("System.Console");
-        var precondResult = precondition.Visit(source, new ExecutionContext());
-        Assert.NotSame(source, precondResult); // Should be different (marked with SearchResult)
-
-        // Step 2: Verify Check delegates to inner visitor
-        var check = Check(precondition, new NoOpCSharpVisitor());
-        var checkResult = check.Visit(source, new ExecutionContext());
-        // If precondition matched, inner visitor ran (even if no-op)
-    }
-
-    private class NoOpCSharpVisitor : CSharpVisitor<ExecutionContext> { }
-
-    /// <summary>
-    /// Verifies that Preconditions.Check works with CSharpVisitor recipes.
-    /// The precondition (LocalUsesType) must be able to traverse C# trees
-    /// to find the type, and the inner CSharpVisitor must run when matched.
-    /// </summary>
     [Fact]
     public void PreconditionMatchesAndVisitorRuns()
     {
@@ -171,40 +137,9 @@ void M()
 }
 
 /// <summary>
-/// A test recipe that uses Preconditions.Check with a CSharpVisitor.
-/// Renames Console.WriteLine to Console.Write in files that use System.Console.
-/// </summary>
-/// <summary>
-/// Test recipe that removes Console.WriteLine by returning null from VisitMethodInvocation.
-/// This does NOT work — returning null from VisitMethodInvocation removes the invocation
-/// but not the enclosing ExpressionStatement, so the tree appears unchanged.
+/// Test recipe that renames Console.WriteLine to Console.Write in files that use System.Console.
+/// Uses Preconditions.Check with an RPC-backed UsesType precondition.
 /// </summary>
-class RemoveConsoleWriteLineRecipe : OpenRewrite.Core.Recipe
-{
-    public override string DisplayName => "Remove Console.WriteLine (broken)";
-    public override string Description => "Attempts to remove Console.WriteLine by returning null from VisitMethodInvocation.";
-
-    public override JavaVisitor<ExecutionContext> GetVisitor() => new Visitor();
-
-    private class Visitor : CSharpVisitor<ExecutionContext>
-    {
-        public override J VisitMethodInvocation(MethodInvocation mi, ExecutionContext ctx)
-        {
-            mi = (MethodInvocation)base.VisitMethodInvocation(mi, ctx);
-
-            if (mi.Name.SimpleName == "WriteLine" &&
-                mi.Select?.Element is Identifier id &&
-                id.SimpleName == "Console")
-            {
-                //noinspection DataFlowIssue
-                return null!;
-            }
-
-            return mi;
-        }
-    }
-}
-
 class RenameWriteLineRecipe : OpenRewrite.Core.Recipe
 {
     public override string DisplayName => "Rename Console.WriteLine to Write";