Record Javadoc reference packages in TypesInUse

`TypesInUse` deliberately excludes fully qualified Javadoc references from
its import-retention set (#5738), since such references need no import.
`ChangePackage` therefore carried its own LST walk to rediscover exactly
those references for its precondition — duplicating the "is this a fully
qualified Javadoc reference" predicate, which is how the regression fixed
in #7284 originally crept in.

Capture the packages of those references in a separate transient
`javadocPackages` bucket during the single `FindTypesInUse` walk, and have
`ChangePackage` query it via `hasJavadocReferenceInPackage`. Only the
package is retained, since that is all package-renaming recipes ask. The
import-retention set is unchanged, so `RemoveUnusedImports`/`UsesType`/the
FQN trie behave exactly as before. The bucket is not serialized;
`TypesInUse.of` leaves it empty.

Author: knutwannheden

rewrite-java-test/src/test/java/org/openrewrite/java/internal/TypesInUseTest.java

@@ -65,6 +65,44 @@ public class Foo {}
         );
     }
 
+    @Test
+    void recordsFullyQualifiedJavadocReferencesSeparately() {
+        rewriteRun(
+          java(
+            """
+              package org.openrewrite.other;
+              public class Target {}
+              """
+          ),
+          java(
+            """
+              package com.example;
+              /**
+               * See {@link org.openrewrite.other.Target} for details.
+               */
+              public class Bar {}
+              """,
+            spec -> spec.afterRecipe(cu -> {
+                TypesInUse tiu = cu.getTypesInUse();
+
+                // Fully qualified Javadoc references stay out of the import-retention set (#5738)...
+                assertThat(tiu.getTypesInUse().stream()
+                  .filter(t -> t instanceof JavaType.FullyQualified)
+                  .map(t -> ((JavaType.FullyQualified) t).getFullyQualifiedName()))
+                  .doesNotContain("org.openrewrite.other.Target");
+
+                // ...but their packages are recorded separately so package-renaming recipes can find them.
+                assertThat(tiu.getJavadocPackages()).contains("org.openrewrite.other");
+
+                assertThat(tiu.hasJavadocReferenceInPackage("org.openrewrite.other", false)).isTrue();
+                assertThat(tiu.hasJavadocReferenceInPackage("org.openrewrite", false)).isFalse();
+                assertThat(tiu.hasJavadocReferenceInPackage("org.openrewrite", true)).isTrue();
+                assertThat(tiu.hasJavadocReferenceInPackage("com.other", true)).isFalse();
+            })
+          )
+        );
+    }
+
     @Test
     void publicFactoryReturnsInstanceWithSuppliedSets() {
         rewriteRun(

rewrite-java/src/main/java/org/openrewrite/java/ChangePackage.java

@@ -29,7 +29,6 @@
 
 import java.nio.file.Paths;
 import java.util.*;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 import static java.util.Objects.requireNonNull;
 import static org.openrewrite.Tree.randomId;
@@ -109,9 +108,9 @@ public TreeVisitor<?, ExecutionContext> getVisitor() {
                             }
                         }
                     }
-                    // Fully qualified javadoc references are excluded from TypesInUse
-                    // (they don't affect imports), but they still need package renaming.
-                    if (hasJavadocReferenceToPackage(cu, oldPackageName, recursive, recursivePackageNamePrefix)) {
+                    // Fully qualified javadoc references are excluded from TypesInUse's import-retention
+                    // set (they don't affect imports), but they still need package renaming.
+                    if (cu.getTypesInUse().hasJavadocReferenceInPackage(oldPackageName, recursive)) {
                         return SearchResult.found(cu);
                     }
                 } else if (tree instanceof SourceFileWithReferences) {
@@ -537,50 +536,6 @@ private boolean isTargetRecursivePackageName(String packageName) {
 
     }
 
-    private static boolean hasJavadocReferenceToPackage(JavaSourceFile cu, String packageName, boolean recursive, String recursivePrefix) {
-        return new JavaIsoVisitor<AtomicBoolean>() {
-            boolean inJavadocReference;
-
-            @Override
-            public @Nullable J visit(@Nullable Tree tree, AtomicBoolean f) {
-                // Once a matching reference is found, skip the rest of the traversal.
-                return f.get() ? (J) tree : super.visit(tree, f);
-            }
-
-            @Override
-            protected JavadocVisitor<AtomicBoolean> getJavadocVisitor() {
-                // Field accesses only carry a fully qualified package reference worth checking when
-                // they appear inside a Javadoc reference, so let the Javadoc delegate flag that scope
-                // rather than re-walking each field access's ancestors during the descent.
-                return new JavadocVisitor<AtomicBoolean>(this) {
-                    @Override
-                    public Javadoc visitReference(Javadoc.Reference reference, AtomicBoolean f) {
-                        inJavadocReference = true;
-                        try {
-                            return super.visitReference(reference, f);
-                        } finally {
-                            inJavadocReference = false;
-                        }
-                    }
-                };
-            }
-
-            @Override
-            public J.FieldAccess visitFieldAccess(J.FieldAccess fieldAccess, AtomicBoolean f) {
-                if (inJavadocReference && !f.get()) {
-                    JavaType type = fieldAccess.getType();
-                    if (type instanceof JavaType.FullyQualified) {
-                        String pkg = ((JavaType.FullyQualified) type).getPackageName();
-                        if (pkg.equals(packageName) || recursive && pkg.startsWith(recursivePrefix)) {
-                            f.set(true);
-                        }
-                    }
-                }
-                return super.visitFieldAccess(fieldAccess, f);
-            }
-        }.reduce(cu, new AtomicBoolean()).get();
-    }
-
     @Value
     @EqualsAndHashCode(callSuper = false)
     private static class ReferenceChangePackageVisitor extends TreeVisitor<Tree, ExecutionContext> {

rewrite-java/src/main/java/org/openrewrite/java/internal/TypesInUse.java

@@ -30,6 +30,7 @@
 import org.openrewrite.java.tree.TypeUtils;
 
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashSet;
 import java.util.IdentityHashMap;
 import java.util.Iterator;
@@ -49,6 +50,19 @@ public class TypesInUse {
     private final Set<JavaType.Method> usedMethods;
     private final Set<JavaType.Variable> variables;
 
+    /**
+     * Packages of the fully qualified types referenced only from Javadoc (e.g. {@code {@link com.foo.Bar}}
+     * contributes {@code com.foo}). The types themselves are deliberately excluded from {@link #typesInUse}
+     * because a fully qualified Javadoc reference needs no import, so it must not count toward import
+     * retention (see #5738). Their packages are recorded here so that package-renaming recipes can still
+     * discover them without re-walking the tree. Only the package is retained because that is all such
+     * recipes query.
+     * <p>
+     * This bucket is <em>transient</em>: it is populated only by {@link #build(JavaSourceFile)} and is left
+     * empty by {@link #of}, since a serialized type index carries no Javadoc references.
+     */
+    private final Set<String> javadocPackages;
+
     /**
      * Lazily-built prefix tree over every fully qualified name reachable via
      * {@link TypeUtils#isAssignableTo(String, JavaType)} starting from any type referenced in this
@@ -83,7 +97,8 @@ public static TypesInUse build(JavaSourceFile cu) {
                 findTypesInUse.getTypes(),
                 findTypesInUse.getDeclaredMethods(),
                 findTypesInUse.getUsedMethods(),
-                findTypesInUse.getVariables());
+                findTypesInUse.getVariables(),
+                findTypesInUse.getJavadocPackages());
     }
 
     /**
@@ -96,7 +111,23 @@ public static TypesInUse of(JavaSourceFile cu,
                                 Set<JavaType.Method> declaredMethods,
                                 Set<JavaType.Method> usedMethods,
                                 Set<JavaType.Variable> variables) {
-        return new TypesInUse(cu, typesInUse, declaredMethods, usedMethods, variables);
+        return new TypesInUse(cu, typesInUse, declaredMethods, usedMethods, variables, Collections.emptySet());
+    }
+
+    /**
+     * Whether any fully qualified Javadoc reference in this compilation unit has a package equal to
+     * {@code packageName}, or (when {@code recursive}) starts with {@code packageName + '.'}. Mirrors the
+     * per-type package check that package-renaming recipes apply to {@link #typesInUse}, for the references
+     * that {@link #typesInUse} deliberately omits.
+     */
+    public boolean hasJavadocReferenceInPackage(String packageName, boolean recursive) {
+        String recursivePrefix = packageName + ".";
+        for (String pkg : javadocPackages) {
+            if (pkg.equals(packageName) || recursive && pkg.startsWith(recursivePrefix)) {
+                return true;
+            }
+        }
+        return false;
     }
 
     /**
@@ -509,6 +540,7 @@ public static class FindTypesInUse extends JavaIsoVisitor<Integer> {
         private final Set<JavaType.Method> declaredMethods = newSetFromMap(new IdentityHashMap<>());
         private final Set<JavaType.Method> usedMethods = newSetFromMap(new IdentityHashMap<>());
         private final Set<JavaType.Variable> variables = newSetFromMap(new IdentityHashMap<>());
+        private final Set<String> javadocPackages = new HashSet<>();
 
         @Override
         public J.Import visitImport(J.Import _import, Integer p) {
@@ -554,9 +586,14 @@ public J.Lambda.Parameters visitLambdaParameters(J.Lambda.Parameters parameters,
                         usedMethods.add((JavaType.Method) javaType);
                     }
                 } else if (!(cursor.getValue() instanceof J.ClassDeclaration) &&
-                        !(cursor.getValue() instanceof J.Lambda) &&
-                        !isFullyQualifiedJavaDocReference(cursor)) {
-                    types.add(javaType);
+                        !(cursor.getValue() instanceof J.Lambda)) {
+                    if (isFullyQualifiedJavaDocReference(cursor)) {
+                        if (javaType instanceof JavaType.FullyQualified) {
+                            javadocPackages.add(((JavaType.FullyQualified) javaType).getPackageName());
+                        }
+                    } else {
+                        types.add(javaType);
+                    }
                 }
             }
             return javaType;