Add star import ambiguity detection to ChangeType

When ChangeType moves a type into a package covered by a star import,
and another star import provides a type with the same simple name,
add an explicit import to disambiguate. This mirrors the ambiguity
handling already present in ChangePackage.

Author: steve-aom-elliott

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

@@ -19,14 +19,20 @@
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.openrewrite.*;
+import org.openrewrite.java.marker.JavaSourceSet;
 import org.openrewrite.java.search.FindTypes;
 import org.openrewrite.java.tree.J;
+import org.openrewrite.java.tree.JavaSourceFile;
 import org.openrewrite.java.tree.JavaType;
 import org.openrewrite.java.tree.NameTree;
 import org.openrewrite.java.tree.TypeUtils;
 import org.openrewrite.test.RecipeSpec;
 import org.openrewrite.test.RewriteTest;
 import org.openrewrite.test.SourceSpec;
+import org.openrewrite.test.UncheckedConsumer;
+
+import java.util.ArrayList;
+import java.util.Optional;
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -2596,4 +2602,89 @@ void changeTypeInServiceProviderFileName() {
           )
         );
     }
+
+    @Test
+    void changeTypeAddsExplicitImportWhenStarImportsWouldBeAmbiguous() {
+        rewriteRun(
+          spec -> spec.recipe(new ChangeType("a.Ambiguous", "b.Ambiguous", true))
+                  .beforeRecipe(withSourceTypesOnClasspath()),
+          java(
+            """
+              package a;
+              public class Ambiguous {}
+              """
+          ),
+          java(
+            """
+              package b;
+              public class Ambiguous {}
+              """
+          ),
+          java(
+            """
+              package b;
+              public class Other {}
+              """
+          ),
+          java(
+            """
+              package c;
+              public class Ambiguous {}
+              """
+          ),
+          java(
+            """
+              import a.Ambiguous;
+              import b.*;
+              import c.*;
+
+              class Test {
+                  Ambiguous a;
+                  Other o;
+              }
+              """,
+            """
+              import b.Ambiguous;
+              import b.*;
+              import c.*;
+
+              class Test {
+                  Ambiguous a;
+                  Other o;
+              }
+              """
+          )
+        );
+    }
+
+    private static UncheckedConsumer<java.util.List<SourceFile>> withSourceTypesOnClasspath() {
+        return sourceFiles -> {
+            java.util.List<JavaType.FullyQualified> sourceTypes = new ArrayList<>();
+            for (SourceFile sf : sourceFiles) {
+                if (sf instanceof JavaSourceFile) {
+                    for (J.ClassDeclaration classDecl : ((JavaSourceFile) sf).getClasses()) {
+                        JavaType.FullyQualified type = classDecl.getType();
+                        if (type != null) {
+                            sourceTypes.add(type);
+                        }
+                    }
+                }
+            }
+            for (int i = 0; i < sourceFiles.size(); i++) {
+                SourceFile sf = sourceFiles.get(i);
+                Optional<JavaSourceSet> maybeSourceSet = sf.getMarkers().findFirst(JavaSourceSet.class);
+                JavaSourceSet ss;
+                if (maybeSourceSet.isPresent()) {
+                    ss = maybeSourceSet.get();
+                    java.util.List<JavaType.FullyQualified> enriched = new ArrayList<>(ss.getClasspath());
+                    enriched.addAll(sourceTypes);
+                    ss = ss.withClasspath(enriched);
+                } else {
+                    ss = new JavaSourceSet(java.util.UUID.randomUUID(), "main", sourceTypes, java.util.Collections.emptyMap());
+                }
+                sourceFiles.set(i, sf.withMarkers(
+                  sf.getMarkers().computeByType(ss, (orig, upd) -> upd)));
+            }
+        };
+    }
 }

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

@@ -20,6 +20,7 @@
 import org.jspecify.annotations.Nullable;
 import org.openrewrite.*;
 import org.openrewrite.internal.ListUtils;
+import org.openrewrite.java.marker.JavaSourceSet;
 import org.openrewrite.java.search.UsesType;
 import org.openrewrite.java.tree.*;
 import org.openrewrite.marker.Markers;
@@ -276,6 +277,12 @@ private void addImport(JavaType.FullyQualified owningClass) {
                         setCursor(cursor);
                     }
                 }));
+
+                // If the new type is covered by a star import and another star import
+                // provides a type with the same simple name, add an explicit import
+                if (fullyQualifiedTarget != null) {
+                    j = maybeAddExplicitImportForAmbiguity((JavaSourceFile) j, fullyQualifiedTarget);
+                }
             }
 
             return j;
@@ -596,6 +603,77 @@ private JavaType.FullyQualified updateNestedType(JavaType.FullyQualified nestedT
             return JavaType.ShallowClass.build(newNestedFqn);
         }
 
+        /**
+         * When the new type is provided by a star import and another star import provides
+         * a type with the same simple name, add an explicit import to disambiguate.
+         */
+        private JavaSourceFile maybeAddExplicitImportForAmbiguity(JavaSourceFile sf, JavaType.FullyQualified newType) {
+            String newPkg = newType.getPackageName();
+            String simpleName = newType.getClassName();
+
+            // Check if the new type is covered by a star import
+            boolean coveredByStar = false;
+            Set<String> otherStarPackages = new LinkedHashSet<>();
+            for (J.Import anImport : sf.getImports()) {
+                if (anImport.isStatic() || !"*".equals(anImport.getQualid().getSimpleName())) {
+                    // Check if there's already an explicit import for this type
+                    if (!anImport.isStatic() && anImport.getTypeName().replace('$', '.').equals(newType.getFullyQualifiedName())) {
+                        return sf; // Already has explicit import, no ambiguity possible
+                    }
+                    continue;
+                }
+                if (anImport.getPackageName().equals(newPkg)) {
+                    coveredByStar = true;
+                } else {
+                    otherStarPackages.add(anImport.getPackageName());
+                }
+            }
+
+            if (!coveredByStar || otherStarPackages.isEmpty()) {
+                return sf;
+            }
+
+            // Check if any other star-imported package has a type with the same simple name
+            Optional<JavaSourceSet> sourceSet = sf.getMarkers().findFirst(JavaSourceSet.class);
+            if (!sourceSet.isPresent()) {
+                return sf;
+            }
+            boolean ambiguous = false;
+            for (JavaType.FullyQualified fq : sourceSet.get().getClasspath()) {
+                if (fq.getClassName().equals(simpleName) && otherStarPackages.contains(fq.getPackageName())) {
+                    ambiguous = true;
+                    break;
+                }
+            }
+
+            if (!ambiguous) {
+                return sf;
+            }
+
+            // Add an explicit import to resolve the ambiguity
+            J.Import explicitImport = new J.Import(Tree.randomId(),
+                    Space.EMPTY,
+                    Markers.EMPTY,
+                    new JLeftPadded<>(Space.EMPTY, false, Markers.EMPTY),
+                    TypeTree.build(newType.getFullyQualifiedName()).withPrefix(Space.SINGLE_SPACE),
+                    null);
+
+            List<JRightPadded<J.Import>> imports = new ArrayList<>(sf.getPadding().getImports());
+            // Insert the explicit import right before the star import for its package
+            for (int i = 0; i < imports.size(); i++) {
+                J.Import imp = imports.get(i).getElement();
+                if (!imp.isStatic() && "*".equals(imp.getQualid().getSimpleName()) && imp.getPackageName().equals(newPkg)) {
+                    // Give the explicit import the star import's prefix (which has the leading newline)
+                    JRightPadded<J.Import> padded = JRightPadded.build(explicitImport.withPrefix(imp.getPrefix()));
+                    // Give the star import a fresh newline prefix
+                    imports.set(i, imports.get(i).map(starImp -> starImp.withPrefix(Space.format("\n"))));
+                    imports.add(i, padded);
+                    break;
+                }
+            }
+            return sf.getPadding().withImports(imports);
+        }
+
         private boolean hasNoConflictingImport(@Nullable JavaSourceFile sf) {
             JavaType.FullyQualified oldType = TypeUtils.asFullyQualified(originalType);
             JavaType.FullyQualified newType = TypeUtils.asFullyQualified(targetType);