Add additional jar names to classpathFromResources for types referenced from types used

build.gradle.kts

@@ -115,14 +115,38 @@ tasks.named<JavaCompile>("compileTestJava") {
     })
     sourceCompatibility = JavaVersion.VERSION_21.toString()
     targetCompatibility = JavaVersion.VERSION_21.toString()
+
+    options.compilerArgs.addAll(
+        listOf(
+            "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
+            "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"
+        )
+    )
 }
 
 tasks.withType<Test>().configureEach {
     useJUnitPlatform()
     javaLauncher.set(javaToolchains.launcherFor {
         languageVersion.set(JavaLanguageVersion.of(21))
     })
-    jvmArgs("--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED")
+    jvmArgs(
+        "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.code=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.comp=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.parser=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.processing=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.file=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.main=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.tree=ALL-UNNAMED",
+        "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"
+    )
 }
 
 tasks.withType<Javadoc>().configureEach {

src/main/java/org/openrewrite/java/template/internal/ClasspathJarNameDetector.java

@@ -16,6 +16,7 @@
 package org.openrewrite.java.template.internal;
 
 import com.sun.tools.javac.code.Symbol;
+import com.sun.tools.javac.code.Type;
 import com.sun.tools.javac.tree.JCTree;
 import com.sun.tools.javac.tree.JCTree.JCFieldAccess;
 import com.sun.tools.javac.tree.TreeScanner;
@@ -57,8 +58,67 @@ public void scan(JCTree tree) {
                         Character.isUpperCase(((JCFieldAccess) tree).getIdentifier().toString().charAt(0))) {
                     jarNames.add(jarNameFor(((JCFieldAccess) tree).sym));
                 }
+
+                // Detect method invocations and their types
+                if (tree instanceof JCTree.JCMethodInvocation) {
+                    JCTree.JCMethodInvocation invocation = (JCTree.JCMethodInvocation) tree;
+                    if (invocation.meth instanceof JCTree.JCFieldAccess) {
+                        JCTree.JCFieldAccess methodAccess = (JCTree.JCFieldAccess) invocation.meth;
+                        if (methodAccess.sym instanceof Symbol.MethodSymbol) {
+                            Symbol.MethodSymbol methodSym = (Symbol.MethodSymbol) methodAccess.sym;
+
+                            // Add jar for the method's owner class
+                            jarNames.add(jarNameFor(methodSym.owner));
+
+                            // Add jar for the return type
+                            if (methodSym.getReturnType() != null) {
+                                addTypeAndTransitiveDependencies(methodSym.getReturnType(), jarNames);
+                            }
+
+                            // Add jars for exception types
+                            for (Type thrownType : methodSym.getThrownTypes()) {
+                                addTypeAndTransitiveDependencies(thrownType, jarNames);
+                            }
+                        }
+                    }
+                }
+
+                // Detect identifiers that reference classes
+                if (tree instanceof JCTree.JCIdent) {
+                    JCTree.JCIdent ident = (JCTree.JCIdent) tree;
+                    if (ident.sym instanceof Symbol.ClassSymbol) {
+                        Symbol.ClassSymbol classSym = (Symbol.ClassSymbol) ident.sym;
+                        jarNames.add(jarNameFor(classSym));
+
+                        // Add transitive dependencies through inheritance
+                        addTypeAndTransitiveDependencies(classSym.type, jarNames);
+                    }
+                }
+
                 super.scan(tree);
             }
+
+            private void addTypeAndTransitiveDependencies(Type type, Set<String> jarNames) {
+                if (type == null) return;
+
+                if (type.tsym instanceof Symbol.ClassSymbol) {
+                    Symbol.ClassSymbol classSym = (Symbol.ClassSymbol) type.tsym;
+                    jarNames.add(jarNameFor(classSym));
+
+                    // Check superclass
+                    Type superType = classSym.getSuperclass();
+                    if (superType != null && superType.tsym != null) {
+                        jarNames.add(jarNameFor(superType.tsym));
+                    }
+
+                    // Check interfaces
+                    for (Type iface : classSym.getInterfaces()) {
+                        if (iface.tsym != null) {
+                            jarNames.add(jarNameFor(iface.tsym));
+                        }
+                    }
+                }
+            }
         }.scan(input);
 
         return jarNames;

src/test/java/org/openrewrite/java/template/RefasterTemplateProcessorTest.java

@@ -46,6 +46,7 @@ class RefasterTemplateProcessorTest {
     @ValueSource(strings = {
       "Arrays",
       "CharacterEscapeAnnotation",
+      "ClasspathFromResourcesTransitive",
       "ComplexGenerics",
       "FindListAdd",
       "MatchOrder",
@@ -174,8 +175,10 @@ static Compilation compile(JavaFileObject javaFileObject, TypeAwareProcessor pro
             fileForClass(BeforeTemplate.class),
             fileForClass(AfterTemplate.class),
             fileForClass(com.google.common.collect.ImmutableMap.class),
+            fileForClass(org.junit.jupiter.api.Assertions.class),
             fileForClass(org.openrewrite.Recipe.class),
             fileForClass(org.openrewrite.java.JavaTemplate.class),
+            fileForClass(org.opentest4j.MultipleFailuresError.class),
             fileForClass(org.slf4j.Logger.class),
             fileForClass(Primitive.class),
             fileForClass(NullMarked.class),

src/test/java/org/openrewrite/java/template/internal/ClasspathJarNameDetectorTest.java

@@ -0,0 +1,166 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.openrewrite.java.template.internal;
+
+import com.sun.source.util.JavacTask;
+import com.sun.tools.javac.api.JavacTool;
+import com.sun.tools.javac.tree.JCTree;
+import com.sun.tools.javac.tree.JCTree.JCCompilationUnit;
+import org.intellij.lang.annotations.Language;
+import org.junit.jupiter.api.Test;
+
+import javax.tools.*;
+import java.io.IOException;
+import java.net.URI;
+import java.nio.charset.StandardCharsets;
+import java.util.Set;
+
+import static com.google.common.truth.Truth.assertThat;
+import static java.util.Collections.emptyList;
+import static java.util.Collections.singletonList;
+import static org.openrewrite.java.template.internal.ClasspathJarNameDetector.classpathFor;
+
+class ClasspathJarNameDetectorTest {
+
+    @Test
+    void detectsJarNamesFromImports() throws IOException {
+        Set<String> jarNames = compileAndExtractJarNames("""
+          import java.util.List;
+          import java.util.ArrayList;
+          class Test {
+              List<String> list = new ArrayList<>();
+          }
+          """);
+
+        // JDK classes should not be included in the jar names
+        assertThat(jarNames).isEmpty();
+    }
+
+    @Test
+    void detectJUnit() throws IOException {
+        Set<String> jarNames = compileAndExtractJarNames("""
+          import org.junit.jupiter.api.Test;
+          import org.junit.jupiter.api.Assertions;
+          class TestClass {
+              @Test
+              void testMethod() {
+                  Assertions.assertEquals(1, 1);
+              }
+          }
+          """);
+
+        assertThat(jarNames).containsExactly("junit-jupiter-api");
+    }
+
+    @Test
+    void detectJUnitAndOpenTest4J() throws IOException {
+        Set<String> jarNames = compileAndExtractJarNames("""
+          import org.junit.jupiter.api.Test;
+          import org.junit.jupiter.api.Assertions;
+          class TestClass {
+              @Test
+              void testMethod() {
+                  Assertions.assertAll("This throws org.opentest4j.MultipleFailuresError");
+              }
+          }
+          """);
+
+        assertThat(jarNames).containsExactly("junit-jupiter-api", "opentest4j");
+    }
+
+    @Test
+    void detectJUnitAndOpenTest4JFromStatement() throws IOException {
+        JCCompilationUnit compilationUnit = compile("""
+          import org.junit.jupiter.api.Assertions;
+          class TestClass {
+              void testMethod() {
+                  Assertions.assertAll("heading");
+              }
+          }
+          """);
+
+        Set<String> jarNames = classpathFor(firstStatement(compilationUnit), emptyList());
+
+        // assertAll throws an exception that is defined in opentest4j, so we need both junit-jupiter-api and opentest4j
+        assertThat(jarNames).containsExactly("junit-jupiter-api", "opentest4j");
+    }
+
+    @Test
+    void detectTransitiveDependencyThroughInheritance() throws IOException {
+        JCCompilationUnit compilationUnit = compile("""
+          import org.openrewrite.java.JavaVisitor;
+          class TestClass {
+              void testMethod() {
+                  String language = new JavaVisitor<>().getLanguage();
+              }
+          }
+          """);
+
+        Set<String> jarNames = classpathFor(firstStatement(compilationUnit), emptyList());
+
+        // JavaVisitor from rewrite-java extends TreeVisitor from rewrite-core, both are needed
+        assertThat(jarNames).containsExactly("rewrite-java", "rewrite-core");
+    }
+
+    private static JCTree.JCStatement firstStatement(JCCompilationUnit compilationUnit) {
+        // Just the first statement of the method body, not the complete compilation unit, just like the processor does
+        JCTree.JCClassDecl classDecl = (JCTree.JCClassDecl) compilationUnit.getTypeDecls().getFirst();
+        JCTree.JCMethodDecl methodDecl = classDecl.getMembers().stream()
+          .filter(JCTree.JCMethodDecl.class::isInstance)
+          .map(JCTree.JCMethodDecl.class::cast)
+          .filter(member -> !member.sym.isConstructor())
+          .findFirst()
+          .orElseThrow();
+        return methodDecl.body.getStatements().getFirst();
+    }
+
+    private Set<String> compileAndExtractJarNames(@Language("java") String source) throws IOException {
+        JCCompilationUnit compilationUnit = compile(source);
+        return classpathFor(
+          compilationUnit.getTypeDecls().getFirst(),
+          ImportDetector.imports(compilationUnit)
+        );
+    }
+
+    private static JCCompilationUnit compile(@Language("java") String source) throws IOException {
+        JavaCompiler compiler = JavacTool.create();
+        DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();
+        try (StandardJavaFileManager fileManager = compiler.getStandardFileManager(diagnostics, null, StandardCharsets.UTF_8)) {
+            JavaFileObject sourceFile = new SimpleJavaFileObject(
+              URI.create("string:///Test.java"),
+              JavaFileObject.Kind.SOURCE) {
+                @Override
+                public CharSequence getCharContent(boolean ignoreEncodingErrors) {
+                    return source;
+                }
+            };
+
+            JavacTask task = (JavacTask) compiler.getTask(
+              null,
+              fileManager,
+              diagnostics,
+              singletonList("-proc:none"),
+              null,
+              singletonList(sourceFile));
+
+            @SuppressWarnings("unchecked")
+            Iterable<? extends JCCompilationUnit> compilationUnits = (Iterable<? extends JCCompilationUnit>) task.parse();
+            task.analyze();
+
+            return compilationUnits.iterator().next();
+        }
+    }
+}

src/test/resources/refaster/ClasspathFromResourcesTransitive.java

@@ -0,0 +1,27 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://www.apache.org/licenses/LICENSE-2.0
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package foo;
+
+import com.google.errorprone.refaster.annotation.AfterTemplate;
+import com.google.errorprone.refaster.annotation.BeforeTemplate;
+import org.openrewrite.java.JavaVisitor;
+
+public class ClasspathFromResourcesTransitive {
+    @BeforeTemplate
+    String before(JavaVisitor visitor) {
+        return visitor.getLanguage();
+    }
+}