Fix RemoveUnusedImports keeping import only referenced in type attribution (#7336)

* Fix RemoveUnusedImports keeping import when type only appears in type attribution (#7333)

When a type is only referenced through statically-imported methods/fields
(e.g., `doSomething(DEFAULT_SOMETHING)` where `Something` is the parameter
type), the non-static import `import org.example.a.Something` was incorrectly
kept because `TypesInUse` includes types from AST type attribution.

Add a check that verifies the imported type's simple name actually appears
as an identifier in the source code before considering the import used.

* Use reduce pattern for collectSourceIdentifierNames

Author: timtebeek

rewrite-java-test/src/test/java/org/openrewrite/java/RemoveUnusedImportsTest.java

@@ -1139,6 +1139,54 @@ public static void main(String[] args) {
         );
     }
 
+    @Issue("https://github.com/openrewrite/rewrite/issues/7333")
+    @Test
+    void removesImportUsedOnlyAsStaticImportParameterType() {
+        rewriteRun(
+          java(
+            """
+              package org.example.a;
+
+              public class Something {
+                  public static Something DEFAULT_SOMETHING = new Something();
+
+                  public static void doSomething(Something something) {
+                      System.out.println("Doing something... " + something);
+                  }
+              }
+              """
+          ),
+          java(
+            """
+              package org.example.b;
+
+              import org.example.a.Something;
+
+              import static org.example.a.Something.DEFAULT_SOMETHING;
+              import static org.example.a.Something.doSomething;
+
+              public class Test {
+                  public static void main(String[] args) {
+                      doSomething(DEFAULT_SOMETHING);
+                  }
+              }
+              """,
+            """
+              package org.example.b;
+
+              import static org.example.a.Something.DEFAULT_SOMETHING;
+              import static org.example.a.Something.doSomething;
+
+              public class Test {
+                  public static void main(String[] args) {
+                      doSomething(DEFAULT_SOMETHING);
+                  }
+              }
+              """
+          )
+        );
+    }
+
     @Issue("https://github.com/openrewrite/rewrite/issues/3275")
     @Test
     void doesNotRemoveReferencedClassesBeingUsedAsParameters() {

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

@@ -73,6 +73,10 @@ public J.CompilationUnit visitCompilationUnit(J.CompilationUnit cu, ExecutionCon
             // Collect all unqualified type references upfront for efficiency
             Set<String> unqualifiedTypeNames = collectUnqualifiedTypeNames(cu);
 
+            // Collect all identifier simple names from source (excluding imports) to detect
+            // types that only appear in type attribution but not in actual source references
+            Set<String> sourceIdentifierNames = collectSourceIdentifierNames(cu);
+
             for (JavaType.Method method : cu.getTypesInUse().getUsedMethods()) {
                 if (method.hasFlags(Flag.Static)) {
                     methodsAndFieldsByTypeName.computeIfAbsent(method.getDeclaringType().getFullyQualifiedName(), t -> new TreeSet<>())
@@ -257,6 +261,11 @@ public J.CompilationUnit visitCompilationUnit(J.CompilationUnit cu, ExecutionCon
                         } else {
                             usedWildcardImports.add(target);
                         }
+                    } else if (!sourceIdentifierNames.contains(qualid.getSimpleName())) {
+                        // The imported type's simple name doesn't appear anywhere in the source code;
+                        // it only appears in type attribution (e.g., as a parameter type of a statically imported method)
+                        anImport.used = false;
+                        changed = true;
                     } else if (combinedTypes.stream().noneMatch(c -> {
                         if ("*".equals(elem.getQualid().getSimpleName())) {
                             return elem.getPackageName().equals(c.getPackageName());
@@ -509,6 +518,25 @@ private boolean isPartOfQualifiedReference(J.Identifier identifier) {
                 }
             }.reduce(cu, new HashSet<>());
         }
+
+        /**
+         * Collect all identifier simple names appearing in source code, excluding import statements.
+         * Used to detect imports whose type name doesn't actually appear in the source.
+         */
+        private Set<String> collectSourceIdentifierNames(J.CompilationUnit cu) {
+            return new JavaIsoVisitor<Set<String>>() {
+                @Override
+                public J.Import visitImport(J.Import import_, Set<String> names) {
+                    return import_;
+                }
+
+                @Override
+                public J.Identifier visitIdentifier(J.Identifier identifier, Set<String> names) {
+                    names.add(identifier.getSimpleName());
+                    return super.visitIdentifier(identifier, names);
+                }
+            }.reduce(cu, new HashSet<>());
+        }
     }
 
     private static class ImportUsage {