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

README.md

@@ -63,7 +63,7 @@ On newer Java version you'd perhaps want to pass in the following option:
 -Arewrite.generatedAnnotation=jakarta.annotation.Generated
 ```
 
-### Use JavaParser.Builder `.classpathFromResources(ctx, "guava")`
+### Use JavaParser.Builder `.classpathFromResources(ctx, "guava-31")`
 By default, the annotation processor will use `JavaParser.runtimeClasspath()` to resolve the classpath for newly generated Java code snippets.
 If you want to use `TypeTables` from `src/main/resources/META-INF/rewrite/classpath.tsv.gz` instead, pass in the following option:
 ```

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,57 +16,34 @@
 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;
 import org.jspecify.annotations.Nullable;
 
 import javax.tools.JavaFileObject;
-import java.util.Collection;
 import java.util.LinkedHashSet;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-public class ClasspathJarNameDetector {
+public class ClasspathJarNameDetector extends TreeScanner {
+    private final Set<String> jarNames = new LinkedHashSet<>();
 
     /**
      * Locate types that are directly referred to by name in the
      * given tree and therefore need an import in the template.
      *
      * @return The list of imports to add.
      */
-    public static Set<String> classpathFor(JCTree input, Collection<Symbol> imports) {
-        Set<String> jarNames = new LinkedHashSet<String>() {
-            @Override
-            public boolean add(@Nullable String s) {
-                return s != null && super.add(s);
-            }
-        };
-
-        for (Symbol anImport : imports) {
-            jarNames.add(jarNameFor(anImport));
-        }
-
-        new TreeScanner() {
-            @Override
-            public void scan(JCTree tree) {
-                // Detect fully qualified classes
-                if (tree instanceof JCFieldAccess &&
-                        ((JCFieldAccess) tree).sym instanceof Symbol.ClassSymbol &&
-                        Character.isUpperCase(((JCFieldAccess) tree).getIdentifier().toString().charAt(0))) {
-                    jarNames.add(jarNameFor(((JCFieldAccess) tree).sym));
-                }
-                super.scan(tree);
-            }
-        }.scan(input);
-
+    public Set<String> classpathFor(JCTree input) {
+        scan(input);
         return jarNames;
     }
 
-
-    private static @Nullable String jarNameFor(Symbol anImport) {
-        Symbol.ClassSymbol enclClass = anImport instanceof Symbol.ClassSymbol ? (Symbol.ClassSymbol) anImport : anImport.enclClass();
+    private void addJarNameFor(Symbol owner) {
+        Symbol.ClassSymbol enclClass = owner instanceof Symbol.ClassSymbol ? (Symbol.ClassSymbol) owner : owner.enclClass();
         while (enclClass.enclClass() != null && enclClass.enclClass() != enclClass) {
             enclClass = enclClass.enclClass();
         }
@@ -75,10 +52,94 @@ public void scan(JCTree tree) {
             String uriStr = classfile.toUri().toString();
             Matcher matcher = Pattern.compile("([^/]*)?\\.jar!/").matcher(uriStr);
             if (matcher.find()) {
-                String jarName = matcher.group(1);
-                return jarName.replaceAll("-\\d.*$", "");
+                String jarName = matcher.group(1)
+                        // Retain major version number, to avoid `log4j` conflict between `log4j-1` and `log4j2-1`
+                        .replaceFirst("(-\\d+).*?$", "$1");
+                jarNames.add(jarName);
             }
         }
-        return null;
     }
+
+    @Override
+    public void scan(JCTree tree) {
+        // Detect fully qualified classes
+        if (tree instanceof JCFieldAccess &&
+                ((JCFieldAccess) tree).sym instanceof Symbol.ClassSymbol &&
+                Character.isUpperCase(((JCFieldAccess) tree).getIdentifier().toString().charAt(0))) {
+            addJarNameFor(((JCFieldAccess) tree).sym);
+        }
+
+        // Detect method invocations and their types
+        if (tree instanceof JCTree.JCMethodInvocation) {
+            JCTree.JCMethodInvocation invocation = (JCTree.JCMethodInvocation) tree;
+            Symbol.MethodSymbol methodSym = null;
+
+            if (invocation.meth instanceof JCFieldAccess) {
+                JCFieldAccess methodAccess = (JCFieldAccess) invocation.meth;
+                if (methodAccess.sym instanceof Symbol.MethodSymbol) {
+                    methodSym = (Symbol.MethodSymbol) methodAccess.sym;
+                }
+            } else if (invocation.meth instanceof JCTree.JCIdent) {
+                // Handle unqualified method calls (e.g., from static imports)
+                JCTree.JCIdent methodIdent = (JCTree.JCIdent) invocation.meth;
+                if (methodIdent.sym instanceof Symbol.MethodSymbol) {
+                    methodSym = (Symbol.MethodSymbol) methodIdent.sym;
+                }
+            }
+
+            if (methodSym != null) {
+                // Add jar for the method's owner class
+                addJarNameFor(methodSym.owner);
+
+                // Add jar for the return type
+                if (methodSym.getReturnType() != null) {
+                    addTypeAndTransitiveDependencies(methodSym.getReturnType());
+                }
+
+                // Add jars for exception types
+                for (Type thrownType : methodSym.getThrownTypes()) {
+                    addTypeAndTransitiveDependencies(thrownType);
+                }
+            }
+        }
+
+        // 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;
+                addJarNameFor(classSym);
+
+                // Add transitive dependencies through inheritance
+                addTypeAndTransitiveDependencies(classSym.type);
+            }
+        }
+
+        super.scan(tree);
+    }
+
+    private void addTypeAndTransitiveDependencies(@Nullable Type type) {
+        if (type == null) {
+            return;
+        }
+
+        if (type.tsym instanceof Symbol.ClassSymbol) {
+            Symbol.ClassSymbol classSym = (Symbol.ClassSymbol) type.tsym;
+            addJarNameFor(classSym);
+
+            // Check superclass
+            Type superType = classSym.getSuperclass();
+            if (superType != null && superType.tsym != null) {
+                addJarNameFor(superType.tsym);
+            }
+
+            // Check interfaces
+            for (Type iface : classSym.getInterfaces()) {
+                if (iface.tsym != null) {
+                    addJarNameFor(iface.tsym);
+                }
+            }
+        }
+    }
+
 }

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

@@ -43,26 +43,10 @@ public static Collection<Symbol> imports(JCTree.JCMethodDecl methodDecl) {
 
     public static Collection<Symbol> imports(JCTree.JCMethodDecl methodDecl, Predicate<JCTree> scopePredicate) {
         ImportScanner importScanner = new ImportScanner(scopePredicate);
+        methodDecl.getParameters().forEach(importScanner::scan);
+        methodDecl.getTypeParameters().forEach(importScanner::scan);
         importScanner.scan(methodDecl.getBody());
         importScanner.scan(methodDecl.getReturnType());
-        for (JCTree.JCVariableDecl param : methodDecl.getParameters()) {
-            importScanner.scan(param);
-        }
-        for (JCTree.JCTypeParameter param : methodDecl.getTypeParameters()) {
-            importScanner.scan(param);
-        }
-        return importScanner.imports;
-    }
-
-    /**
-     * Locate types that are directly referred to by name in the
-     * given tree and therefore need an import in the template.
-     *
-     * @return The list of imports to add.
-     */
-    public static Collection<Symbol> imports(JCTree tree) {
-        ImportScanner importScanner = new ImportScanner(t -> true);
-        importScanner.scan(tree);
         return importScanner.imports;
     }
 

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

@@ -70,10 +70,9 @@ public static <T extends JCTree> String process(
             if (!printer.staticImports.isEmpty()) {
                 builder.append("\n        .staticImports(").append(printer.staticImports.stream().map(i -> '"' + i + '"').collect(joining(", "))).append(")");
             }
-            Set<String> jarNames = ClasspathJarNameDetector.classpathFor(tree, ImportDetector.imports(tree));
-            for (JCTree.JCVariableDecl parameter : parameters) {
-                jarNames.addAll(ClasspathJarNameDetector.classpathFor(parameter, ImportDetector.imports(parameter)));
-            }
+            ClasspathJarNameDetector classpathJarNameDetector = new ClasspathJarNameDetector();
+            parameters.forEach(classpathJarNameDetector::classpathFor);
+            Set<String> jarNames = classpathJarNameDetector.classpathFor(tree);
             if (!jarNames.isEmpty()) {
                 builder.append("\n        .javaParser(JavaParser.fromJavaVersion()");
                 if (classpathFromResources) {

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),