Set type attribution when unfolding star imports (#6614)

* Set type attribution when unfolding star imports

When RemoveImport unfolds a star import (e.g., import org.junit.* to
import org.junit.Test), the resulting import was missing type
attribution on its qualid field. This caused downstream recipes like
ChangeType or UpdateTestAnnotation to fail to properly match and
transform the import.

The fix adds type attribution (JavaType.ShallowClass) to the unfolded
import's qualid for non-static imports, allowing downstream recipes
to work correctly.

Fixes moderneinc/customer-requests#1521

* Expect a single cycle going forward

---------

Co-authored-by: Tim te Beek <tim@moderne.io>

Author: jkschneider

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

@@ -20,6 +20,7 @@
 import org.openrewrite.Issue;
 import org.openrewrite.Recipe;
 import org.openrewrite.java.style.ImportLayoutStyle;
+import org.openrewrite.java.tree.JavaType;
 import org.openrewrite.style.NamedStyles;
 import org.openrewrite.test.RewriteTest;
 
@@ -786,6 +787,45 @@ class Test {
         );
     }
 
+    @Issue("https://github.com/moderneinc/customer-requests/issues/1521")
+    @Test
+    void unfoldedStarImportHasTypeAttribution() {
+        rewriteRun(
+          spec -> spec.recipes(
+            removeImport("java.util.List"),
+            new ChangeType("java.util.Set", "java.util.HashSet", null)
+          ),
+          java(
+            """
+              package a;
+
+              import java.util.*;
+
+              public class A {
+                  Set<Integer> s;
+              }
+              """,
+            """
+              package a;
+
+              import java.util.HashSet;
+
+              public class A {
+                  HashSet<Integer> s;
+              }
+              """,
+            spec -> spec.afterRecipe(cu -> {
+                // Verify the unfolded import has proper type attribution
+                assertThat(cu.getImports()).hasSize(1);
+                assertThat(cu.getImports().getFirst().getQualid().getType())
+                  .isInstanceOf(JavaType.FullyQualified.class);
+                assertThat(((JavaType.FullyQualified) cu.getImports().getFirst().getQualid().getType())
+                  .getFullyQualifiedName()).isEqualTo("java.util.HashSet");
+            })
+          )
+        );
+    }
+
     @Test
     void unfoldSubpackage() {
         rewriteRun(

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

@@ -20,6 +20,7 @@
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.internal.ListUtils;
 import org.openrewrite.java.internal.FormatFirstClassPrefix;
+import org.openrewrite.java.marker.JavaSourceSet;
 import org.openrewrite.java.style.ImportLayoutStyle;
 import org.openrewrite.java.style.IntelliJ;
 import org.openrewrite.java.tree.*;
@@ -139,7 +140,7 @@ public RemoveImport(String type, boolean force) {
                         } else if (!isPackageAlwaysFolded(importLayoutStyle.getPackagesToFold(), import_) &&
                                 methodsAndFieldsUsed.size() + otherMethodsAndFieldsInTypeUsed.size() < importLayoutStyle.getNameCountToUseStarImport()) {
                             methodsAndFieldsUsed.addAll(otherMethodsAndFieldsInTypeUsed);
-                            return unfoldStarImport(import_, methodsAndFieldsUsed);
+                            return unfoldStarImport(import_, methodsAndFieldsUsed, cu);
                         }
                     } else if (TypeUtils.fullyQualifiedNamesAreEqual(typeName, type) && !methodsAndFieldsUsed.contains(imported)) {
                         // e.g. remove java.util.Collections.emptySet when type is java.util.Collections
@@ -157,7 +158,7 @@ public RemoveImport(String type, boolean force) {
                         spaceForNextImport.set(import_.getPrefix());
                         return null;
                     } else {
-                        return unfoldStarImport(import_, otherTypesInPackageUsed);
+                        return unfoldStarImport(import_, otherTypesInPackageUsed, cu);
                     }
                 }
                 return import_;
@@ -178,14 +179,53 @@ private long countTrailingLinebreaks(Space space) {
         return space.getLastWhitespace().chars().filter(s -> s == '\n').count();
     }
 
-    private Object unfoldStarImport(J.Import starImport, Set<String> otherImportsUsed) {
+    private Object unfoldStarImport(J.Import starImport, Set<String> otherImportsUsed, JavaSourceFile cu) {
         List<J.Import> unfoldedImports = new ArrayList<>(otherImportsUsed.size());
         int i = 0;
         for (String other : otherImportsUsed) {
-            J.Import unfolded = starImport.withQualid(starImport.getQualid().withName(starImport
-                    .getQualid().getName().withSimpleName(other))).withId(randomId());
+            J.FieldAccess newQualid = starImport.getQualid().withName(starImport
+                    .getQualid().getName().withSimpleName(other));
+
+            // Set type attribution on the unfolded import so downstream recipes
+            // can properly match and transform it
+            if (!starImport.isStatic()) {
+                String fqn = starImport.getPackageName() + "." + other;
+                JavaType.FullyQualified typeForImport = findType(fqn, cu);
+                newQualid = newQualid.withType(typeForImport);
+            }
+
+            J.Import unfolded = starImport.withQualid(newQualid).withId(randomId());
             unfoldedImports.add(i++ == 0 ? unfolded : unfolded.withPrefix(Space.format("\n")));
         }
         return unfoldedImports;
     }
+
+    /**
+     * Find a fully qualified type by name. First checks TypesInUse for a fully hydrated type,
+     * then checks the JavaSourceSet classpath, and falls back to creating a ShallowClass.
+     */
+    private JavaType.FullyQualified findType(String fqn, JavaSourceFile cu) {
+        // First, check if the type is already used in the source file (fully hydrated)
+        for (JavaType javaType : cu.getTypesInUse().getTypesInUse()) {
+            if (javaType instanceof JavaType.FullyQualified) {
+                JavaType.FullyQualified fq = (JavaType.FullyQualified) javaType;
+                if (TypeUtils.fullyQualifiedNamesAreEqual(fq.getFullyQualifiedName(), fqn)) {
+                    return fq;
+                }
+            }
+        }
+
+        // Check the JavaSourceSet classpath
+        Optional<JavaSourceSet> sourceSet = cu.getMarkers().findFirst(JavaSourceSet.class);
+        if (sourceSet.isPresent()) {
+            for (JavaType.FullyQualified fq : sourceSet.get().getClasspath()) {
+                if (TypeUtils.fullyQualifiedNamesAreEqual(fq.getFullyQualifiedName(), fqn)) {
+                    return fq;
+                }
+            }
+        }
+
+        // Fall back to creating a ShallowClass
+        return JavaType.ShallowClass.build(fqn);
+    }
 }

rewrite-kotlin/src/test/java/org/openrewrite/kotlin/RemoveImportTest.java

@@ -75,7 +75,7 @@ class A
     @Test
     void removeStarFoldPackage() {
         rewriteRun(
-          spec -> spec.recipe(removeTypeImportRecipe("java.io.OutputStream")).expectedCyclesThatMakeChanges(2),
+          spec -> spec.recipe(removeTypeImportRecipe("java.io.OutputStream")),
           kotlin(
             """
               import java.io.*