typeSolverClasspath) throws IOException {
- // JavaParser defaults to Java 11 and rejects newer syntax such as records; align with JavaParserTypeSolver's default.
- this.parser = new JavaParser(new ParserConfiguration().setLanguageLevel(LanguageLevel.BLEEDING_EDGE));
-
- CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
- combinedTypeSolver.add(new ReflectionTypeSolver(ReflectionTypeSolver.JCL_ONLY));
- for (File element : typeSolverClasspath) {
- if (element.isFile() && element.getName().endsWith(".jar")) {
- combinedTypeSolver.add(new JarTypeSolver(element));
- } else if (element.isDirectory()) {
- combinedTypeSolver.add(new JavaParserTypeSolver(element));
- } // gracefully ignore non-existing src-directories
- }
-
- SymbolResolver symbolSolver = new JavaSymbolSolver(combinedTypeSolver);
+ this.parser = SymbolResolution.parser();
+ SymbolResolver symbolSolver = new JavaSymbolSolver(SymbolResolution.typeSolver(typeSolverClasspath));
parser.getParserConfiguration().setSymbolResolver(symbolSolver);
}
diff --git a/lib/src/javaParser/java/com/diffplug/spotless/glue/javaparser/ReplaceStaticImportsFormatterFunc.java b/lib/src/javaParser/java/com/diffplug/spotless/glue/javaparser/ReplaceStaticImportsFormatterFunc.java
new file mode 100644
index 0000000000..619ab0512c
--- /dev/null
+++ b/lib/src/javaParser/java/com/diffplug/spotless/glue/javaparser/ReplaceStaticImportsFormatterFunc.java
@@ -0,0 +1,1839 @@
+/*
+ * Copyright 2026 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.spotless.glue.javaparser;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.IdentityHashMap;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParseResult;
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.ParserConfiguration.LanguageLevel;
+import com.github.javaparser.Position;
+import com.github.javaparser.ast.AccessSpecifier;
+import com.github.javaparser.ast.CompilationUnit;
+import com.github.javaparser.ast.ImportDeclaration;
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.NodeList;
+import com.github.javaparser.ast.PackageDeclaration;
+import com.github.javaparser.ast.body.AnnotationDeclaration;
+import com.github.javaparser.ast.body.AnnotationMemberDeclaration;
+import com.github.javaparser.ast.body.BodyDeclaration;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.CompactConstructorDeclaration;
+import com.github.javaparser.ast.body.ConstructorDeclaration;
+import com.github.javaparser.ast.body.EnumConstantDeclaration;
+import com.github.javaparser.ast.body.EnumDeclaration;
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.body.Parameter;
+import com.github.javaparser.ast.body.ReceiverParameter;
+import com.github.javaparser.ast.body.RecordDeclaration;
+import com.github.javaparser.ast.body.TypeDeclaration;
+import com.github.javaparser.ast.body.VariableDeclarator;
+import com.github.javaparser.ast.comments.Comment;
+import com.github.javaparser.ast.expr.AnnotationExpr;
+import com.github.javaparser.ast.expr.Expression;
+import com.github.javaparser.ast.expr.FieldAccessExpr;
+import com.github.javaparser.ast.expr.MemberValuePair;
+import com.github.javaparser.ast.expr.MethodCallExpr;
+import com.github.javaparser.ast.expr.MethodReferenceExpr;
+import com.github.javaparser.ast.expr.Name;
+import com.github.javaparser.ast.expr.NameExpr;
+import com.github.javaparser.ast.expr.ObjectCreationExpr;
+import com.github.javaparser.ast.expr.SimpleName;
+import com.github.javaparser.ast.expr.SuperExpr;
+import com.github.javaparser.ast.expr.ThisExpr;
+import com.github.javaparser.ast.expr.TypeExpr;
+import com.github.javaparser.ast.expr.TypePatternExpr;
+import com.github.javaparser.ast.modules.ModuleDeclaration;
+import com.github.javaparser.ast.nodeTypes.SwitchNode;
+import com.github.javaparser.ast.stmt.BreakStmt;
+import com.github.javaparser.ast.stmt.ContinueStmt;
+import com.github.javaparser.ast.stmt.ForEachStmt;
+import com.github.javaparser.ast.stmt.ForStmt;
+import com.github.javaparser.ast.stmt.LabeledStmt;
+import com.github.javaparser.ast.stmt.SwitchEntry;
+import com.github.javaparser.ast.type.ClassOrInterfaceType;
+import com.github.javaparser.ast.type.TypeParameter;
+import com.github.javaparser.resolution.Context;
+import com.github.javaparser.resolution.TypeSolver;
+import com.github.javaparser.resolution.declarations.HasAccessSpecifier;
+import com.github.javaparser.resolution.declarations.ResolvedFieldDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedMethodDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedTypeDeclaration;
+import com.github.javaparser.resolution.declarations.ResolvedValueDeclaration;
+import com.github.javaparser.resolution.model.SymbolReference;
+import com.github.javaparser.resolution.types.ResolvedReferenceType;
+import com.github.javaparser.resolution.types.ResolvedType;
+import com.github.javaparser.symbolsolver.JavaSymbolSolver;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFactory;
+
+import com.diffplug.spotless.FormatterFunc;
+
+/**
+ * Replaces static imports with regular imports and qualified references:
+ * {@code import static org.junit.jupiter.api.Assertions.assertTrue;} and {@code assertTrue(x)} become
+ * {@code import org.junit.jupiter.api.Assertions;} and {@code Assertions.assertTrue(x)}.
+ *
+ * Goal: never introduce a compile error or change behaviour
+ *
+ * Each static import is either replaced completely or left exactly as it is. It is replaced only
+ * when every occurrence of every name it can supply is known to be either
+ *
+ * a use of the import, which gets qualified with the imported type, or
+ * something else, such as a local variable, a member of an enclosing class, or the label of a
+ * {@code switch} on an enum, which stays as it is.
+ *
+ * Anything else keeps the import: a name the classpath cannot resolve, a supertype it cannot see, a name
+ * that several imports supply, a use inside a {@code spotless:off} region or a doc comment, and so on.
+ *
+ * How occurrences are classified
+ *
+ * JavaParser's resolution of method calls is not reliable enough to decide this (overloads, generics,
+ * lambdas, the order of imports), so the scoping rules of the JLS are applied directly, and JavaParser is
+ * mostly asked about types: the members of an imported type, and the members an enclosing class declares
+ * or inherits.
+ *
+ * A method, field or member type that an enclosing class declares or inherits hides a static import
+ * of the same name (JLS 6.4.1, 15.12.1), so such an occurrence is not a use of the import. Private
+ * members and static interface methods are not inherited (JLS 8.2, 8.4.8), and a class whose
+ * supertypes cannot all be resolved, or that uses Lombok, has members this step cannot see.
+ * A local variable, parameter or pattern variable hides a static import of the same name.
+ * Otherwise the name can only come from a static import. If exactly one imported type supplies it,
+ * the occurrence is a use of that import; if several do, or an import the classpath cannot resolve
+ * could, the imports are left alone.
+ * An unqualified enum constant used as a {@code case} label of a switch on an enum is resolved against
+ * the enum, not through the import (JLS 14.11.1), so it is left alone. In a switch on another type,
+ * which Java 21 allows, it is an ordinary name.
+ *
+ *
+ * Qualifying a use
+ *
+ * A use of {@code member} from type {@code T} becomes {@code T.member}, written with the simple name of
+ * {@code T} (or {@code Outer.Inner} for a nested type), adding {@code import pkg.Outer;} when needed. If that
+ * simple name means something else at the use, or the new import could change what another name in the file
+ * refers to, the fully qualified name is written instead. A static import of a member type becomes a regular
+ * import of that type, and its uses stay as they are.
+ *
+ *
Writing just {@code Math} relies on there being no other type of that name in the file's package, or in a
+ * package imported on demand. The step checks this against the classpath, and a package that is not on it may
+ * hold any type, so such names get the fully qualified form. Types missing from a package that is on it, such as
+ * generated sources, are assumed not to exist.
+ *
+ *
Edits are made to the text at the positions JavaParser reports, so formatting is preserved. New
+ * imports are added after the existing ones, so this step is meant to run before {@code importOrder()}.
+ */
+public class ReplaceStaticImportsFormatterFunc implements FormatterFunc.Closeable {
+ private static final Pattern STATIC_IMPORT = Pattern.compile("\\bimport\\s+static\\b");
+ private static final Pattern MULTI_RELEASE = Pattern.compile("^META-INF/versions/\\d+/");
+ /** A unicode escape of a line terminator, which javac reads as a line break, e.g. hiding code behind a {@code //}. */
+ private static final Pattern ESCAPED_LINE_TERMINATOR = Pattern.compile("(? FENCES = List.of(
+ Pattern.compile("spotless:off[\\s\\S]*?spotless:on"),
+ Pattern.compile("@formatter:off[\\s\\S]*?@formatter:on"));
+ /** Unqualified references in doc comments: {@code {@link name}}, {@code @see name}, {@code @throws name}... */
+ private static final Pattern DOC_REFERENCE = Pattern.compile("(?:\\{@(?:link|linkplain|value)|@(?:see|throws|exception))\\s+([A-Za-z_$][\\w$]*)(?![\\w$.#])");
+ /** Unqualified references in Markdown doc comments: {@code [name]} and {@code [name(int)]}. */
+ private static final Pattern MARKDOWN_REFERENCE = Pattern.compile("\\[([A-Za-z_$][\\w$]*)(?:\\([^)\\]]*\\))?\\]");
+ /** Methods that every class, enum, record and interface has as members (JLS 4.3.2, 9.2). */
+ private static final Set OBJECT_METHODS = Set.of("clone", "equals", "finalize", "getClass", "hashCode", "notify", "notifyAll", "toString", "wait");
+
+ private final Collection typeSolverClasspath;
+ private final Set excludes;
+ /** Reads unicode escapes like javac does, so that a name spelled with them is seen; positions stay those of the text. */
+ private final JavaParser parser = new JavaParser(new ParserConfiguration().setLanguageLevel(LanguageLevel.BLEEDING_EDGE).setPreprocessUnicodeEscapes(true));
+ /** The packages of each jar on the classpath, read when first needed. */
+ private final Map> jarPackages = new HashMap<>();
+ private final Map knownPackages = new HashMap<>();
+ /** How many classpath entries have a top-level class, by its path such as {@code com/acme/Base}. */
+ private final Map copiesOnClasspath = new HashMap<>();
+ private static volatile Set jdkPackages;
+ /** Created when the first file with a static import is formatted, since building it reads every jar. */
+ private TypeSolver typeSolver;
+ private JavaSymbolSolver symbolSolver;
+ private boolean typeSolverFailed;
+
+ public ReplaceStaticImportsFormatterFunc(Collection typeSolverClasspath, Collection excludes) {
+ this.typeSolverClasspath = List.copyOf(typeSolverClasspath);
+ this.excludes = Set.copyOf(excludes);
+ }
+
+ /** Synchronized because JavaParser's parser and type solver caches are not thread-safe. */
+ @Override
+ public synchronized String apply(String rawUnix) {
+ if (!STATIC_IMPORT.matcher(rawUnix).find() || ESCAPED_LINE_TERMINATOR.matcher(rawUnix).find()) {
+ // the edits rely on the lines of the text being the lines that javac sees
+ return rawUnix;
+ }
+ try {
+ ParseResult parsed = parser.parse(rawUnix);
+ if (!parsed.isSuccessful() || parsed.getResult().isEmpty()) {
+ return rawUnix;
+ }
+ CompilationUnit cu = parsed.getResult().get();
+ if (cu.getImports().stream().noneMatch(ImportDeclaration::isStatic) || cu.getModule().isPresent() || !initializeTypeSolver()) {
+ return rawUnix;
+ }
+ symbolSolver.inject(cu);
+ String result = new Rewrite(cu, rawUnix).apply();
+ if (result.equals(rawUnix) || !parser.parse(result).isSuccessful()) {
+ return rawUnix;
+ }
+ return result;
+ } catch (RuntimeException | StackOverflowError e) {
+ // JavaParser can fail in many ways on code it does not fully understand: when in doubt, leave the file alone
+ return rawUnix;
+ }
+ }
+
+ /** Creates the type solver on first use. False if that failed, e.g. for an unreadable jar: then every file stays as it is. */
+ private boolean initializeTypeSolver() {
+ if (symbolSolver == null && !typeSolverFailed) {
+ try {
+ // the files of the source directories need symbol resolution too, e.g. to find the type that contains a nested one
+ ParserConfiguration sourceConfiguration = new ParserConfiguration().setLanguageLevel(LanguageLevel.BLEEDING_EDGE).setPreprocessUnicodeEscapes(true);
+ TypeSolver solver = SymbolResolution.typeSolver(typeSolverClasspath, sourceConfiguration);
+ JavaSymbolSolver resolver = new JavaSymbolSolver(solver);
+ sourceConfiguration.setSymbolResolver(resolver);
+ typeSolver = solver;
+ symbolSolver = resolver;
+ } catch (IOException | RuntimeException e) {
+ typeSolverFailed = true;
+ }
+ }
+ return symbolSolver != null;
+ }
+
+ /** Releases the type solver, which JavaParser would otherwise keep in a static cache for as long as its classes are loaded. */
+ @Override
+ public synchronized void close() {
+ typeSolver = null;
+ symbolSolver = null;
+ SymbolResolution.release();
+ }
+
+ /**
+ * Whether the type solver can see the package, so that not finding a type in it means the type does not exist.
+ * A package it cannot see, e.g. generated code or another module's classes, may hold any type.
+ */
+ private boolean isKnownPackage(String packageName) {
+ return knownPackages.computeIfAbsent(packageName, this::findPackage);
+ }
+
+ private boolean findPackage(String packageName) {
+ if (jdkPackages().contains(packageName)) {
+ return true;
+ }
+ String path = packageName.replace('.', '/');
+ for (File entry : typeSolverClasspath) {
+ if (entry.isDirectory()) {
+ // only sources count: the type solver cannot read the class files of an output directory
+ File[] sources = new File(entry, path).listFiles((dir, name) -> name.endsWith(".java"));
+ if (sources != null && sources.length > 0) {
+ return true;
+ }
+ } else if (entry.isFile() && entry.getName().endsWith(".jar") && jarPackages.computeIfAbsent(entry, ReplaceStaticImportsFormatterFunc::packagesOf).contains(packageName)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Whether more than one jar on the classpath has the top-level class of the type, e.g. two versions of a library.
+ * A source directory and the classes compiled from it hold the same class, so directories do not count.
+ */
+ private boolean isOnClasspathTwice(ResolvedReferenceTypeDeclaration type) {
+ String packageName = type.getPackageName();
+ if (jdkPackages().contains(packageName)) {
+ return false;
+ }
+ String topLevel = type.getClassName().split("\\.")[0];
+ String path = packageName.isEmpty() ? topLevel : packageName.replace('.', '/') + "/" + topLevel;
+ return copiesOnClasspath.computeIfAbsent(path, this::countCopies) > 1;
+ }
+
+ private int countCopies(String path) {
+ int copies = 0;
+ String packageName = path.contains("/") ? path.substring(0, path.lastIndexOf('/')).replace('/', '.') : "";
+ for (File entry : typeSolverClasspath) {
+ if (entry.isFile() && entry.getName().endsWith(".jar")
+ && jarPackages.computeIfAbsent(entry, ReplaceStaticImportsFormatterFunc::packagesOf).contains(packageName)) {
+ try (ZipFile zip = new ZipFile(entry)) {
+ if (zip.getEntry(path + ".class") != null) {
+ copies++;
+ }
+ } catch (IOException e) {
+ copies++; // unreadable: assume it may have the class
+ }
+ }
+ }
+ return copies;
+ }
+
+ private static Set packagesOf(File jar) {
+ Set packages = new HashSet<>();
+ try (ZipFile zip = new ZipFile(jar)) {
+ zip.stream().map(ZipEntry::getName).filter(name -> name.endsWith(".class")).forEach(name -> {
+ String path = MULTI_RELEASE.matcher(name).replaceFirst("");
+ int slash = path.lastIndexOf('/');
+ packages.add(slash < 0 ? "" : path.substring(0, slash).replace('/', '.'));
+ });
+ } catch (IOException e) {
+ // an unreadable jar shows no packages, so nothing is assumed about them
+ }
+ return packages;
+ }
+
+ private static Set jdkPackages() {
+ Set packages = jdkPackages;
+ if (packages == null) {
+ packages = new HashSet<>();
+ for (Module module : ModuleLayer.boot().modules()) {
+ packages.addAll(module.getPackages());
+ }
+ jdkPackages = packages;
+ }
+ return packages;
+ }
+
+ /** The kinds of member a static import can supply. */
+ private enum Kind {
+ METHOD, FIELD, TYPE
+ }
+
+ /** One resolved static import declaration, and what is known about it. */
+ private static final class StaticImport {
+ final ImportDeclaration declaration;
+ final ResolvedReferenceTypeDeclaration type;
+ final Map> names = new EnumMap<>(Kind.class);
+ final Set enumConstants = new HashSet<>();
+ /** Canonical names of the member types declared in the imported type itself, by simple name. */
+ final Map declaredMemberTypes = new HashMap<>();
+ /** The parameter counts of the imported type's instance methods, which compete with its static ones once a call is qualified. */
+ final Map> instanceMethods = new HashMap<>();
+ /** The types that declare the static methods and fields this import supplies, by name. */
+ final Map> declaringTypes = new HashMap<>();
+ /** True when this import must stay, because it is excluded or some occurrence could not be classified with certainty. */
+ boolean keep;
+
+ StaticImport(ImportDeclaration declaration, ResolvedReferenceTypeDeclaration type) {
+ this.declaration = declaration;
+ this.type = type;
+ for (Kind kind : Kind.values()) {
+ names.put(kind, new HashSet<>());
+ }
+ }
+
+ boolean supplies(Kind kind, String name) {
+ return names.get(kind).contains(name);
+ }
+
+ boolean suppliesAnything(String name) {
+ return supplies(Kind.METHOD, name) || supplies(Kind.FIELD, name) || supplies(Kind.TYPE, name);
+ }
+
+ void retainOnly(String member) {
+ for (Set set : names.values()) {
+ set.retainAll(Set.of(member));
+ }
+ enumConstants.retainAll(Set.of(member));
+ }
+ }
+
+ /** How many arguments a method takes. */
+ private record Arity(int parameters, boolean varargs) {
+ boolean accepts(int arguments) {
+ return varargs ? arguments >= parameters - 1 : arguments == parameters;
+ }
+ }
+
+ /** An occurrence that uses a static import, and so will be qualified. */
+ private record Use(Node node, String name, StaticImport source) {}
+
+ /** What the enclosing classes of an occurrence say about a name. */
+ private enum Membership {
+ /** An enclosing class certainly declares or inherits a member of that name. */
+ MEMBER,
+ /** No enclosing class declares or inherits a member of that name. */
+ NOT_MEMBER,
+ /** It cannot be decided, e.g. because a supertype cannot be resolved. */
+ UNKNOWN
+ }
+
+ /** The member names of one kind that a class has. */
+ private static final class Members {
+ /** Names it certainly has: declared in it, or inherited from a supertype. */
+ final Set certain = new HashSet<>();
+ /** Names it may have, such as package-private members of a supertype. */
+ final Set possible = new HashSet<>();
+ /** False when some members cannot be seen, e.g. because a supertype cannot be resolved. */
+ boolean complete = true;
+
+ void add(String name, boolean isCertain) {
+ possible.add(name);
+ if (isCertain) {
+ certain.add(name);
+ }
+ }
+ }
+
+ /** A class around an occurrence, and whether the occurrence is in its body, where its members are in scope. */
+ private record EnclosingScope(Node node, boolean inBody) {}
+
+ /** What a simple type name refers to at some point of the file. */
+ private enum Visible {
+ /** No type of that name is visible. */
+ NOTHING,
+ /** The expected type. */
+ EXPECTED,
+ /** A top-level type from the same package, an on-demand import or {@code java.lang}, which a single-type import would shadow. */
+ SHADOWABLE,
+ /** Another type, such as a member type in scope, which an import cannot shadow. */
+ OTHER,
+ /** It cannot be determined. */
+ UNKNOWN
+ }
+
+ /** How to qualify a use: the text to write before it, and the import that text needs, or null. */
+ private record Qualifier(String text, String importName) {}
+
+ /** The edits that replace one static import's uses, and the imports they need. */
+ private static final class Plan {
+ final List insertions = new ArrayList<>();
+ final Set imports = new TreeSet<>();
+ }
+
+ private record Edit(int start, int end, String replacement) {}
+
+ /** The work for one file. */
+ private final class Rewrite {
+ private final CompilationUnit cu;
+ private final String text;
+ private final int[] lineOffsets;
+ private final String packageName;
+ private final List imports = new ArrayList<>();
+ /** Members named by single static imports that cannot be resolved: any occurrence of these names may use them. */
+ private final Set unresolvedNames = new HashSet<>();
+ /** Simple name -> canonical name, for the non-static single-type imports. */
+ private final Map typeImports = new HashMap<>();
+ private final Set declaredTypeNames = new HashSet<>();
+ private final Set declaredTypeQualifiedNames = new HashSet<>();
+ private final Set typeParameterNames = new HashSet<>();
+ private final Set variableNames = new HashSet<>();
+ /** The text ranges that {@code toggleOffOn()} would restore, as start and end offsets. */
+ private final List fences = new ArrayList<>();
+ private final Map> membersCache = new IdentityHashMap<>();
+ private final Map usedUnqualifiedCache = new HashMap<>();
+ private final List uses = new ArrayList<>();
+ /** Canonical names of the member types to import, for each static import that supplies them. */
+ private final Map> memberTypeImports = new IdentityHashMap<>();
+ /** Simple name -> canonical name, for the imports planned so far for qualified uses. */
+ private final Map plannedSimpleNames = new HashMap<>();
+
+ Rewrite(CompilationUnit cu, String text) {
+ this.cu = cu;
+ this.text = text;
+ this.lineOffsets = lineOffsets(text);
+ this.packageName = cu.getPackageDeclaration().map(PackageDeclaration::getNameAsString).orElse("");
+ }
+
+ String apply() {
+ collectFileFacts();
+ for (ImportDeclaration declaration : cu.getImports()) {
+ if (isFenced(declaration)) {
+ return text; // toggleOffOn() would restore it, whatever this step does
+ }
+ }
+ for (ImportDeclaration declaration : cu.getImports()) {
+ if (!declaration.isStatic()) {
+ continue;
+ }
+ Optional resolved = resolveImport(declaration);
+ if (resolved.isPresent()) {
+ resolved.get().keep |= isExcluded(declaration);
+ imports.add(resolved.get());
+ } else if (declaration.isAsterisk()) {
+ return text; // it could supply any name, so no name in the file can be attributed with certainty
+ } else {
+ unresolvedNames.add(declaration.getName().getIdentifier());
+ }
+ }
+ if (imports.stream().allMatch(i -> i.keep)) {
+ return text;
+ }
+ classifyOccurrences();
+ keepImportsReferencedInComments();
+ return edit();
+ }
+
+ private void collectFileFacts() {
+ for (ImportDeclaration declaration : cu.getImports()) {
+ if (!declaration.isStatic() && !declaration.isAsterisk() && !declaration.isModule()) {
+ typeImports.put(declaration.getName().getIdentifier(), declaration.getNameAsString());
+ }
+ }
+ for (TypeDeclaration> declaration : cu.findAll(TypeDeclaration.class)) {
+ declaredTypeNames.add(declaration.getNameAsString());
+ declaration.getFullyQualifiedName().ifPresent(declaredTypeQualifiedNames::add);
+ }
+ for (TypeParameter parameter : cu.findAll(TypeParameter.class)) {
+ declaredTypeNames.add(parameter.getNameAsString());
+ typeParameterNames.add(parameter.getNameAsString());
+ }
+ for (VariableDeclarator variable : cu.findAll(VariableDeclarator.class)) {
+ variableNames.add(variable.getNameAsString());
+ }
+ for (Parameter parameter : cu.findAll(Parameter.class)) {
+ variableNames.add(parameter.getNameAsString());
+ }
+ for (TypePatternExpr pattern : cu.findAll(TypePatternExpr.class)) {
+ variableNames.add(pattern.getNameAsString());
+ }
+ for (EnumConstantDeclaration constant : cu.findAll(EnumConstantDeclaration.class)) {
+ variableNames.add(constant.getNameAsString());
+ }
+ for (Pattern fence : FENCES) {
+ Matcher matcher = fence.matcher(text);
+ while (matcher.find()) {
+ fences.add(new int[]{matcher.start(), matcher.end()});
+ }
+ }
+ }
+
+ /**
+ * {@code Type.*}, or just {@code Type}, keeps every static import from that type. {@code Type.member} keeps the
+ * static import of that member, and an on-demand import of the type if the file uses that member through it.
+ */
+ private boolean isExcluded(ImportDeclaration declaration) {
+ String name = declaration.getNameAsString();
+ if (declaration.isAsterisk()) {
+ return excludes.contains(name + ".*") || excludes.contains(name) || usesExcludedMember(name);
+ }
+ String type = declaration.getName().getQualifier().map(Name::asString).orElse("");
+ return excludes.contains(name) || excludes.contains(type + ".*") || excludes.contains(type);
+ }
+
+ private boolean usesExcludedMember(String type) {
+ for (String exclude : excludes) {
+ String member = exclude.startsWith(type + ".") ? exclude.substring(type.length() + 1) : "";
+ if (!member.isEmpty() && !member.contains(".") && !member.equals("*")
+ && cu.findAll(SimpleName.class).stream().anyMatch(name -> name.getIdentifier().equals(member))) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private boolean isFenced(Node node) {
+ if (fences.isEmpty()) {
+ return false;
+ }
+ int begin = node.getBegin().map(this::offset).orElse(-1);
+ for (int[] fence : fences) {
+ if (begin < 0 || (fence[0] <= begin && begin < fence[1])) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ // ---------------------------------------------------------------- the imports
+
+ /** Resolves the imported type and the names it supplies; empty if that cannot be done with certainty. */
+ private Optional resolveImport(ImportDeclaration declaration) {
+ String typeName = declaration.isAsterisk()
+ ? declaration.getNameAsString()
+ : declaration.getName().getQualifier().map(Name::asString).orElse("");
+ if (typeName.isEmpty()) {
+ return Optional.empty();
+ }
+ try {
+ SymbolReference reference = typeSolver.tryToSolveType(typeName);
+ if (!reference.isSolved()) {
+ return Optional.empty();
+ }
+ ResolvedReferenceTypeDeclaration type = reference.getCorrespondingDeclaration();
+ if (!typeName.equals(type.getQualifiedName())) {
+ return Optional.empty(); // not the canonical name, so something does not match what the compiler sees
+ }
+ requireCompleteAncestry(type, new HashSet<>());
+ StaticImport staticImport = new StaticImport(declaration, type);
+ collectMembers(staticImport);
+ if (!declaration.isAsterisk()) {
+ String member = declaration.getName().getIdentifier();
+ staticImport.retainOnly(member);
+ if (!staticImport.suppliesAnything(member)) {
+ return Optional.empty(); // the type solver does not see this member
+ }
+ }
+ return Optional.of(staticImport);
+ } catch (RuntimeException e) {
+ return Optional.empty();
+ }
+ }
+
+ /** Collects the static members that a static import of the type supplies to this file (JLS 6.6, 7.5.3, 7.5.4, 8.4.8). */
+ private void collectMembers(StaticImport staticImport) {
+ ResolvedReferenceTypeDeclaration type = staticImport.type;
+ Set methods = new LinkedHashSet<>(type.getDeclaredMethods());
+ type.getAllMethods().forEach(method -> methods.add(method.getDeclaration()));
+ for (ResolvedMethodDeclaration method : methods) {
+ ResolvedReferenceTypeDeclaration declaringType = method.declaringType();
+ if (!method.isStatic()) {
+ if (method.accessSpecifier() != AccessSpecifier.PRIVATE) {
+ staticImport.instanceMethods.computeIfAbsent(method.getName(), name -> new ArrayList<>())
+ .add(new Arity(method.getNumberOfParams(), method.hasVariadicParameter()));
+ }
+ } else if (isImportable(method.accessSpecifier(), declaringType)
+ && !(declaringType.isInterface() && !declaringType.getQualifiedName().equals(type.getQualifiedName()))) {
+ // static methods of an interface are not inherited
+ staticImport.names.get(Kind.METHOD).add(method.getName());
+ staticImport.declaringTypes.computeIfAbsent(method.getName(), name -> new HashSet<>()).add(declaringType.getQualifiedName());
+ }
+ }
+ for (ResolvedFieldDeclaration field : type.getAllFields()) {
+ boolean implicitlyPublicStatic = isInterfaceOrAnnotation(field.declaringType());
+ if ((field.isStatic() || implicitlyPublicStatic)
+ && (implicitlyPublicStatic || isImportable(field.accessSpecifier(), field.declaringType()))) {
+ staticImport.names.get(Kind.FIELD).add(field.getName());
+ staticImport.declaringTypes.computeIfAbsent(field.getName(), name -> new HashSet<>()).add(field.declaringType().getQualifiedName());
+ }
+ }
+ if (type.isEnum()) {
+ for (var constant : type.asEnum().getEnumConstants()) {
+ staticImport.names.get(Kind.FIELD).add(constant.getName());
+ staticImport.declaringTypes.computeIfAbsent(constant.getName(), name -> new HashSet<>()).add(type.getQualifiedName());
+ staticImport.enumConstants.add(constant.getName());
+ }
+ }
+ for (ResolvedReferenceTypeDeclaration owner : withAncestors(type)) {
+ for (ResolvedReferenceTypeDeclaration memberType : owner.internalTypes()) {
+ if (isInterfaceOrAnnotation(owner) || isImportable(accessOf(memberType), owner)) {
+ staticImport.names.get(Kind.TYPE).add(memberType.getName());
+ if (owner == type) {
+ staticImport.declaredMemberTypes.put(memberType.getName(), memberType.getQualifiedName());
+ }
+ }
+ }
+ }
+ }
+
+ /** Whether a member with that access, declared in that type, can be imported into this file. */
+ private boolean isImportable(AccessSpecifier access, ResolvedTypeDeclaration declaringType) {
+ if (access == AccessSpecifier.PUBLIC) {
+ return true;
+ }
+ // protected and package-private members are only accessible from the same package here, and private ones never
+ return access != AccessSpecifier.PRIVATE && packageOf(declaringType).equals(packageName);
+ }
+
+ /**
+ * Fails if any ancestor of the type cannot be resolved, or if the type may get members from Lombok: JavaParser would
+ * silently miss them. Also fails for a type that is on the classpath twice, e.g. in two versions of a library, since
+ * the compiler may see the other one.
+ */
+ private void requireCompleteAncestry(ResolvedReferenceTypeDeclaration type, Set seen) {
+ if (!seen.add(type.getQualifiedName())) {
+ return;
+ }
+ if (type.toAst(TypeDeclaration.class).filter(ReplaceStaticImportsFormatterFunc::usesLombok).isPresent()) {
+ throw new IllegalStateException("Lombok generates members that JavaParser cannot see");
+ }
+ if (isOnClasspathTwice(type)) {
+ throw new IllegalStateException(type.getQualifiedName() + " is on the classpath twice");
+ }
+ for (ResolvedReferenceType ancestor : type.getAncestors(false)) {
+ requireCompleteAncestry(ancestor.getTypeDeclaration().orElseThrow(), seen);
+ }
+ }
+
+ // ---------------------------------------------------------------- the occurrences
+
+ /** Classifies every occurrence of every name the static imports supply. */
+ private void classifyOccurrences() {
+ Set suppliedNames = new HashSet<>(unresolvedNames);
+ for (StaticImport staticImport : imports) {
+ staticImport.names.values().forEach(suppliedNames::addAll);
+ }
+ boolean closedWorld = imports.stream().anyMatch(i -> i.declaration.isAsterisk() && !i.keep);
+ for (SimpleName name : cu.findAll(SimpleName.class)) {
+ String identifier = name.getIdentifier();
+ if (suppliedNames.contains(identifier)) {
+ if (unresolvedNames.contains(identifier) || isFenced(name)) {
+ keepSuppliersOf(identifier, Kind.values());
+ } else {
+ classify(name);
+ }
+ } else if (closedWorld) {
+ checkExplained(name);
+ }
+ }
+ for (Name name : cu.findAll(Name.class)) {
+ if (name.getQualifier().isPresent()) {
+ continue;
+ }
+ String identifier = name.getIdentifier();
+ if (suppliedNames.contains(identifier)) {
+ if (unresolvedNames.contains(identifier) || isFenced(name)) {
+ keepSuppliersOf(identifier, Kind.values());
+ } else {
+ classifyLeftmostName(name);
+ }
+ } else if (closedWorld && name.getParentNode().orElse(null) instanceof AnnotationExpr annotation && !resolves(annotation)) {
+ keepOnDemandImports();
+ }
+ }
+ }
+
+ private void classify(SimpleName name) {
+ Node parent = name.getParentNode().orElse(null);
+ String identifier = name.getIdentifier();
+ if (parent instanceof MethodCallExpr call && call.getName() == name) {
+ if (call.getScope().isEmpty()) {
+ classifyMethodCall(call, identifier);
+ } // else a member access, such as `list.max()`
+ } else if (parent instanceof NameExpr nameExpr) {
+ classifyExpressionName(nameExpr, identifier);
+ } else if (parent instanceof ClassOrInterfaceType type && type.getName() == name) {
+ if (type.getScope().isPresent()) {
+ return; // a member type, such as `Map.Entry`
+ }
+ if (isMethodReferenceScope(type) && suppliesField(identifier)) {
+ // `NAMES::add` is parsed as a type, but it may well be a field
+ classifyFieldUse(type, identifier);
+ } else {
+ classifyTypeName(type, identifier);
+ }
+ } else if (!isDeclarationOrMemberAccess(parent)) {
+ // a position this step does not know about: be safe
+ keepSuppliersOf(identifier, Kind.values());
+ }
+ }
+
+ /** True for the parent of a {@code SimpleName} that declares something, or that names a member of something else. */
+ private boolean isDeclarationOrMemberAccess(Node parent) {
+ return parent instanceof FieldAccessExpr
+ || parent instanceof MethodCallExpr
+ || parent instanceof ClassOrInterfaceType
+ || parent instanceof MethodDeclaration
+ || parent instanceof ConstructorDeclaration
+ || parent instanceof CompactConstructorDeclaration
+ || parent instanceof AnnotationMemberDeclaration
+ || parent instanceof VariableDeclarator
+ || parent instanceof Parameter
+ || parent instanceof ReceiverParameter
+ || parent instanceof TypeDeclaration
+ || parent instanceof EnumConstantDeclaration
+ || parent instanceof TypeParameter
+ || parent instanceof TypePatternExpr
+ || parent instanceof MemberValuePair
+ || parent instanceof LabeledStmt
+ || parent instanceof BreakStmt
+ || parent instanceof ContinueStmt;
+ }
+
+ /** The leftmost segment of a {@link Name}, as used by annotations, imports, packages, modules and {@code Outer.this}. */
+ private void classifyLeftmostName(Name name) {
+ Node root = name;
+ Node parent = root.getParentNode().orElse(null);
+ while (parent instanceof Name qualified && qualified.getQualifier().isPresent() && qualified.getQualifier().get() == root) {
+ root = parent;
+ parent = root.getParentNode().orElse(null);
+ }
+ if (parent instanceof ImportDeclaration || parent instanceof PackageDeclaration || parent instanceof ModuleDeclaration
+ || (parent != null && parent.findAncestor(ModuleDeclaration.class).isPresent())) {
+ return;
+ }
+ if (parent instanceof AnnotationExpr || parent instanceof SuperExpr || parent instanceof ThisExpr) {
+ classifyTypeName(name, name.getIdentifier()); // `@Outer.Inner`, `Listener.super.m()`, `Outer.this`
+ } else {
+ keepSuppliersOf(name.getIdentifier(), Kind.values());
+ }
+ }
+
+ /**
+ * The closed-world check for on-demand imports: the type solver may not see every member an on-demand
+ * import supplies (version skew, Lombok), so they are only removed if every other simple name in the file
+ * is explained by something else.
+ */
+ private void checkExplained(SimpleName name) {
+ Node parent = name.getParentNode().orElse(null);
+ boolean explained = true;
+ if (parent instanceof MethodCallExpr call && call.getName() == name && call.getScope().isEmpty()) {
+ explained = membership(call, Kind.METHOD, name.getIdentifier()) == Membership.MEMBER;
+ } else if (parent instanceof NameExpr nameExpr) {
+ explained = resolves(nameExpr);
+ } else if (parent instanceof ClassOrInterfaceType type && type.getName() == name && type.getScope().isEmpty()) {
+ explained = declaredTypeNames.contains(name.getIdentifier()) || resolves(type);
+ }
+ if (!explained) {
+ keepOnDemandImports();
+ }
+ }
+
+ private boolean resolves(NameExpr nameExpr) {
+ try {
+ nameExpr.resolve();
+ return true;
+ } catch (RuntimeException e) {
+ // not a variable: a type used as a qualifier, or the first segment of a package name
+ if (isQualifier(nameExpr) && visibleType(context(nameExpr), nameExpr.getNameAsString(), null) != Visible.NOTHING) {
+ return true;
+ }
+ return nameExpr.getParentNode().orElse(null) instanceof FieldAccessExpr && Character.isLowerCase(nameExpr.getNameAsString().charAt(0));
+ }
+ }
+
+ private boolean resolves(ClassOrInterfaceType type) {
+ try {
+ type.resolve();
+ return true;
+ } catch (RuntimeException e) {
+ return false;
+ }
+ }
+
+ private boolean resolves(AnnotationExpr annotation) {
+ try {
+ annotation.resolve();
+ return true;
+ } catch (RuntimeException e) {
+ return false;
+ }
+ }
+
+ private void keepOnDemandImports() {
+ for (StaticImport staticImport : imports) {
+ if (staticImport.declaration.isAsterisk()) {
+ staticImport.keep = true;
+ }
+ }
+ }
+
+ /** {@code name(...)} without a scope (JLS 15.12.1). */
+ private void classifyMethodCall(MethodCallExpr call, String name) {
+ switch (membership(call, Kind.METHOD, name)) {
+ case MEMBER:
+ return; // a method of an enclosing class, not the import
+ case UNKNOWN:
+ keepSuppliersOf(name, Kind.METHOD);
+ return;
+ case NOT_MEMBER:
+ break;
+ }
+ Optional source = onlySupplier(name, Kind.METHOD);
+ if (source.isEmpty()) {
+ return;
+ }
+ int arguments = call.getArguments().size();
+ boolean instanceOverload = source.get().instanceMethods.getOrDefault(name, List.of()).stream().anyMatch(arity -> arity.accepts(arguments));
+ if (instanceOverload) {
+ // once qualified as `T.name(...)`, an instance method of T could be the one picked, which does not compile
+ keepSuppliersOf(name, Kind.METHOD);
+ return;
+ }
+ uses.add(new Use(call, name, source.get()));
+ }
+
+ /** An unqualified name in an expression: a variable, a field, or a type used as a qualifier. */
+ private void classifyExpressionName(NameExpr nameExpr, String name) {
+ if (nameExpr.getParentNode().orElse(null) instanceof SwitchEntry entry && entry.getLabels().contains(nameExpr)) {
+ switch (switchesOnEnum(entry)) {
+ case MEMBER:
+ return; // resolved against the enum type of the switch, not through the import (JLS 14.11.1)
+ case UNKNOWN:
+ keepSuppliersOf(name, Kind.values());
+ return;
+ case NOT_MEMBER:
+ break; // a switch on another type, where the label is an ordinary name (Java 21)
+ }
+ }
+ if (suppliesField(name)) {
+ classifyFieldUse(nameExpr, name); // a variable obscures a type of the same name (JLS 6.4.2)
+ } else if (imports.stream().anyMatch(i -> i.supplies(Kind.TYPE, name))) {
+ if (isQualifier(nameExpr)) {
+ classifyTypeName(nameExpr, name);
+ } else {
+ keepSuppliersOf(name, Kind.TYPE);
+ }
+ }
+ // otherwise the name is only supplied as a method, which a name in an expression cannot refer to
+ }
+
+ /** {@link Membership#MEMBER} if the switch of this entry is on an enum type, NOT_MEMBER if it is certainly on another type. */
+ private Membership switchesOnEnum(SwitchEntry entry) {
+ try {
+ Expression selectorExpression = ((SwitchNode) entry.getParentNode().orElseThrow()).getSelector();
+ for (NameExpr name : selectorExpression.findAll(NameExpr.class)) {
+ if (isOutOfScopeLoopVariable(name)) {
+ return Membership.UNKNOWN; // JavaParser would give the selector the type of a variable that is not in scope
+ }
+ }
+ ResolvedType selector = selectorExpression.calculateResolvedType();
+ if (selector.isPrimitive()) {
+ return Membership.NOT_MEMBER;
+ }
+ if (selector.isReferenceType()) {
+ Optional declaration = selector.asReferenceType().getTypeDeclaration();
+ if (declaration.isPresent()) {
+ return declaration.get().isEnum() ? Membership.MEMBER : Membership.NOT_MEMBER;
+ }
+ }
+ return Membership.UNKNOWN; // e.g. a type variable that JavaParser could not infer
+ } catch (RuntimeException e) {
+ return Membership.UNKNOWN;
+ }
+ }
+
+ /** JavaParser keeps the variable of a for loop in scope after the loop, which javac does not. */
+ private boolean isOutOfScopeLoopVariable(NameExpr nameExpr) {
+ try {
+ return isOutOfScopeLoopVariable(nameExpr.resolve(), nameExpr);
+ } catch (RuntimeException e) {
+ return false;
+ }
+ }
+
+ private boolean isOutOfScopeLoopVariable(ResolvedValueDeclaration value, Node occurrence) {
+ Node declaration = value.toAst().orElse(null);
+ if (declaration instanceof VariableDeclarator) {
+ declaration = declaration.getParentNode().orElse(null);
+ }
+ Node variable = declaration;
+ Node loop = variable == null ? null : variable.getParentNode().orElse(null);
+ boolean loopVariable = (loop instanceof ForStmt forStmt && forStmt.getInitialization().stream().anyMatch(init -> init == variable))
+ || (loop instanceof ForEachStmt forEach && forEach.getVariable() == variable);
+ return loopVariable && !occurrence.isDescendantOf(loop);
+ }
+
+ /** A use of a static field: an unqualified name in an expression, or the scope of a method reference. */
+ private void classifyFieldUse(Node node, String name) {
+ switch (localOrField(node, name)) {
+ case MEMBER:
+ return; // a local variable, a parameter or a field of an enclosing class
+ case UNKNOWN:
+ keepSuppliersOf(name, Kind.FIELD, Kind.TYPE);
+ return;
+ case NOT_MEMBER:
+ onlySupplier(name, Kind.FIELD).ifPresent(source -> uses.add(new Use(node, name, source)));
+ return;
+ }
+ }
+
+ /** For a name in an expression, a local variable or a field of an enclosing class counts as {@link Membership#MEMBER}. */
+ private Membership localOrField(Node node, String name) {
+ try {
+ Optional extends ResolvedValueDeclaration> value;
+ if (node instanceof NameExpr nameExpr) {
+ value = Optional.of(nameExpr.resolve());
+ } else {
+ SymbolReference extends ResolvedValueDeclaration> reference = context(node).solveSymbol(name);
+ value = reference.isSolved() ? Optional.of(reference.getCorrespondingDeclaration()) : Optional.empty();
+ }
+ if (value.isPresent() && !value.get().isField() && !value.get().isEnumConstant()) {
+ return isOutOfScopeLoopVariable(value.get(), node) ? Membership.UNKNOWN : Membership.MEMBER;
+ }
+ } catch (RuntimeException e) {
+ // JavaParser could not resolve it, so look for a local of that name ourselves
+ if (hasLocalNamed(node, name)) {
+ return Membership.UNKNOWN;
+ }
+ }
+ // JavaParser misses some pattern variables, e.g. `name` in `x instanceof T name ? name : null`
+ boolean patternVariable = node.findAncestor(BodyDeclaration.class)
+ .map(body -> body.findAll(TypePatternExpr.class).stream().anyMatch(pattern -> pattern.getNameAsString().equals(name)))
+ .orElse(false);
+ return patternVariable ? Membership.UNKNOWN : membership(node, Kind.FIELD, name);
+ }
+
+ /** True if a variable of that name is declared in the innermost enclosing class, other than as a field. */
+ private boolean hasLocalNamed(Node node, String name) {
+ Node scope = enclosingScopes(node).stream().findFirst().map(EnclosingScope::node).orElse(cu);
+ for (VariableDeclarator variable : scope.findAll(VariableDeclarator.class)) {
+ if (variable.getNameAsString().equals(name) && !(variable.getParentNode().orElse(null) instanceof FieldDeclaration)) {
+ return true;
+ }
+ }
+ for (Parameter parameter : scope.findAll(Parameter.class)) {
+ if (parameter.getNameAsString().equals(name)) {
+ return true;
+ }
+ }
+ for (TypePatternExpr pattern : scope.findAll(TypePatternExpr.class)) {
+ if (pattern.getNameAsString().equals(name)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /** An unqualified type name: a class type, the leftmost part of an annotation name, or a qualifier like {@code Entry.comparingByKey()}. */
+ private void classifyTypeName(Node node, String name) {
+ List suppliers = imports.stream().filter(i -> i.supplies(Kind.TYPE, name)).toList();
+ if (suppliers.stream().anyMatch(i -> !i.declaration.isAsterisk())) {
+ // a single-static-import of a type shadows those of static-imports-on-demand (JLS 6.4.1)
+ suppliers = suppliers.stream().filter(i -> !i.declaration.isAsterisk()).toList();
+ }
+ if (suppliers.isEmpty() || typeImports.containsKey(name)) {
+ return; // not a member type of an import, or a single-type import of that name shadows them (JLS 6.4.1)
+ }
+ if (declaredTypeNames.contains(name)) {
+ keepSuppliersOf(name, Kind.TYPE);
+ return;
+ }
+ switch (membership(node, Kind.TYPE, name)) {
+ case MEMBER:
+ return;
+ case UNKNOWN:
+ keepSuppliersOf(name, Kind.TYPE);
+ return;
+ case NOT_MEMBER:
+ break;
+ }
+ Set canonicalNames = new HashSet<>();
+ for (StaticImport supplier : suppliers) {
+ // a member type inherited from a supertype can only be imported through the supertype (JLS 7.5.1)
+ canonicalNames.add(supplier.declaredMemberTypes.getOrDefault(name, ""));
+ }
+ if (canonicalNames.size() != 1 || canonicalNames.contains("")) {
+ keepSuppliersOf(name, Kind.TYPE);
+ return;
+ }
+ if (suppliers.stream().allMatch(i -> i.declaration.isAsterisk())) {
+ if (isSamePackageType(name)) {
+ return; // a type of the same package shadows a static-import-on-demand (JLS 6.4.1)
+ }
+ // and so may one that the type solver cannot see, such as generated code, so the import stays
+ keepSuppliersOf(name, Kind.TYPE);
+ return;
+ }
+ String canonicalName = canonicalNames.iterator().next();
+ for (StaticImport supplier : suppliers) {
+ memberTypeImports.computeIfAbsent(supplier, s -> new LinkedHashSet<>()).add(canonicalName);
+ }
+ }
+
+ private boolean isSamePackageType(String name) {
+ try {
+ return typeSolver.tryToSolveType(packageName.isEmpty() ? name : packageName + "." + name).isSolved();
+ } catch (RuntimeException e) {
+ return true;
+ }
+ }
+
+ private boolean suppliesField(String name) {
+ return imports.stream().anyMatch(i -> i.supplies(Kind.FIELD, name));
+ }
+
+ /**
+ * The one static import that supplies this name, for an occurrence that can only come from a static import.
+ * If imports of several types supply it, JavaParser cannot be trusted to pick the one the compiler picks,
+ * unless they all reach the very same declarations, as {@code Mockito.*} and {@code ArgumentMatchers.any} do:
+ * then the import of the declaring type is the one.
+ */
+ private Optional onlySupplier(String name, Kind kind) {
+ List suppliers = imports.stream().filter(i -> i.supplies(kind, name)).toList();
+ List single = suppliers.stream().filter(i -> !i.declaration.isAsterisk()).toList();
+ if (kind == Kind.FIELD && !single.isEmpty()) {
+ // a single-static-import of a field shadows those of static-imports-on-demand (JLS 6.4.1); for methods,
+ // it only shadows the override-equivalent ones, so the other overloads still compete
+ suppliers = single;
+ }
+ Set types = new HashSet<>();
+ suppliers.forEach(i -> types.add(i.type.getQualifiedName()));
+ if (types.size() == 1) {
+ // prefer an excluded import, which keeps its uses as they are, then a single static import
+ List candidates = suppliers;
+ return candidates.stream().filter(i -> i.keep).findFirst()
+ .or(() -> candidates.stream().filter(i -> !i.declaration.isAsterisk()).findFirst())
+ .or(() -> Optional.of(candidates.get(0)));
+ }
+ Set declaringTypes = new HashSet<>();
+ suppliers.forEach(i -> declaringTypes.addAll(i.declaringTypes.getOrDefault(name, Set.of("?"))));
+ if (declaringTypes.size() == 1) {
+ String declaringType = declaringTypes.iterator().next();
+ for (StaticImport supplier : suppliers) {
+ if (supplier.type.getQualifiedName().equals(declaringType)) {
+ return Optional.of(supplier);
+ }
+ }
+ }
+ keepSuppliersOf(name, kind);
+ return Optional.empty();
+ }
+
+ private void keepSuppliersOf(String name, Kind... kinds) {
+ for (StaticImport staticImport : imports) {
+ for (Kind kind : kinds) {
+ if (staticImport.supplies(kind, name)) {
+ staticImport.keep = true;
+ }
+ }
+ }
+ }
+
+ /** Static imports named in doc comments stay, so that {@code javadoc} can still resolve the references. */
+ private void keepImportsReferencedInComments() {
+ for (Comment comment : cu.getAllComments()) {
+ String content = comment.getContent();
+ List patterns = comment.isJavadocComment() || comment.isMarkdownComment() || content.startsWith("/")
+ ? List.of(DOC_REFERENCE, MARKDOWN_REFERENCE)
+ : List.of(DOC_REFERENCE);
+ for (Pattern pattern : patterns) {
+ Matcher matcher = pattern.matcher(content);
+ while (matcher.find()) {
+ keepSuppliersOf(matcher.group(1), Kind.values());
+ }
+ }
+ }
+ }
+
+ // ---------------------------------------------------------------- the enclosing classes
+
+ /** Whether an enclosing class of {@code node} declares or inherits a member of that kind and name. */
+ private Membership membership(Node node, Kind kind, String name) {
+ boolean complete = true;
+ for (EnclosingScope scope : enclosingScopes(node)) {
+ Members members = members(scope.node()).get(kind);
+ if (!scope.inBody()) {
+ // a class's members are not in scope in its header: annotations, type parameters, extends, implements (JLS 6.3)
+ if (scope.node() instanceof RecordDeclaration && (members.possible.contains(name) || !members.complete)) {
+ return Membership.UNKNOWN; // a record header declares its components, so be careful there
+ }
+ continue;
+ }
+ if (members.certain.contains(name)) {
+ return Membership.MEMBER;
+ }
+ if (members.possible.contains(name)) {
+ return Membership.UNKNOWN;
+ }
+ complete &= members.complete;
+ }
+ return complete ? Membership.NOT_MEMBER : Membership.UNKNOWN;
+ }
+
+ /** The classes around a node, innermost first: type declarations, anonymous classes and enum constant bodies. */
+ private List enclosingScopes(Node node) {
+ List scopes = new ArrayList<>();
+ Node child = node;
+ Node parent = node.getParentNode().orElse(null);
+ while (parent != null) {
+ if (parent instanceof TypeDeclaration> declaration) {
+ boolean inBody = containsSame(declaration.getMembers(), child)
+ || (declaration instanceof EnumDeclaration enumDeclaration && containsSame(enumDeclaration.getEntries(), child));
+ scopes.add(new EnclosingScope(parent, inBody));
+ } else if (parent instanceof ObjectCreationExpr creation && creation.getAnonymousClassBody().isPresent()) {
+ if (containsSame(creation.getAnonymousClassBody().get(), child)) {
+ scopes.add(new EnclosingScope(parent, true));
+ }
+ } else if (parent instanceof EnumConstantDeclaration constant && containsSame(constant.getClassBody(), child)) {
+ scopes.add(new EnclosingScope(parent, true));
+ }
+ child = parent;
+ parent = parent.getParentNode().orElse(null);
+ }
+ return scopes;
+ }
+
+ private Map members(Node scope) {
+ return membersCache.computeIfAbsent(scope, this::collectScopeMembers);
+ }
+
+ private Map collectScopeMembers(Node scope) {
+ Map members = new EnumMap<>(Kind.class);
+ for (Kind kind : Kind.values()) {
+ members.put(kind, new Members());
+ }
+ NodeList> body = new NodeList<>();
+ try {
+ List supertypes = new ArrayList<>();
+ if (scope instanceof TypeDeclaration> declaration) {
+ body = declaration.getMembers();
+ addImplicitMembers(declaration, members);
+ if (usesLombok(declaration)) {
+ throw new IllegalStateException("Lombok generates members that JavaParser cannot see");
+ }
+ supertypes.addAll(directSupertypes(declaration));
+ } else if (scope instanceof ObjectCreationExpr creation) {
+ body = creation.getAnonymousClassBody().orElseGet(NodeList::new);
+ supertypes.add(creation.getType().resolve().asReferenceType().getTypeDeclaration().orElseThrow());
+ OBJECT_METHODS.forEach(method -> members.get(Kind.METHOD).add(method, true));
+ } else {
+ // the members of the enum itself are found through the enclosing EnumDeclaration
+ body = ((EnumConstantDeclaration) scope).getClassBody();
+ }
+ for (ResolvedReferenceTypeDeclaration supertype : supertypes) {
+ requireCompleteAncestry(supertype, new HashSet<>());
+ addInheritedMembers(supertype, members);
+ }
+ } catch (RuntimeException e) {
+ members.values().forEach(m -> m.complete = false);
+ }
+ for (BodyDeclaration> declaration : body) {
+ if (declaration instanceof MethodDeclaration method) {
+ members.get(Kind.METHOD).add(method.getNameAsString(), true);
+ } else if (declaration instanceof FieldDeclaration field) {
+ field.getVariables().forEach(variable -> members.get(Kind.FIELD).add(variable.getNameAsString(), true));
+ } else if (declaration instanceof TypeDeclaration> type) {
+ members.get(Kind.TYPE).add(type.getNameAsString(), true);
+ } else if (declaration instanceof AnnotationMemberDeclaration member) {
+ members.get(Kind.METHOD).add(member.getNameAsString(), true);
+ }
+ }
+ return members;
+ }
+
+ /** Members that a type has without declaring them in its body: enum constants, record components, {@code values()}... */
+ private void addImplicitMembers(TypeDeclaration> declaration, Map members) {
+ if (declaration instanceof EnumDeclaration enumDeclaration) {
+ enumDeclaration.getEntries().forEach(entry -> members.get(Kind.FIELD).add(entry.getNameAsString(), true));
+ members.get(Kind.METHOD).add("values", true);
+ members.get(Kind.METHOD).add("valueOf", true);
+ } else if (declaration instanceof RecordDeclaration record) {
+ for (Parameter component : record.getParameters()) {
+ members.get(Kind.FIELD).add(component.getNameAsString(), true);
+ members.get(Kind.METHOD).add(component.getNameAsString(), true);
+ }
+ }
+ boolean isInterface = declaration instanceof AnnotationDeclaration
+ || (declaration instanceof ClassOrInterfaceDeclaration classOrInterface && classOrInterface.isInterface());
+ for (String method : OBJECT_METHODS) {
+ // an interface only has the public methods of Object (JLS 9.2), not clone or finalize
+ if (!isInterface || !(method.equals("clone") || method.equals("finalize"))) {
+ members.get(Kind.METHOD).add(method, true);
+ }
+ }
+ }
+
+ /** The resolved direct supertypes of a type declaration, including the implicit ones. */
+ private List directSupertypes(TypeDeclaration> declaration) {
+ List types = new ArrayList<>();
+ List implicit = new ArrayList<>();
+ if (declaration instanceof ClassOrInterfaceDeclaration classOrInterface) {
+ types.addAll(classOrInterface.getExtendedTypes());
+ types.addAll(classOrInterface.getImplementedTypes());
+ } else if (declaration instanceof EnumDeclaration enumDeclaration) {
+ types.addAll(enumDeclaration.getImplementedTypes());
+ implicit.add("java.lang.Enum");
+ } else if (declaration instanceof RecordDeclaration record) {
+ types.addAll(record.getImplementedTypes());
+ implicit.add("java.lang.Record");
+ } else if (declaration instanceof AnnotationDeclaration) {
+ implicit.add("java.lang.annotation.Annotation");
+ }
+ List supertypes = new ArrayList<>();
+ for (ClassOrInterfaceType type : types) {
+ supertypes.add(type.resolve().asReferenceType().getTypeDeclaration().orElseThrow());
+ }
+ for (String name : implicit) {
+ supertypes.add(typeSolver.solveType(name));
+ }
+ return supertypes;
+ }
+
+ /**
+ * Adds the members that a class inherits from a supertype (JLS 8.2, 8.4.8). Private members and static
+ * interface methods are not inherited; package-private ones only within their package, which depends on
+ * every class in between, so they are only possible members.
+ */
+ private void addInheritedMembers(ResolvedReferenceTypeDeclaration supertype, Map members) {
+ for (var method : supertype.getAllMethods()) {
+ ResolvedMethodDeclaration declaration = method.getDeclaration();
+ if (declaration.isStatic() && declaration.declaringType().isInterface()) {
+ continue;
+ }
+ addInherited(members.get(Kind.METHOD), declaration.getName(), declaration.accessSpecifier(), declaration.declaringType());
+ }
+ // a field or member type that two ancestors declare may be hidden on the way, e.g. by a private field of a
+ // class in between (JLS 8.3, 8.5), so it is only a possible member
+ List fields = supertype.getAllFields();
+ Map fieldCount = new HashMap<>();
+ fields.forEach(field -> fieldCount.merge(field.getName(), 1, Integer::sum));
+ for (ResolvedFieldDeclaration field : fields) {
+ AccessSpecifier access = isInterfaceOrAnnotation(field.declaringType()) ? AccessSpecifier.PUBLIC : field.accessSpecifier();
+ if (fieldCount.get(field.getName()) > 1) {
+ members.get(Kind.FIELD).add(field.getName(), false);
+ } else {
+ addInherited(members.get(Kind.FIELD), field.getName(), access, field.declaringType());
+ }
+ }
+ Map typeCount = new HashMap<>();
+ List owners = withAncestors(supertype);
+ owners.forEach(owner -> owner.internalTypes().forEach(memberType -> typeCount.merge(memberType.getName(), 1, Integer::sum)));
+ for (ResolvedReferenceTypeDeclaration owner : owners) {
+ for (ResolvedReferenceTypeDeclaration memberType : owner.internalTypes()) {
+ AccessSpecifier access = isInterfaceOrAnnotation(owner) ? AccessSpecifier.PUBLIC : accessOf(memberType);
+ if (typeCount.get(memberType.getName()) > 1) {
+ members.get(Kind.TYPE).add(memberType.getName(), false);
+ } else {
+ addInherited(members.get(Kind.TYPE), memberType.getName(), access, owner);
+ }
+ }
+ }
+ }
+
+ private void addInherited(Members members, String name, AccessSpecifier access, ResolvedTypeDeclaration declaringType) {
+ String declaringPackage = packageOf(declaringType);
+ // the JDK that runs the build may not be the one the project compiles against, and their members differ
+ boolean fromJdk = jdkPackages().contains(declaringPackage) && !"java.lang.Object".equals(declaringType.getQualifiedName());
+ if (access == AccessSpecifier.PUBLIC || access == AccessSpecifier.PROTECTED) {
+ members.add(name, !fromJdk);
+ } else if (access == AccessSpecifier.NONE && declaringPackage.equals(packageName)) {
+ members.add(name, false);
+ } // private members, and package-private ones of another package, are not inherited
+ }
+
+ // ---------------------------------------------------------------- the edits
+
+ private String edit() {
+ Map plans = planQualifiers();
+ List removed = imports.stream().filter(i -> !i.keep).toList();
+ if (removed.isEmpty()) {
+ return text;
+ }
+ List edits = new ArrayList<>();
+ Set newImports = new TreeSet<>();
+ for (StaticImport staticImport : removed) {
+ Plan plan = plans.get(staticImport);
+ if (plan != null) {
+ edits.addAll(plan.insertions);
+ newImports.addAll(plan.imports);
+ }
+ for (String canonicalName : memberTypeImports.getOrDefault(staticImport, Set.of())) {
+ if (!canonicalName.equals(typeImports.get(simpleName(canonicalName)))) {
+ newImports.add(canonicalName);
+ }
+ }
+ }
+ addImportEdits(removed, newImports, edits);
+ if (touchesFence(edits)) {
+ return text; // toggleOffOn() would undo part of the edits, e.g. a new import inside a spotless:off region
+ }
+ return applyEdits(edits);
+ }
+
+ /** Works out how to qualify every use; a static import with a use that cannot be qualified is kept. */
+ private Map planQualifiers() {
+ while (true) {
+ plannedSimpleNames.clear();
+ Map plans = new IdentityHashMap<>();
+ Set qualifiedOffsets = new HashSet<>();
+ StaticImport failed = null;
+ for (Use use : uses) {
+ StaticImport source = use.source();
+ if (source.keep) {
+ continue;
+ }
+ int offset = use.node().getBegin().map(this::offset).orElse(-1);
+ if (!qualifiedOffsets.add(offset)) {
+ continue; // the same occurrence, seen twice
+ }
+ Optional qualifier = offset >= 0 && text.startsWith(use.name(), offset) ? qualifier(use) : Optional.empty();
+ if (qualifier.isEmpty()) {
+ failed = source;
+ break;
+ }
+ Plan plan = plans.computeIfAbsent(source, s -> new Plan());
+ plan.insertions.add(new Edit(offset, offset, qualifier.get().text() + "."));
+ if (qualifier.get().importName() != null) {
+ plan.imports.add(qualifier.get().importName());
+ }
+ }
+ if (failed == null) {
+ return plans;
+ }
+ failed.keep = true;
+ }
+ }
+
+ /** Qualifies a use with the simple name of the imported type where that is safe, otherwise with its fully qualified name. */
+ private Optional qualifier(Use use) {
+ ResolvedReferenceTypeDeclaration type = use.source().type;
+ if (!isReachableThroughContainers(type)) {
+ return Optional.empty();
+ }
+ Node node = use.node();
+ Context context = context(node);
+ // a nested type of this file may already be visible by its own name, e.g. inside its outer class
+ if (type.containerType().isPresent() && declaredTypeQualifiedNames.contains(type.getQualifiedName())
+ && !typeParameterNames.contains(type.getName())
+ && noVariableNamed(node, context, type.getName())
+ && isOwnMemberTypeInScope(node, type)
+ && visibleType(context, type.getName(), type.getQualifiedName()) == Visible.EXPECTED) {
+ return Optional.of(new Qualifier(type.getName(), null));
+ }
+ String className = type.getClassName();
+ String simple = firstSegment(className);
+ String topLevel = type.getPackageName().isEmpty() ? simple : type.getPackageName() + "." + simple;
+ // an import of a java.lang type would not last: removeUnusedImports() deletes those as redundant
+ boolean importable = !"java.lang".equals(type.getPackageName());
+ if (noVariableNamed(node, context, simple) && noMemberTypeNamed(node, simple, topLevel)) {
+ Visible visible = visibleType(context, simple, topLevel);
+ // a type parameter of an enclosing class shadows the type, and JavaParser does not see that
+ if (visible == Visible.EXPECTED && !typeParameterNames.contains(simple) && isUnambiguous(simple, topLevel)) {
+ return Optional.of(new Qualifier(className, null));
+ }
+ if (importable && (visible == Visible.NOTHING || visible == Visible.SHADOWABLE || visible == Visible.EXPECTED)) {
+ String planned = plannedSimpleNames.get(simple);
+ if (topLevel.equals(planned)) {
+ return Optional.of(new Qualifier(className, topLevel));
+ }
+ if (planned == null && canImport(simple)) {
+ plannedSimpleNames.put(simple, topLevel);
+ return Optional.of(new Qualifier(className, topLevel));
+ }
+ }
+ }
+ String fullyQualified = type.getQualifiedName();
+ String first = firstSegment(fullyQualified);
+ if (type.getPackageName().isEmpty() || !noVariableNamed(node, context, first) || declaredTypeNames.contains(first)
+ || membership(node, Kind.TYPE, first) != Membership.NOT_MEMBER || visibleType(context, first, null) != Visible.NOTHING) {
+ return Optional.empty(); // a variable or type of that name would obscure the package (JLS 6.4.2)
+ }
+ return Optional.of(new Qualifier(fullyQualified, null));
+ }
+
+ /** For a nested type, {@code Outer.Inner} would mean a field of {@code Outer} named {@code Inner} if there is one (JLS 6.5.2). */
+ private boolean isReachableThroughContainers(ResolvedReferenceTypeDeclaration type) {
+ try {
+ ResolvedReferenceTypeDeclaration inner = type;
+ Optional container = inner.containerType();
+ while (container.isPresent()) {
+ String innerName = inner.getName();
+ if (container.get().getAllFields().stream().anyMatch(field -> field.getName().equals(innerName))) {
+ return false;
+ }
+ inner = container.get();
+ container = inner.containerType();
+ }
+ return true;
+ } catch (RuntimeException e) {
+ return false;
+ }
+ }
+
+ /** True if no variable of that name is in scope, which would obscure a type or package of the same name (JLS 6.4.2). */
+ private boolean noVariableNamed(Node node, Context context, String name) {
+ return !variableNames.contains(name)
+ && !unresolvedNames.contains(name)
+ && !suppliesField(name)
+ && membership(node, Kind.FIELD, name) == Membership.NOT_MEMBER
+ && !isVisibleAsVariable(context, name);
+ }
+
+ /** True if no member type of that name is in scope at the node. */
+ private boolean noMemberTypeNamed(Node node, String simple, String topLevel) {
+ return membership(node, Kind.TYPE, simple) == Membership.NOT_MEMBER;
+ }
+
+ /**
+ * True if the innermost enclosing class with a member type of that name declares the nested type itself.
+ * JavaParser does not see member types inherited from superclasses, such as {@code Thread.State}.
+ */
+ private boolean isOwnMemberTypeInScope(Node node, ResolvedReferenceTypeDeclaration type) {
+ String name = type.getName();
+ for (EnclosingScope scope : enclosingScopes(node)) {
+ Members members = members(scope.node()).get(Kind.TYPE);
+ if (!scope.inBody() && !(scope.node() instanceof RecordDeclaration)) {
+ continue; // a class's members are not in scope in its header
+ }
+ if (!members.complete) {
+ return false;
+ }
+ if (members.possible.contains(name)) {
+ return scope.node() instanceof TypeDeclaration> declaration
+ && declaration.getFullyQualifiedName().map(outer -> (outer + "." + name).equals(type.getQualifiedName())).orElse(false);
+ }
+ }
+ return false;
+ }
+
+ /**
+ * A type visible through {@code java.lang} or an on-demand import can only be used by its simple name if no
+ * other on-demand import supplies a type of that name, which would make it ambiguous, and no type of the same
+ * package has that name, which would shadow it (JLS 6.4.1, 7.5.2). Types the type solver cannot see count too.
+ */
+ private boolean isUnambiguous(String simple, String topLevel) {
+ if (typeImports.containsKey(simple) && !topLevel.equals(typeImports.get(simple))) {
+ return false; // an import names another type, even if the type solver cannot resolve it
+ }
+ if (topLevel.equals(typeImports.get(simple)) || declaredTypeQualifiedNames.contains(topLevel)
+ || packageOfQualified(topLevel).equals(packageName)) {
+ return true;
+ }
+ if (!isKnownPackage(packageName)) {
+ return false;
+ }
+ Set providers = new HashSet<>();
+ addIfType(providers, "java.lang." + simple);
+ for (ImportDeclaration declaration : cu.getImports()) {
+ if (declaration.isModule()) {
+ return false;
+ }
+ if (declaration.isAsterisk() && !declaration.isStatic()) {
+ String name = declaration.getNameAsString();
+ if (!isKnownPackage(name) && !typeSolver.tryToSolveType(name).isSolved()) {
+ return false;
+ }
+ addIfType(providers, name + "." + simple);
+ }
+ }
+ for (StaticImport staticImport : imports) {
+ if (staticImport.declaration.isAsterisk() && staticImport.keep && staticImport.supplies(Kind.TYPE, simple)) {
+ providers.add(staticImport.declaredMemberTypes.getOrDefault(simple, "?"));
+ }
+ }
+ return providers.size() == 1 && providers.contains(topLevel);
+ }
+
+ private void addIfType(Set providers, String name) {
+ try {
+ SymbolReference reference = typeSolver.tryToSolveType(name);
+ if (reference.isSolved()) {
+ providers.add(reference.getCorrespondingDeclaration().getQualifiedName());
+ }
+ } catch (RuntimeException e) {
+ providers.add("?" + name);
+ }
+ }
+
+ /** Whether {@code import x.simple;} can be added without changing what any other name in the file refers to. */
+ private boolean canImport(String simple) {
+ if (typeImports.containsKey(simple) || declaredTypeNames.contains(simple) || unresolvedNames.contains(simple)) {
+ return false;
+ }
+ for (StaticImport staticImport : imports) {
+ if (!staticImport.declaration.isAsterisk() && staticImport.declaration.getName().getIdentifier().equals(simple)) {
+ return false; // a single-static-import of a type with that name would clash (JLS 7.5.3)
+ }
+ }
+ for (Set canonicalNames : memberTypeImports.values()) {
+ for (String canonicalName : canonicalNames) {
+ if (simpleName(canonicalName).equals(simple)) {
+ return false;
+ }
+ }
+ }
+ return !usedUnqualified(simple);
+ }
+
+ /** Whether the simple name is used anywhere in the file as a type or an expression name, where a new import could capture it. */
+ private boolean usedUnqualified(String simple) {
+ return usedUnqualifiedCache.computeIfAbsent(simple, s -> {
+ for (SimpleName name : cu.findAll(SimpleName.class)) {
+ if (name.getIdentifier().equals(s)) {
+ Node parent = name.getParentNode().orElse(null);
+ if (parent instanceof NameExpr || (parent instanceof ClassOrInterfaceType type && type.getScope().isEmpty())) {
+ return true;
+ }
+ }
+ }
+ for (Name name : cu.findAll(Name.class)) {
+ if (name.getQualifier().isEmpty() && name.getIdentifier().equals(s)
+ && name.findAncestor(ImportDeclaration.class).isEmpty()
+ && name.findAncestor(PackageDeclaration.class).isEmpty()) {
+ return true;
+ }
+ }
+ return false;
+ });
+ }
+
+ private Context context(Node node) {
+ return JavaParserFactory.getContext(node, typeSolver);
+ }
+
+ private Visible visibleType(Context context, String simple, String expected) {
+ try {
+ SymbolReference reference = context.solveType(simple);
+ if (!reference.isSolved()) {
+ return Visible.NOTHING;
+ }
+ ResolvedTypeDeclaration declaration = reference.getCorrespondingDeclaration();
+ if (declaration.getQualifiedName().equals(expected)) {
+ return Visible.EXPECTED;
+ }
+ boolean topLevel = declaration instanceof ResolvedReferenceTypeDeclaration type && type.containerType().isEmpty();
+ return topLevel ? Visible.SHADOWABLE : Visible.OTHER;
+ } catch (RuntimeException e) {
+ return Visible.UNKNOWN;
+ }
+ }
+
+ private boolean isVisibleAsVariable(Context context, String name) {
+ try {
+ return context.solveSymbol(name).isSolved();
+ } catch (RuntimeException e) {
+ return true;
+ }
+ }
+
+ private void addImportEdits(List removed, Set newImports, List edits) {
+ Set removedDeclarations = Collections.newSetFromMap(new IdentityHashMap<>());
+ removed.forEach(r -> removedDeclarations.add(r.declaration));
+ ImportDeclaration lastRemaining = null;
+ for (ImportDeclaration declaration : cu.getImports()) {
+ if (!removedDeclarations.contains(declaration)) {
+ lastRemaining = declaration;
+ }
+ }
+ StringBuilder importLines = new StringBuilder();
+ for (String newImport : newImports) {
+ importLines.append("import ").append(newImport).append(";\n");
+ }
+ List blocks = removalBlocks(removed);
+ if (!newImports.isEmpty()) {
+ if (lastRemaining == null) {
+ // the new imports take the place of the first removed block
+ int[] first = blocks.remove(0);
+ edits.add(new Edit(first[0], first[1], importLines.toString()));
+ } else {
+ int end = offset(lastRemaining.getEnd().orElseThrow()) + 1;
+ int newline = text.indexOf('\n', end);
+ String rest = text.substring(end, newline < 0 ? text.length() : newline).strip();
+ if (rest.isEmpty() || rest.startsWith("//")) {
+ int afterLast = lineEnd(end);
+ edits.add(new Edit(afterLast, afterLast, importLines.toString()));
+ } else {
+ // the line goes on, e.g. with the class or a comment: the new imports go on lines of their own
+ edits.add(new Edit(end, end, "\n" + importLines.toString().stripTrailing()));
+ }
+ }
+ }
+ for (int[] block : blocks) {
+ edits.add(new Edit(block[0], withFollowingBlankLine(block), ""));
+ }
+ }
+
+ /** The end of a deleted block, extended over the next line if the block sits between two blank lines, so that only one remains. */
+ private int withFollowingBlankLine(int[] block) {
+ boolean wholeLines = block[0] > 0 && text.charAt(block[0] - 1) == '\n' && text.charAt(block[1] - 1) == '\n';
+ boolean blankBefore = block[0] >= 2 && text.charAt(block[0] - 2) == '\n';
+ boolean blankAfter = block[1] < text.length() && text.charAt(block[1]) == '\n';
+ return wholeLines && blankBefore && blankAfter ? block[1] + 1 : block[1];
+ }
+
+ /** The text ranges of the removed imports: whole lines when an import is alone on its line, with adjacent lines merged. */
+ private List removalBlocks(List removed) {
+ List ranges = new ArrayList<>();
+ for (StaticImport staticImport : removed) {
+ int begin = offset(staticImport.declaration.getBegin().orElseThrow());
+ int end = offset(staticImport.declaration.getEnd().orElseThrow()) + 1;
+ int lineStart = text.lastIndexOf('\n', begin - 1) + 1;
+ int newline = text.indexOf('\n', end);
+ int contentEnd = newline < 0 ? text.length() : newline;
+ String rest = text.substring(end, contentEnd).strip();
+ // an import alone on its line goes with its line, including a trailing comment about it, such as `// NOPMD`
+ if (text.substring(lineStart, begin).isBlank() && (rest.isEmpty() || rest.startsWith("//"))) {
+ ranges.add(new int[]{lineStart, newline < 0 ? text.length() : newline + 1});
+ } else {
+ // shares its line with other code: remove it with the blanks that follow it
+ int after = end;
+ while (after < contentEnd && (text.charAt(after) == ' ' || text.charAt(after) == '\t')) {
+ after++;
+ }
+ ranges.add(new int[]{begin, after});
+ }
+ }
+ ranges.sort(Comparator.comparingInt(range -> range[0]));
+ List blocks = new ArrayList<>();
+ for (int[] range : ranges) {
+ int[] last = blocks.isEmpty() ? null : blocks.get(blocks.size() - 1);
+ if (last != null && last[1] == range[0]) {
+ last[1] = range[1];
+ } else {
+ blocks.add(new int[]{range[0], range[1]});
+ }
+ }
+ return blocks;
+ }
+
+ private boolean touchesFence(List edits) {
+ for (Edit edit : edits) {
+ for (int[] fence : fences) {
+ boolean touches = edit.start() == edit.end()
+ ? fence[0] < edit.start() && edit.start() < fence[1]
+ : edit.start() < fence[1] && fence[0] < edit.end();
+ if (touches) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ /** The offset just after the end of the line that contains {@code offset}. */
+ private int lineEnd(int offset) {
+ int newline = text.indexOf('\n', offset);
+ return newline < 0 ? text.length() : newline + 1;
+ }
+
+ private String applyEdits(List edits) {
+ edits.sort(Comparator.comparingInt(Edit::start).thenComparingInt(Edit::end));
+ List merged = new ArrayList<>();
+ for (Edit edit : edits) {
+ Edit last = merged.isEmpty() ? null : merged.get(merged.size() - 1);
+ if (last != null && edit.start() < last.end()) {
+ throw new IllegalStateException("overlapping edits");
+ }
+ if (last != null && edit.start() == last.start() && last.start() == last.end()) {
+ // an insertion, then a replacement that starts at the same place
+ merged.set(merged.size() - 1, new Edit(edit.start(), edit.end(), last.replacement() + edit.replacement()));
+ } else {
+ merged.add(edit);
+ }
+ }
+ StringBuilder result = new StringBuilder(text);
+ for (int i = merged.size() - 1; i >= 0; i--) {
+ Edit edit = merged.get(i);
+ result.replace(edit.start(), edit.end(), edit.replacement());
+ }
+ return result.toString();
+ }
+
+ private int offset(Position position) {
+ if (position.line < 1 || position.line >= lineOffsets.length) {
+ return -1;
+ }
+ return lineOffsets[position.line] + position.column - 1;
+ }
+ }
+
+ /** True if the type declaration, or one of its members, carries an annotation that may come from Lombok. */
+ private static boolean usesLombok(TypeDeclaration> declaration) {
+ CompilationUnit cu = declaration.findCompilationUnit().orElse(null);
+ Set lombokNames = new HashSet<>();
+ boolean lombokOnDemand = false;
+ if (cu != null) {
+ for (ImportDeclaration declarationImport : cu.getImports()) {
+ String name = declarationImport.getNameAsString();
+ if (name.equals("lombok") || name.startsWith("lombok.")) {
+ if (declarationImport.isAsterisk()) {
+ lombokOnDemand = true;
+ } else {
+ lombokNames.add(declarationImport.getName().getIdentifier());
+ }
+ }
+ }
+ }
+ for (AnnotationExpr annotation : declaration.findAll(AnnotationExpr.class)) {
+ String name = annotation.getNameAsString();
+ if (name.startsWith("lombok.") || lombokNames.contains(name) || (lombokOnDemand && !name.contains("."))) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /** {@code NodeList.contains} compares nodes structurally, which is slow and could match an identical member elsewhere. */
+ private static boolean containsSame(List extends Node> nodes, Node node) {
+ for (Node element : nodes) {
+ if (element == node) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static List withAncestors(ResolvedReferenceTypeDeclaration type) {
+ List types = new ArrayList<>();
+ types.add(type);
+ for (ResolvedReferenceType ancestor : type.getAllAncestors()) {
+ types.add(ancestor.getTypeDeclaration().orElseThrow());
+ }
+ return types;
+ }
+
+ private static boolean isInterfaceOrAnnotation(ResolvedTypeDeclaration type) {
+ return type.isInterface() || type.isAnnotation();
+ }
+
+ private static AccessSpecifier accessOf(ResolvedReferenceTypeDeclaration type) {
+ return type instanceof HasAccessSpecifier withAccess ? withAccess.accessSpecifier() : AccessSpecifier.NONE;
+ }
+
+ private static String packageOf(ResolvedTypeDeclaration type) {
+ return type instanceof ResolvedReferenceTypeDeclaration reference ? reference.getPackageName() : "";
+ }
+
+ private static String packageOfQualified(String qualifiedName) {
+ int dot = qualifiedName.lastIndexOf('.');
+ return dot < 0 ? "" : qualifiedName.substring(0, dot);
+ }
+
+ private static boolean isQualifier(NameExpr nameExpr) {
+ Node parent = nameExpr.getParentNode().orElse(null);
+ if (parent instanceof MethodCallExpr call) {
+ return call.getScope().filter(scope -> scope == nameExpr).isPresent();
+ }
+ if (parent instanceof FieldAccessExpr access) {
+ return access.getScope() == nameExpr;
+ }
+ return parent instanceof MethodReferenceExpr reference && reference.getScope() == nameExpr;
+ }
+
+ /** True for the {@code X} of {@code X::method}, which JavaParser parses as a type even when it is a variable. */
+ private static boolean isMethodReferenceScope(ClassOrInterfaceType type) {
+ return type.getParentNode().orElse(null) instanceof TypeExpr typeExpr
+ && typeExpr.getParentNode().orElse(null) instanceof MethodReferenceExpr reference
+ && reference.getScope() == typeExpr;
+ }
+
+ private static String firstSegment(String dottedName) {
+ int dot = dottedName.indexOf('.');
+ return dot < 0 ? dottedName : dottedName.substring(0, dot);
+ }
+
+ private static String simpleName(String canonicalName) {
+ return canonicalName.substring(canonicalName.lastIndexOf('.') + 1);
+ }
+
+ /** {@code lineOffsets[line]} is the offset of the first character of that 1-based line. */
+ private static int[] lineOffsets(String text) {
+ List offsets = new ArrayList<>();
+ offsets.add(0);
+ offsets.add(0);
+ for (int i = 0; i < text.length(); i++) {
+ if (text.charAt(i) == '\n') {
+ offsets.add(i + 1);
+ }
+ }
+ return offsets.stream().mapToInt(Integer::intValue).toArray();
+ }
+}
diff --git a/lib/src/javaParser/java/com/diffplug/spotless/glue/javaparser/SymbolResolution.java b/lib/src/javaParser/java/com/diffplug/spotless/glue/javaparser/SymbolResolution.java
new file mode 100644
index 0000000000..ae186c9485
--- /dev/null
+++ b/lib/src/javaParser/java/com/diffplug/spotless/glue/javaparser/SymbolResolution.java
@@ -0,0 +1,202 @@
+/*
+ * Copyright 2026 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.spotless.glue.javaparser;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javassist.ClassPool;
+
+import com.github.javaparser.JavaParser;
+import com.github.javaparser.ParserConfiguration;
+import com.github.javaparser.ParserConfiguration.LanguageLevel;
+import com.github.javaparser.resolution.TypeSolver;
+import com.github.javaparser.resolution.declarations.ResolvedReferenceTypeDeclaration;
+import com.github.javaparser.resolution.model.SymbolReference;
+import com.github.javaparser.symbolsolver.javaparsermodel.JavaParserFacade;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.CombinedTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JarTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.JavaParserTypeSolver;
+import com.github.javaparser.symbolsolver.resolution.typesolvers.ReflectionTypeSolver;
+
+/** The JavaParser setup shared by the steps that resolve names against the project's classpath. */
+final class SymbolResolution {
+ static {
+ // If ClassPool is allowed to cache class files, it does not free the file-lock
+ ClassPool.cacheOpenedJarFile = false;
+ }
+
+ private SymbolResolution() {}
+
+ /** A parser that accepts every language level; JavaParser defaults to Java 11 and rejects newer syntax such as records. */
+ static JavaParser parser() {
+ return new JavaParser(new ParserConfiguration().setLanguageLevel(LanguageLevel.BLEEDING_EDGE));
+ }
+
+ /** A type solver for the JDK and the given jars and source directories. Entries that do not exist are ignored. */
+ static CombinedTypeSolver typeSolver(Collection classpath) throws IOException {
+ CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+ combinedTypeSolver.add(new ReflectionTypeSolver(ReflectionTypeSolver.JCL_ONLY));
+ for (File element : classpath) {
+ if (element.isFile() && element.getName().endsWith(".jar")) {
+ combinedTypeSolver.add(new JarTypeSolver(element));
+ } else if (element.isDirectory()) {
+ combinedTypeSolver.add(new JavaParserTypeSolver(element));
+ }
+ }
+ return combinedTypeSolver;
+ }
+
+ /**
+ * Like {@link #typeSolver(Collection)}, but parses the files of the source directories with the given configuration,
+ * which can have a symbol resolver, and only when a file there mentions the name being looked up.
+ */
+ static CombinedTypeSolver typeSolver(Collection classpath, ParserConfiguration sourceConfiguration) throws IOException {
+ CombinedTypeSolver combinedTypeSolver = new CombinedTypeSolver();
+ combinedTypeSolver.add(new ReflectionTypeSolver(ReflectionTypeSolver.JCL_ONLY));
+ for (File element : classpath) {
+ if (element.isFile() && element.getName().endsWith(".jar")) {
+ combinedTypeSolver.add(new JarTypeSolver(element));
+ } else if (element.isDirectory()) {
+ combinedTypeSolver.add(new MentionFilter(element, sourceConfiguration));
+ }
+ }
+ return combinedTypeSolver;
+ }
+
+ /**
+ * JavaParser caches a facade for every type solver in a static map, which keeps the type solver, and with it
+ * every jar it has read, alive for as long as JavaParser's classes are loaded. Clears it.
+ */
+ static void release() {
+ synchronized (JavaParserFacade.class) {
+ // JavaParserFacade.get is static synchronized, clearInstances is not
+ JavaParserFacade.clearInstances();
+ }
+ }
+
+ /**
+ * A source directory that only asks JavaParser about a type when one of the files that could declare it mentions
+ * its name. When a package has no file named after the type, JavaParser parses every file of the package to look for
+ * a non-public top-level type of that name, and most of the names this step looks up are in no package at all.
+ */
+ private static final class MentionFilter implements TypeSolver {
+ private static final Pattern IDENTIFIER = Pattern.compile("[\\p{javaJavaIdentifierStart}][\\p{javaJavaIdentifierPart}]*");
+ private static final String ANY_NAME = "\\u";
+
+ private final File root;
+ private final ParserConfiguration configuration;
+ private final Map> namesByDirectory = new HashMap<>();
+ private TypeSolver parent;
+ private JavaParserTypeSolver delegate;
+ private RuntimeException failure;
+
+ MentionFilter(File root, ParserConfiguration configuration) {
+ this.root = root;
+ this.configuration = configuration;
+ }
+
+ @Override
+ public TypeSolver getParent() {
+ return parent;
+ }
+
+ @Override
+ public void setParent(TypeSolver parent) {
+ this.parent = parent;
+ }
+
+ @Override
+ public SymbolReference tryToSolveType(String name) {
+ return mayDeclare(name) ? delegate().tryToSolveType(name) : SymbolReference.unsolved();
+ }
+
+ @Override
+ public SymbolReference tryToSolveTypeInModule(String qualifiedModuleName, String simpleTypeName) {
+ return mayDeclare(simpleTypeName) ? delegate().tryToSolveTypeInModule(qualifiedModuleName, simpleTypeName) : SymbolReference.unsolved();
+ }
+
+ /** Created on first use, since it walks the whole directory, and remembered when that fails, e.g. for an unreadable folder. */
+ private JavaParserTypeSolver delegate() {
+ if (failure != null) {
+ throw failure;
+ }
+ if (delegate == null) {
+ try {
+ JavaParserTypeSolver created = new JavaParserTypeSolver(root, configuration);
+ created.setParent(parent);
+ delegate = created;
+ } catch (RuntimeException e) {
+ failure = e;
+ throw e;
+ }
+ }
+ return delegate;
+ }
+
+ /** A type can only be declared in a file that mentions its name, in a directory of one of the packages the name could have. */
+ private boolean mayDeclare(String name) {
+ String[] segments = name.split("\\.");
+ String simpleName = segments[segments.length - 1];
+ for (int packageLength = 0; packageLength < segments.length; packageLength++) {
+ File directory = new File(root, String.join("/", Arrays.copyOfRange(segments, 0, packageLength)));
+ Set names = namesIn(directory);
+ if (names.contains(simpleName) || names.contains(ANY_NAME)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private Set namesIn(File directory) {
+ return namesByDirectory.computeIfAbsent(directory, dir -> {
+ Set names = new HashSet<>();
+ File[] sources = dir.listFiles((parentDir, fileName) -> fileName.endsWith(".java"));
+ if (sources == null) {
+ return names;
+ }
+ for (File source : sources) {
+ String content;
+ try {
+ // decoded like JavaParser decodes it, without failing on bytes that are not UTF-8
+ content = new String(Files.readAllBytes(source.toPath()), StandardCharsets.UTF_8);
+ } catch (IOException e) {
+ throw new UncheckedIOException(e);
+ }
+ if (content.contains(ANY_NAME)) {
+ // a unicode escape can spell any name, so this file may declare anything
+ names.add(ANY_NAME);
+ }
+ Matcher identifier = IDENTIFIER.matcher(content);
+ while (identifier.find()) {
+ names.add(identifier.group());
+ }
+ }
+ return names;
+ });
+ }
+ }
+}
diff --git a/lib/src/main/java/com/diffplug/spotless/java/ReplaceStaticImportsStep.java b/lib/src/main/java/com/diffplug/spotless/java/ReplaceStaticImportsStep.java
new file mode 100644
index 0000000000..ef1db42279
--- /dev/null
+++ b/lib/src/main/java/com/diffplug/spotless/java/ReplaceStaticImportsStep.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright 2026 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.spotless.java;
+
+import static com.diffplug.spotless.JarState.from;
+import static com.diffplug.spotless.JarState.promise;
+import static java.util.Objects.requireNonNull;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Serial;
+import java.io.Serializable;
+import java.lang.reflect.InvocationTargetException;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+import com.diffplug.spotless.FileSignature;
+import com.diffplug.spotless.FormatterFunc;
+import com.diffplug.spotless.FormatterStep;
+import com.diffplug.spotless.JarState;
+import com.diffplug.spotless.Provisioner;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+/**
+ * Replaces static imports with regular imports and qualified references, so that
+ * {@code assertTrue(x)} becomes {@code Assertions.assertTrue(x)}.
+ *
+ * Uses JavaParser and the project classpath to work out what each name refers to. A static
+ * import is only replaced when every use of it can be resolved; otherwise it is left as it is.
+ *
+ *
Designed to run before {@code importOrder()} and {@code removeUnusedImports()}.
+ */
+public final class ReplaceStaticImportsStep implements Serializable {
+ @Serial
+ private static final long serialVersionUID = 1L;
+
+ private static final String NAME = "replaceStaticImports";
+ private static final String INCOMPATIBLE_ERROR_MESSAGE = "There was a problem interacting with JavaParser; maybe you set an incompatible version?";
+ private static final String MAVEN_COORDINATES = "com.github.javaparser:javaparser-symbol-solver-core:" + BuildConfig.VERSION_JAVAPARSER;
+
+ private final List typeSolverClasspath;
+ private final List excludes;
+ private final JarState.Promised jarState;
+
+ private ReplaceStaticImportsStep(List typeSolverClasspath, List excludes, JarState.Promised jarState) {
+ this.typeSolverClasspath = typeSolverClasspath;
+ this.excludes = excludes;
+ this.jarState = jarState;
+ }
+
+ /**
+ * @param typeSolverClasspath source directories and jars used to resolve names, normally the
+ * source directories and compile classpath of the project
+ */
+ public static FormatterStep create(Set typeSolverClasspath, Provisioner provisioner) {
+ return create(typeSolverClasspath, List.of(), provisioner);
+ }
+
+ /**
+ * @param typeSolverClasspath source directories and jars used to resolve names, normally the
+ * source directories and compile classpath of the project
+ * @param excludes static imports to keep: {@code org.assertj.core.api.Assertions.*}, or just the type name, keeps
+ * every static import from that class; {@code java.util.concurrent.TimeUnit.SECONDS} keeps the static import of
+ * that member, and an on-demand static import of its class if the file uses the member through it
+ */
+ public static FormatterStep create(Set typeSolverClasspath, Collection excludes, Provisioner provisioner) {
+ requireNonNull(typeSolverClasspath);
+ requireNonNull(excludes);
+ requireNonNull(provisioner);
+ Set sortedExcludes = new TreeSet<>();
+ for (String exclude : excludes) {
+ sortedExcludes.add(requireNonNull(exclude).trim());
+ }
+ return FormatterStep.create(NAME,
+ new ReplaceStaticImportsStep(List.copyOf(typeSolverClasspath), List.copyOf(sortedExcludes), promise(() -> from(MAVEN_COORDINATES, provisioner))),
+ ReplaceStaticImportsStep::equalityState,
+ State::toFormatter);
+ }
+
+ private State equalityState() throws IOException {
+ List jars = typeSolverClasspath.stream().filter(file -> file.isFile() && file.getName().endsWith(".jar")).toList();
+ return new State(typeSolverClasspath, FileSignature.signAsList(jars), excludes, jarState.get());
+ }
+
+ /**
+ * Equality depends on the content of the jars, the excludes, the JavaParser version and the JDK version. The
+ * paths are transient, so that build cache keys do not depend on where the project is.
+ */
+ private static final class State implements Serializable {
+ @Serial
+ private static final long serialVersionUID = 1L;
+
+ /** Only used to create the formatter: the equality state is never deserialized, and the paths must not affect equality. */
+ @SuppressFBWarnings(value = "SE_TRANSIENT_FIELD_NOT_RESTORED", justification = "paths are kept out of the equality check, like FileSignature does")
+ private final transient List typeSolverClasspath;
+ @SuppressWarnings("unused")
+ private final FileSignature jars;
+ private final List excludes;
+ private final JarState jarState;
+ /** The JDK classes are those of the JDK running the build, which can make a difference. */
+ @SuppressWarnings("unused")
+ private final int jdkVersion = Runtime.version().feature();
+
+ State(List typeSolverClasspath, FileSignature jars, List excludes, JarState jarState) {
+ this.typeSolverClasspath = typeSolverClasspath;
+ this.jars = jars;
+ this.excludes = excludes;
+ this.jarState = jarState;
+ }
+
+ FormatterFunc toFormatter() {
+ try {
+ return (FormatterFunc) jarState
+ .getClassLoader()
+ .loadClass("com.diffplug.spotless.glue.javaparser.ReplaceStaticImportsFormatterFunc")
+ .getConstructor(Collection.class, Collection.class)
+ .newInstance(typeSolverClasspath, excludes);
+ } catch (ClassNotFoundException | NoSuchMethodException | InvocationTargetException
+ | InstantiationException | IllegalAccessException | NoClassDefFoundError cause) {
+ throw new IllegalStateException(INCOMPATIBLE_ERROR_MESSAGE, cause);
+ }
+ }
+ }
+}
diff --git a/plugin-gradle/CHANGES.md b/plugin-gradle/CHANGES.md
index 27c78dde65..83287f62bb 100644
--- a/plugin-gradle/CHANGES.md
+++ b/plugin-gradle/CHANGES.md
@@ -6,6 +6,7 @@ We adhere to the [keepachangelog](https://keepachangelog.com/en/1.0.0/) format (
### Added
- Add `groupArtifact(String)` to `palantirJavaFormat()`. ([#3179](https://github.com/diffplug/spotless/pull/3179))
- `SpotlessApply` writes a report of the files it rewrote to `build/spotless/-changed-files.txt`, configurable via `changedFilesReport`. The report is a task output, so tasks which take it as an input automatically depend on the apply task. ([#2715](https://github.com/diffplug/spotless/issues/2715))
+- Add `replaceStaticImports()` for Java, which replaces static imports with regular imports and qualified references, such as `Assertions.assertTrue(x)`, using the compile classpath to resolve names. Pass the static imports to keep, such as `'org.assertj.core.api.Assertions.*'`. ([#1379](https://github.com/diffplug/spotless/issues/1379))
### Changes
- `SpotlessApply` now only reports that it did work (and is otherwise `UP-TO-DATE`) when it actually rewrote a file. ([#2715](https://github.com/diffplug/spotless/issues/2715))
### Fixed
diff --git a/plugin-gradle/README.md b/plugin-gradle/README.md
index e762f1d5c5..60c3c1503b 100644
--- a/plugin-gradle/README.md
+++ b/plugin-gradle/README.md
@@ -79,7 +79,7 @@ Spotless supports all of Gradle's built-in performance features (incremental bui
- [Git hook (optional)](#git-hook)
- [Linting](#linting)
- **Languages**
- - [Java](#java) ([removeUnusedImports](#removeunusedimports), [forbidWildcardImports](#forbidwildcardimports), [expandWildcardImports](#expandwildcardimports), [forbidModuleImports](#forbidmoduleimports), [shortenFullyQualifiedTypes](#shortenfullyqualifiedtypes), [google-java-format](#google-java-format), [eclipse jdt](#eclipse-jdt), [clang-format](#clang-format), [prettier](#prettier), [palantir-java-format](#palantir-java-format), [prince-of-space](#prince-of-space), [formatAnnotations](#formatAnnotations), [cleanthat](#cleanthat), [tabletest-formatter](#tabletest-formatter), [IntelliJ IDEA](#intellij-idea))
+ - [Java](#java) ([removeUnusedImports](#removeunusedimports), [forbidWildcardImports](#forbidwildcardimports), [expandWildcardImports](#expandwildcardimports), [forbidModuleImports](#forbidmoduleimports), [shortenFullyQualifiedTypes](#shortenfullyqualifiedtypes), [replaceStaticImports](#replacestaticimports), [google-java-format](#google-java-format), [eclipse jdt](#eclipse-jdt), [clang-format](#clang-format), [prettier](#prettier), [palantir-java-format](#palantir-java-format), [prince-of-space](#prince-of-space), [formatAnnotations](#formatAnnotations), [cleanthat](#cleanthat), [tabletest-formatter](#tabletest-formatter), [IntelliJ IDEA](#intellij-idea))
- [Groovy](#groovy) ([eclipse groovy](#eclipse-groovy))
- [Kotlin](#kotlin) ([ktfmt](#ktfmt), [ktlint](#ktlint), [diktat](#diktat), [tabletest-formatter](#tabletest-formatter-1), [prettier](#prettier))
- [Scala](#scala) ([scalafmt](#scalafmt))
@@ -234,6 +234,7 @@ spotless {
forbidWildcardImports() // or expandWildcardImports, see below
forbidModuleImports()
shortenFullyQualifiedTypes() // replaces fully-qualified type names with simple names + imports
+ replaceStaticImports() // replaces static imports with qualified references + imports, see below
// Cleanthat will refactor your code, but it may break your style: apply it before your formatter
cleanthat() // has its own section below
@@ -371,6 +372,71 @@ A name is left fully-qualified whenever shortening it could change what the code
Types in `java.lang` and in the file's own package are shortened without adding an import.
+### replaceStaticImports
+
+Replaces static imports with regular imports and qualified references, for codebases that prefer `Assertions.assertTrue(x)` to a bare `assertTrue(x)`.
+
+Like [`expandWildcardImports`](#expandwildcardimports), it uses [JavaParser](https://javaparser.org/) and your compile classpath to work out what each name refers to, so it needs the `java` plugin. New imports are appended after the existing ones, so run it before `importOrder()`:
+
+```gradle
+spotless {
+ java {
+ replaceStaticImports()
+ importOrder()
+ removeUnusedImports()
+ }
+}
+```
+
+Before:
+
+```java
+package com.acme;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class TimeoutTest {
+ void defaultTimeout() {
+ assertEquals(30_000, SECONDS.toMillis(30));
+ }
+}
+```
+
+After:
+
+```java
+package com.acme;
+
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Assertions;
+
+class TimeoutTest {
+ void defaultTimeout() {
+ Assertions.assertEquals(30_000, TimeUnit.SECONDS.toMillis(30));
+ }
+}
+```
+
+It never changes what the code means, so a static import is only replaced when every use of it can be resolved:
+
+- a name hidden by a local variable, or by a method, field or nested class of the enclosing class, is not a use of the import and stays as it is
+- an enum constant used as a `case` label of a `switch` on that enum stays unqualified, since qualified ones only compile from Java 21 on
+- when the simple name of the class is already taken in the file, the fully qualified name is used, e.g. `java.util.Date.from(instant)`
+- a static import of a nested class becomes a regular import of that class, e.g. `import java.util.Map.Entry;`
+- a static import that the classpath cannot resolve, or whose names are also supplied by another imported class, is left alone
+- so is a static import with a use that cannot be resolved with certainty, for example in a class whose supertypes are not on the classpath or that uses Lombok, inside a `spotless:off` region, or in a Javadoc reference
+
+It relies on the classpath to know what names mean:
+
+- JDK classes are those of the JDK that runs the build, so run the build with the JDK that the project compiles against, or a newer one
+- all source sets share one classpath, as with `expandWildcardImports`
+- classes that are not on the classpath, such as generated sources, are assumed not to exist: a generated class in the same package named like a class that it qualifies with, such as `Math`, would take over `Math.max`
+- of the regions that `toggleOffOn` restores, it only recognises those between `spotless:off` and `spotless:on`, or `@formatter:off` and `@formatter:on`
+
+To keep some static imports, such as AssertJ's, list them: `replaceStaticImports('org.assertj.core.api.Assertions.*', 'java.util.concurrent.TimeUnit.SECONDS')`. `Type.*`, or just `Type`, keeps every static import from that class. `Type.member` keeps the static import of that member, and an on-demand `import static Type.*;` if the file uses that member through it.
+
+
### google-java-format
[homepage](https://github.com/google/google-java-format). [changelog](https://github.com/google/google-java-format/releases).
diff --git a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/JavaExtension.java b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/JavaExtension.java
index ed7fa4151f..d8341117fb 100644
--- a/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/JavaExtension.java
+++ b/plugin-gradle/src/main/java/com/diffplug/gradle/spotless/JavaExtension.java
@@ -16,13 +16,14 @@
package com.diffplug.gradle.spotless;
import static com.diffplug.gradle.spotless.PluginGradlePreconditions.requireElementsNonNull;
-import static java.util.stream.Collectors.toSet;
+import static java.util.stream.Collectors.toCollection;
import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
+import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@@ -47,6 +48,7 @@
import com.diffplug.spotless.java.PalantirJavaFormatStep;
import com.diffplug.spotless.java.PrinceOfSpaceStep;
import com.diffplug.spotless.java.RemoveUnusedImportsStep;
+import com.diffplug.spotless.java.ReplaceStaticImportsStep;
import com.diffplug.spotless.java.ShortenFullyQualifiedTypesStep;
import com.diffplug.spotless.java.TableTestFormatterStep;
@@ -179,13 +181,28 @@ public void forbidModuleImports() {
}
public void expandWildcardImports() {
- SourceSetContainer sourceSets = getSourceSets(getProject(), "expansion of wildcards requires the 'java' plugin to be applied");
- Set typeSolverClasspath = sourceSets.stream().flatMap(s -> s.getAllJava().getSrcDirs().stream()).collect(toSet());
+ addStep(ExpandWildcardImportsStep.create(typeSolverClasspath("expansion of wildcards requires the 'java' plugin to be applied"), provisioner()));
+ }
+
+ /**
+ * Replaces static imports with regular imports and qualified references, such as {@code Assertions.assertTrue(x)}.
+ *
+ * @param excludes static imports to keep, such as {@code org.assertj.core.api.Assertions.*} for every static import
+ * from that class, or {@code java.util.concurrent.TimeUnit.SECONDS} for the import of that member
+ */
+ public void replaceStaticImports(String... excludes) {
+ addStep(ReplaceStaticImportsStep.create(typeSolverClasspath("replacing static imports requires the 'java' plugin to be applied"), List.of(excludes), provisioner()));
+ }
+
+ /** The source directories and compile classpath of every source set, which JavaParser uses to resolve names. */
+ private Set typeSolverClasspath(String message) {
+ SourceSetContainer sourceSets = getSourceSets(getProject(), message);
+ Set typeSolverClasspath = sourceSets.stream().flatMap(s -> s.getAllJava().getSrcDirs().stream()).collect(toCollection(LinkedHashSet::new));
sourceSets.stream()
.map(SourceSet::getCompileClasspath)
.flatMap(classpath -> classpath.getFiles().stream())
.forEach(typeSolverClasspath::add);
- addStep(ExpandWildcardImportsStep.create(typeSolverClasspath, provisioner()));
+ return typeSolverClasspath;
}
/** Uses the google-java-format jar to format source code. */
diff --git a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/JavaDefaultTargetTest.java b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/JavaDefaultTargetTest.java
index 60762dce8f..9662a60f96 100644
--- a/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/JavaDefaultTargetTest.java
+++ b/plugin-gradle/src/test/java/com/diffplug/gradle/spotless/JavaDefaultTargetTest.java
@@ -208,6 +208,58 @@ void expandWildcardImportsIgnoresUnrelatedConfigurations() throws IOException {
assertFile("src/main/java/test.java").sameAsResource("java/googlejavaformat/JavaCodeUnformatted.test");
}
+ @Test
+ void replaceStaticImports() throws IOException {
+ setFile("build.gradle").toLines(
+ "plugins {",
+ " id 'java'",
+ " id 'com.diffplug.spotless'",
+ "}",
+ "",
+ "repositories { mavenCentral() }",
+ "",
+ "spotless {",
+ " java {",
+ " target file('src/main/java/p/A.java')",
+ " replaceStaticImports('java.lang.Math.*')",
+ " }",
+ "}");
+ // only resolvable through the source sets
+ setFile("src/main/java/q/Codes.java").toLines(
+ "package q;",
+ "",
+ "public final class Codes {",
+ " public static final int OK = 0;",
+ "}");
+ setFile("src/main/java/p/A.java").toLines(
+ "package p;",
+ "",
+ "import static java.lang.Math.max;",
+ "import static java.util.Objects.requireNonNull;",
+ "import static q.Codes.OK;",
+ "",
+ "class A {",
+ " int f(Object o) {",
+ " requireNonNull(o);",
+ " return max(OK, 1);",
+ " }",
+ "}");
+ gradleRunner().withArguments("spotlessApply").build();
+ assertFile("src/main/java/p/A.java").hasLines(
+ "package p;",
+ "",
+ "import static java.lang.Math.max;",
+ "import java.util.Objects;",
+ "import q.Codes;",
+ "",
+ "class A {",
+ " int f(Object o) {",
+ " Objects.requireNonNull(o);",
+ " return max(Codes.OK, 1);",
+ " }",
+ "}");
+ }
+
/**
* Triggers the special case in {@link FormatExtension#setupTask(SpotlessTask)} with {@code toggleFence} and
* {@code targetExcludeContentPattern} both being not {@code null}.
diff --git a/plugin-maven/CHANGES.md b/plugin-maven/CHANGES.md
index 7120684723..270fb9f345 100644
--- a/plugin-maven/CHANGES.md
+++ b/plugin-maven/CHANGES.md
@@ -7,6 +7,7 @@ We adhere to the [keepachangelog](https://keepachangelog.com/en/1.0.0/) format (
- Add a `` parameter to ``. ([#3179](https://github.com/diffplug/spotless/pull/3179))
- Add a `spotless:report` goal that puts a Spotless page in the Maven site. ([#3175](https://github.com/diffplug/spotless/pull/3175))
List `spotless-maven-plugin` under `` and run `mvn site`: the page shows which files need formatting, with a colored diff for each, and their lint problems. It works with `maven-site-plugin` 3.12.1 and 3.20.0 or later.
+- Add `` for Java, which replaces static imports with regular imports and qualified references, such as `Assertions.assertTrue(x)`, using the project's source roots and dependencies to resolve names. Static imports to keep go in ``. ([#1379](https://github.com/diffplug/spotless/issues/1379))
### Fixed
- GrEclipse no longer leaves a `file%3A...` directory in the working directory. ([#2019](https://github.com/diffplug/spotless/issues/2019))
- DBeaver SQL formatter no longer prints an `IndexOutOfBoundsException` when a file starts with a keyword like `SET`. ([#1552](https://github.com/diffplug/spotless/issues/1552))
diff --git a/plugin-maven/README.md b/plugin-maven/README.md
index cb94daa3de..c38227bccd 100644
--- a/plugin-maven/README.md
+++ b/plugin-maven/README.md
@@ -40,7 +40,7 @@ user@machine repo % mvn spotless:check
- [Git hook (optional)](#git-hook)
- [Binding to maven phase](#binding-to-maven-phase)
- **Languages**
- - [Java](#java) ([removeUnusedImports](#removeunusedimports), [forbidWildcardImports](#forbidwildcardimports), [expandWildcardImports](#expandwildcardimports), [forbidModuleImports](#forbidmoduleimports), [shortenFullyQualifiedTypes](#shortenfullyqualifiedtypes), [google-java-format](#google-java-format), [eclipse jdt](#eclipse-jdt), [prettier](#prettier), [palantir-java-format](#palantir-java-format), [prince-of-space](#prince-of-space), [formatAnnotations](#formatAnnotations), [cleanthat](#cleanthat), [tabletest-formatter](#tabletest-formatter), [IntelliJ IDEA](#intellij-idea))
+ - [Java](#java) ([removeUnusedImports](#removeunusedimports), [forbidWildcardImports](#forbidwildcardimports), [expandWildcardImports](#expandwildcardimports), [forbidModuleImports](#forbidmoduleimports), [shortenFullyQualifiedTypes](#shortenfullyqualifiedtypes), [replaceStaticImports](#replacestaticimports), [google-java-format](#google-java-format), [eclipse jdt](#eclipse-jdt), [prettier](#prettier), [palantir-java-format](#palantir-java-format), [prince-of-space](#prince-of-space), [formatAnnotations](#formatAnnotations), [cleanthat](#cleanthat), [tabletest-formatter](#tabletest-formatter), [IntelliJ IDEA](#intellij-idea))
- [Groovy](#groovy) ([eclipse groovy](#eclipse-groovy))
- [Kotlin](#kotlin) ([ktfmt](#ktfmt), [ktlint](#ktlint), [diktat](#diktat), [tabletest-formatter](#tabletest-formatter-1), [prettier](#prettier))
- [Scala](#scala) ([scalafmt](#scalafmt))
@@ -238,6 +238,7 @@ any other maven phase (i.e. compile) then it can be configured as below;
+
@@ -335,6 +336,76 @@ A name is left fully-qualified whenever shortening it could change what the code
Types in `java.lang` and in the file's own package are shortened without adding an import.
+### replaceStaticImports
+
+Replaces static imports with regular imports and qualified references, for codebases that prefer `Assertions.assertTrue(x)` to a bare `assertTrue(x)`.
+
+Like [`expandWildcardImports`](#expandwildcardimports), it uses [JavaParser](https://javaparser.org/) and your project's source roots and dependencies to work out what each name refers to. New imports are appended after the existing ones, so run it before ``:
+
+```xml
+
+
+
+```
+
+Before:
+
+```java
+package com.acme;
+
+import static java.util.concurrent.TimeUnit.SECONDS;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class TimeoutTest {
+ void defaultTimeout() {
+ assertEquals(30_000, SECONDS.toMillis(30));
+ }
+}
+```
+
+After:
+
+```java
+package com.acme;
+
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.Assertions;
+
+class TimeoutTest {
+ void defaultTimeout() {
+ Assertions.assertEquals(30_000, TimeUnit.SECONDS.toMillis(30));
+ }
+}
+```
+
+It never changes what the code means, so a static import is only replaced when every use of it can be resolved:
+
+- a name hidden by a local variable, or by a method, field or nested class of the enclosing class, is not a use of the import and stays as it is
+- an enum constant used as a `case` label of a `switch` on that enum stays unqualified, since qualified ones only compile from Java 21 on
+- when the simple name of the class is already taken in the file, the fully qualified name is used, e.g. `java.util.Date.from(instant)`
+- a static import of a nested class becomes a regular import of that class, e.g. `import java.util.Map.Entry;`
+- a static import that the classpath cannot resolve, or whose names are also supplied by another imported class, is left alone
+- so is a static import with a use that cannot be resolved with certainty, for example in a class whose supertypes are not on the classpath or that uses Lombok, inside a `spotless:off` region, or in a Javadoc reference
+
+It relies on the classpath to know what names mean:
+
+- JDK classes are those of the JDK that runs Maven, so run Maven with the JDK that the project compiles against, or a newer one
+- main and test sources share one classpath, as with `expandWildcardImports`
+- classes that are not on the classpath, such as generated sources, are assumed not to exist: a generated class in the same package named like a class that it qualifies with, such as `Math`, would take over `Math.max`
+- of the regions that `` restores, it only recognises those between `spotless:off` and `spotless:on`, or `@formatter:off` and `@formatter:on`
+
+To keep some static imports, such as AssertJ's, list them. `Type.*`, or just `Type`, keeps every static import from that class. `Type.member` keeps the static import of that member, and an on-demand `import static Type.*;` if the file uses that member through it:
+
+```xml
+
+
+ org.assertj.core.api.Assertions.*
+ java.util.concurrent.TimeUnit.SECONDS
+
+
+```
+
+
### google-java-format
[homepage](https://github.com/google/google-java-format). [changelog](https://github.com/google/google-java-format/releases). [code](https://github.com/diffplug/spotless/blob/main/plugin-maven/src/main/java/com/diffplug/spotless/maven/java/GoogleJavaFormat.java).
diff --git a/plugin-maven/src/main/java/com/diffplug/spotless/maven/AbstractSpotlessMojo.java b/plugin-maven/src/main/java/com/diffplug/spotless/maven/AbstractSpotlessMojo.java
index e7401be073..5a9d81793f 100644
--- a/plugin-maven/src/main/java/com/diffplug/spotless/maven/AbstractSpotlessMojo.java
+++ b/plugin-maven/src/main/java/com/diffplug/spotless/maven/AbstractSpotlessMojo.java
@@ -428,8 +428,19 @@ private FormatterConfig getFormatterConfig() {
final Optional userRatchetFrom = Optional.ofNullable((String) mavenSession.getUserProperties().get("ratchetFrom"));
final Optional optionalRatchetFrom = Optional.ofNullable(this.ratchetFrom)
.filter(ratchet -> !RATCHETFROM_NONE.equals(ratchet));
- // Lazy: only resolve dependencies when the expandWildcardImports step actually requests the classpath.
- Supplier> projectClasspathSupplier = () -> computeTypeSolverClasspath(resolver);
+ // Lazy: only resolve dependencies when a step that resolves names, such as expandWildcardImports, actually requests the
+ // classpath, and only once, however many steps request it.
+ Supplier> projectClasspathSupplier = new Supplier<>() {
+ private Set classpath;
+
+ @Override
+ public synchronized Set get() {
+ if (classpath == null) {
+ classpath = computeTypeSolverClasspath(resolver);
+ }
+ return classpath;
+ }
+ };
return new FormatterConfig(baseDir, encoding, lineEndings, userRatchetFrom, optionalRatchetFrom, provisioner, p2Provisioner, fileLocator, formatterStepFactories, Optional.ofNullable(setLicenseHeaderYearsFromGitHistory), lintSuppressions, Optional.of(projectClasspathSupplier));
}
@@ -455,7 +466,7 @@ private Set computeTypeSolverClasspath(ArtifactResolver resolver) {
Set dependencyJars = resolver.resolveProjectDependencies(project, repositories);
classpath.addAll(dependencyJars);
} catch (Exception e) {
- getLog().warn("Could not resolve project dependencies for expandWildcardImports: " + e.getMessage());
+ getLog().warn("Could not resolve project dependencies for expandWildcardImports or replaceStaticImports: " + e.getMessage());
}
return classpath;
diff --git a/plugin-maven/src/main/java/com/diffplug/spotless/maven/java/Java.java b/plugin-maven/src/main/java/com/diffplug/spotless/maven/java/Java.java
index 996dbefea7..038428ac9a 100644
--- a/plugin-maven/src/main/java/com/diffplug/spotless/maven/java/Java.java
+++ b/plugin-maven/src/main/java/com/diffplug/spotless/maven/java/Java.java
@@ -107,6 +107,10 @@ public void addShortenFullyQualifiedTypes(ShortenFullyQualifiedTypes shortenFull
addStepFactory(shortenFullyQualifiedTypes);
}
+ public void addReplaceStaticImports(ReplaceStaticImports replaceStaticImports) {
+ addStepFactory(replaceStaticImports);
+ }
+
private static String fileMask(Path path) {
String dir = path.toString();
if (!dir.endsWith(File.separator)) {
diff --git a/plugin-maven/src/main/java/com/diffplug/spotless/maven/java/ReplaceStaticImports.java b/plugin-maven/src/main/java/com/diffplug/spotless/maven/java/ReplaceStaticImports.java
new file mode 100644
index 0000000000..b615ded0b3
--- /dev/null
+++ b/plugin-maven/src/main/java/com/diffplug/spotless/maven/java/ReplaceStaticImports.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2026 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.spotless.maven.java;
+
+import java.io.File;
+import java.util.Collections;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Supplier;
+
+import org.apache.maven.plugins.annotations.Parameter;
+
+import com.diffplug.spotless.FormatterStep;
+import com.diffplug.spotless.java.ReplaceStaticImportsStep;
+import com.diffplug.spotless.maven.FormatterStepConfig;
+import com.diffplug.spotless.maven.FormatterStepFactory;
+
+public class ReplaceStaticImports implements FormatterStepFactory {
+ /** Static imports to keep: {@code org.assertj.core.api.Assertions.*} for every static import from that class, or {@code java.util.concurrent.TimeUnit.SECONDS} for the import of that member. */
+ @Parameter
+ private String[] excludes;
+
+ @Override
+ public FormatterStep newFormatterStep(FormatterStepConfig config) {
+ Set classpath = config.getProjectClasspathSupplier()
+ .map(Supplier::get)
+ .orElse(Collections.emptySet());
+ return ReplaceStaticImportsStep.create(classpath, excludes == null ? List.of() : List.of(excludes), config.getProvisioner());
+ }
+}
diff --git a/plugin-maven/src/test/java/com/diffplug/spotless/maven/java/ReplaceStaticImportsStepTest.java b/plugin-maven/src/test/java/com/diffplug/spotless/maven/java/ReplaceStaticImportsStepTest.java
new file mode 100644
index 0000000000..645325177d
--- /dev/null
+++ b/plugin-maven/src/test/java/com/diffplug/spotless/maven/java/ReplaceStaticImportsStepTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2026 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.spotless.maven.java;
+
+import org.junit.jupiter.api.Test;
+
+import com.diffplug.spotless.maven.MavenIntegrationHarness;
+
+class ReplaceStaticImportsStepTest extends MavenIntegrationHarness {
+
+ @Test
+ void replaceStaticImports() throws Exception {
+ writePomWithJavaSteps("java.lang.Math.* ");
+ // only resolvable through the project's source roots
+ setFile("src/main/java/q/Codes.java").toContent("""
+ package q;
+
+ public final class Codes {
+ public static final int OK = 0;
+ }
+ """);
+ String path = "src/main/java/p/A.java";
+ setFile(path).toContent("""
+ package p;
+
+ import static java.lang.Math.max;
+ import static java.util.Objects.requireNonNull;
+ import static q.Codes.OK;
+
+ class A {
+ int f(Object o) {
+ requireNonNull(o);
+ return max(OK, 1);
+ }
+ }
+ """);
+
+ mavenRunner().withArguments("spotless:apply").runNoError();
+
+ assertFile(path).hasContent("""
+ package p;
+
+ import static java.lang.Math.max;
+ import java.util.Objects;
+ import q.Codes;
+
+ class A {
+ int f(Object o) {
+ Objects.requireNonNull(o);
+ return max(Codes.OK, 1);
+ }
+ }
+ """);
+ }
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/AmbiguousOnDemandFormatted.test b/testlib/src/main/resources/java/replacestaticimports/AmbiguousOnDemandFormatted.test
new file mode 100644
index 0000000000..86a8404a97
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/AmbiguousOnDemandFormatted.test
@@ -0,0 +1,11 @@
+package p;
+
+import java.awt.*;
+import java.util.*;
+import java.util.List;
+
+class A {
+ Object f() {
+ return List.of(1);
+ }
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/AmbiguousOnDemandUnformatted.test b/testlib/src/main/resources/java/replacestaticimports/AmbiguousOnDemandUnformatted.test
new file mode 100644
index 0000000000..17fdf14991
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/AmbiguousOnDemandUnformatted.test
@@ -0,0 +1,12 @@
+package p;
+
+import java.awt.*;
+import java.util.*;
+
+import static java.util.List.of;
+
+class A {
+ Object f() {
+ return of(1);
+ }
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/ExcludedMemberUsedThroughOnDemandImport.test b/testlib/src/main/resources/java/replacestaticimports/ExcludedMemberUsedThroughOnDemandImport.test
new file mode 100644
index 0000000000..b3bb9f01d1
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/ExcludedMemberUsedThroughOnDemandImport.test
@@ -0,0 +1,9 @@
+package p;
+
+import static java.util.concurrent.TimeUnit.*;
+
+class A {
+ long f() {
+ return SECONDS.toMillis(1);
+ }
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/JavaLangWithInvisibleOnDemandCompetitorFormatted.test b/testlib/src/main/resources/java/replacestaticimports/JavaLangWithInvisibleOnDemandCompetitorFormatted.test
new file mode 100644
index 0000000000..dd161feae8
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/JavaLangWithInvisibleOnDemandCompetitorFormatted.test
@@ -0,0 +1,7 @@
+package q;
+
+import x.*;
+
+class Main {
+ int m = java.lang.Math.max(1, 2);
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/JavaLangWithInvisibleOnDemandCompetitorUnformatted.test b/testlib/src/main/resources/java/replacestaticimports/JavaLangWithInvisibleOnDemandCompetitorUnformatted.test
new file mode 100644
index 0000000000..3cd5c0d080
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/JavaLangWithInvisibleOnDemandCompetitorUnformatted.test
@@ -0,0 +1,9 @@
+package q;
+
+import x.*;
+
+import static java.lang.Math.max;
+
+class Main {
+ int m = max(1, 2);
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/OnDemandJavaLangFormatted.test b/testlib/src/main/resources/java/replacestaticimports/OnDemandJavaLangFormatted.test
new file mode 100644
index 0000000000..b6e57f270f
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/OnDemandJavaLangFormatted.test
@@ -0,0 +1,7 @@
+package p;
+
+class A {
+ double f(double a, double b) {
+ return Math.max(a, b) * Math.PI;
+ }
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/OnDemandJavaLangUnformatted.test b/testlib/src/main/resources/java/replacestaticimports/OnDemandJavaLangUnformatted.test
new file mode 100644
index 0000000000..93db85a4b0
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/OnDemandJavaLangUnformatted.test
@@ -0,0 +1,9 @@
+package p;
+
+import static java.lang.Math.*;
+
+class A {
+ double f(double a, double b) {
+ return max(a, b) * PI;
+ }
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/SameDeclarationThroughTwoImportsFormatted.test b/testlib/src/main/resources/java/replacestaticimports/SameDeclarationThroughTwoImportsFormatted.test
new file mode 100644
index 0000000000..d501f5684b
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/SameDeclarationThroughTwoImportsFormatted.test
@@ -0,0 +1,8 @@
+package p;
+
+import q.Matchers;
+import q.Mocks;
+
+class A {
+ String s = Mocks.when(Matchers.any());
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/SameDeclarationThroughTwoImportsUnformatted.test b/testlib/src/main/resources/java/replacestaticimports/SameDeclarationThroughTwoImportsUnformatted.test
new file mode 100644
index 0000000000..367bf21cf1
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/SameDeclarationThroughTwoImportsUnformatted.test
@@ -0,0 +1,8 @@
+package p;
+
+import static q.Matchers.any;
+import static q.Mocks.*;
+
+class A {
+ String s = when(any());
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/SingleAndOnDemandFormatted.test b/testlib/src/main/resources/java/replacestaticimports/SingleAndOnDemandFormatted.test
new file mode 100644
index 0000000000..21aa5cf073
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/SingleAndOnDemandFormatted.test
@@ -0,0 +1,9 @@
+package p;
+
+import java.util.Objects;
+
+class A {
+ Object f(Object o) {
+ return Objects.requireNonNull(Objects.isNull(o) ? null : o);
+ }
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/SingleAndOnDemandUnformatted.test b/testlib/src/main/resources/java/replacestaticimports/SingleAndOnDemandUnformatted.test
new file mode 100644
index 0000000000..5ff44759c1
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/SingleAndOnDemandUnformatted.test
@@ -0,0 +1,10 @@
+package p;
+
+import static java.util.Objects.requireNonNull;
+import static java.util.Objects.*;
+
+class A {
+ Object f(Object o) {
+ return requireNonNull(isNull(o) ? null : o);
+ }
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/SingleImportOfAFieldShadowsOnDemandFormatted.test b/testlib/src/main/resources/java/replacestaticimports/SingleImportOfAFieldShadowsOnDemandFormatted.test
new file mode 100644
index 0000000000..8a1cfa01ae
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/SingleImportOfAFieldShadowsOnDemandFormatted.test
@@ -0,0 +1,8 @@
+package q;
+
+import p.A;
+import p.B;
+
+class Main {
+ String s = B.X + A.a();
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/SingleImportOfAFieldShadowsOnDemandUnformatted.test b/testlib/src/main/resources/java/replacestaticimports/SingleImportOfAFieldShadowsOnDemandUnformatted.test
new file mode 100644
index 0000000000..166ba31aab
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/SingleImportOfAFieldShadowsOnDemandUnformatted.test
@@ -0,0 +1,8 @@
+package q;
+
+import static p.A.*;
+import static p.B.X;
+
+class Main {
+ String s = X + a();
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/UnresolvableOnDemandImport.test b/testlib/src/main/resources/java/replacestaticimports/UnresolvableOnDemandImport.test
new file mode 100644
index 0000000000..5cc96e75ee
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/UnresolvableOnDemandImport.test
@@ -0,0 +1,10 @@
+package p;
+
+import static java.util.Objects.requireNonNull;
+import static org.example.Missing.*;
+
+class A {
+ Object f(Object o) {
+ return requireNonNull(o);
+ }
+}
diff --git a/testlib/src/main/resources/java/replacestaticimports/UnresolvableSingleImportOfTheSameName.test b/testlib/src/main/resources/java/replacestaticimports/UnresolvableSingleImportOfTheSameName.test
new file mode 100644
index 0000000000..36e86483b0
--- /dev/null
+++ b/testlib/src/main/resources/java/replacestaticimports/UnresolvableSingleImportOfTheSameName.test
@@ -0,0 +1,10 @@
+package p;
+
+import static java.util.Objects.*;
+import static org.example.Missing.requireNonNull;
+
+class A {
+ Object f(Object o) {
+ return isNull(o) ? null : requireNonNull(o);
+ }
+}
diff --git a/testlib/src/test/java/com/diffplug/spotless/java/ReplaceStaticImportsStepTest.java b/testlib/src/test/java/com/diffplug/spotless/java/ReplaceStaticImportsStepTest.java
new file mode 100644
index 0000000000..9bc9031715
--- /dev/null
+++ b/testlib/src/test/java/com/diffplug/spotless/java/ReplaceStaticImportsStepTest.java
@@ -0,0 +1,1767 @@
+/*
+ * Copyright 2026 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.spotless.java;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.Serializable;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import javax.tools.DiagnosticCollector;
+import javax.tools.JavaCompiler;
+import javax.tools.JavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.ToolProvider;
+
+import org.junit.jupiter.api.Test;
+
+import com.diffplug.spotless.FormatterStep;
+import com.diffplug.spotless.ResourceHarness;
+import com.diffplug.spotless.SerializableEqualityTester;
+import com.diffplug.spotless.StepHarness;
+import com.diffplug.spotless.TestProvisioner;
+
+/**
+ * Tests for {@code replaceStaticImports}. The step must never produce code that does not compile or
+ * behaves differently, so most tests are about the cases where a static import has to stay, or where
+ * a name must not be qualified. {@link StepHarness#test} checks that the result is idempotent, and
+ * {@link #assertCompiles} compiles inputs and outputs with the JDK's own compiler.
+ */
+class ReplaceStaticImportsStepTest extends ResourceHarness {
+ private static final Pattern PACKAGE_DECLARATION = Pattern.compile("(?m)^package\\s+([\\w.]+)\\s*;");
+ private static final Pattern TYPE_DECLARATION = Pattern.compile("(?m)^\\s*(public\\s+)?(?:(?:abstract|final|sealed|non-sealed|static)\\s+)*(?:class|interface|enum|record|@interface)\\s+(\\w+)");
+ private int compilations;
+
+ /** A step whose classpath is the {@code src} directory of the test folder, plus the JDK. */
+ private FormatterStep step(String... excludes) {
+ return ReplaceStaticImportsStep.create(Set.of(newFile("src")), List.of(excludes), TestProvisioner.mavenCentral());
+ }
+
+ /** Writes a source file that the type solver, and the compiler, can see. */
+ private void source(String path, String content) throws IOException {
+ setFile("src/" + path).toContent(content);
+ }
+
+ /**
+ * In a real project, the file being formatted is in a source directory on the classpath, which tells the step
+ * which types its package has. The tests format strings, so they also write them there.
+ */
+ private void inASourceDirectory(String source) throws IOException {
+ Matcher packageDeclaration = PACKAGE_DECLARATION.matcher(source);
+ String directory = packageDeclaration.find() ? packageDeclaration.group(1).replace('.', '/') + "/" : "";
+ setFile("src/" + directory + typeName(source) + ".java").toContent(source);
+ }
+
+ /** Checks the step's output, that it is idempotent, and that both the input and the output compile. */
+ private void assertReplaced(String before, String after) throws IOException {
+ inASourceDirectory(before);
+ StepHarness.forStep(step()).test(before, after);
+ assertCompiles(before);
+ assertCompiles(after);
+ }
+
+ private void assertReplacedResource(String before, String after) throws IOException {
+ assertReplaced(getTestResource(before), getTestResource(after));
+ }
+
+ /** Checks that the step leaves a file that compiles alone. */
+ private void assertUnchanged(String source) throws IOException {
+ inASourceDirectory(source);
+ StepHarness.forStep(step()).testUnaffected(source);
+ assertCompiles(source);
+ }
+
+ /** For files that cannot compile here, because they refer to types that are deliberately missing. */
+ private void assertUnchangedWithoutCompiling(String source) throws IOException {
+ inASourceDirectory(source);
+ StepHarness.forStep(step()).testUnaffected(source);
+ }
+
+ /** The name of the public type of the source, or else of its first type, which names its file. */
+ private static String typeName(String source) {
+ String typeName = "A";
+ boolean found = false;
+ Matcher declaration = TYPE_DECLARATION.matcher(source);
+ while (declaration.find()) {
+ if (!found || declaration.group(1) != null) {
+ typeName = declaration.group(2);
+ found = true;
+ if (declaration.group(1) != null) {
+ break;
+ }
+ }
+ }
+ return typeName;
+ }
+
+ /** A jar holding the given sources, compiled by the JDK's compiler. */
+ private File jar(String name, String path, String source) throws IOException {
+ File sources = newFile("jar-sources/" + name);
+ File sourceFile = new File(sources, path);
+ Files.createDirectories(sourceFile.getParentFile().toPath());
+ Files.write(sourceFile.toPath(), source.getBytes(StandardCharsets.UTF_8));
+ File classes = newFile("jar-classes/" + name);
+ Files.createDirectories(classes.toPath());
+ JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+ try (StandardJavaFileManager files = compiler.getStandardFileManager(null, Locale.ROOT, StandardCharsets.UTF_8)) {
+ assertThat(compiler.getTask(null, files, null, List.of("-d", classes.getPath()), null, files.getJavaFileObjects(sourceFile)).call()).isTrue();
+ }
+ File jar = newFile("libs/" + name + ".jar");
+ Files.createDirectories(jar.getParentFile().toPath());
+ try (ZipOutputStream zip = new ZipOutputStream(Files.newOutputStream(jar.toPath()))) {
+ try (Stream classFiles = Files.walk(classes.toPath())) {
+ for (Path classFile : (Iterable) classFiles.filter(Files::isRegularFile)::iterator) {
+ zip.putNextEntry(new ZipEntry(classes.toPath().relativize(classFile).toString().replace(File.separatorChar, '/')));
+ zip.write(Files.readAllBytes(classFile));
+ zip.closeEntry();
+ }
+ }
+ }
+ return jar;
+ }
+
+ /** Compiles the source with the JDK's compiler against the {@code src} folder, to prove that it is valid Java. */
+ private void assertCompiles(String source) throws IOException {
+ JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+ assertThat(compiler).as("these tests need a JDK").isNotNull();
+ File dir = newFile("compile/" + compilations++);
+ File file = new File(dir, typeName(source) + ".java");
+ File classes = new File(dir, "classes");
+ Files.createDirectories(classes.toPath());
+ Files.createDirectories(newFile("src").toPath());
+ Files.write(file.toPath(), source.getBytes(StandardCharsets.UTF_8));
+ DiagnosticCollector diagnostics = new DiagnosticCollector<>();
+ try (StandardJavaFileManager files = compiler.getStandardFileManager(diagnostics, Locale.ROOT, StandardCharsets.UTF_8)) {
+ // javac-only holds types that the compiler sees but the type solver does not, such as generated code
+ String sourcepath = newFile("src").getPath() + File.pathSeparator + newFile("javac-only").getPath();
+ List options = List.of("-d", classes.getPath(), "-sourcepath", sourcepath, "-proc:none", "-Xlint:none");
+ boolean compiled = compiler.getTask(null, files, diagnostics, options, null, files.getJavaFileObjects(file)).call();
+ assertThat(compiled).as("does not compile: %s%n%s", diagnostics.getDiagnostics(), source).isTrue();
+ }
+ }
+
+ @Test
+ void enumConstantFromTheIssue() throws IOException {
+ source("org/enums/Value.java", """
+ package org.enums;
+
+ public enum Value {
+ SOME_ENUM_VALUE, OTHER_VALUE
+ }
+ """);
+ assertReplaced("""
+ package com.example;
+
+ import static org.enums.Value.SOME_ENUM_VALUE;
+
+ public class Test {
+ public void method() {
+ var example = SOME_ENUM_VALUE;
+ }
+ }
+ """, """
+ package com.example;
+
+ import org.enums.Value;
+
+ public class Test {
+ public void method() {
+ var example = Value.SOME_ENUM_VALUE;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void staticMethodGetsQualifiedAndItsTypeImported() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import java.util.List;
+
+ import static java.util.Objects.requireNonNull;
+
+ class A {
+ List f(List list) {
+ return requireNonNull(list).isEmpty() ? null : requireNonNull(list);
+ }
+ }
+ """, """
+ package p;
+
+ import java.util.List;
+ import java.util.Objects;
+
+ class A {
+ List f(List list) {
+ return Objects.requireNonNull(list).isEmpty() ? null : Objects.requireNonNull(list);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void onDemandImportFromJavaLangNeedsNoNewImport() throws IOException {
+ // in a resource file, because the build forbids wildcard imports even inside text blocks
+ assertReplacedResource("java/replacestaticimports/OnDemandJavaLangUnformatted.test", "java/replacestaticimports/OnDemandJavaLangFormatted.test");
+ }
+
+ @Test
+ void enumCaseLabelsStayUnqualified() throws IOException {
+ // a qualified enum constant is not a valid case label before Java 21
+ assertReplaced("""
+ package p;
+
+ import static java.util.concurrent.TimeUnit.SECONDS;
+
+ import java.util.concurrent.TimeUnit;
+
+ class A {
+ \tlong f(TimeUnit unit) {
+ \t\tswitch (unit) {
+ \t\tcase SECONDS:
+ \t\t\treturn SECONDS.toMillis(1);
+ \t\tdefault:
+ \t\t\treturn 0;
+ \t\t}
+ \t}
+
+ \tString g(TimeUnit unit) {
+ \t\treturn switch (unit) {
+ \t\tcase SECONDS -> "s";
+ \t\tdefault -> "?";
+ \t\t};
+ \t}
+ }
+ """, """
+ package p;
+
+ import java.util.concurrent.TimeUnit;
+
+ class A {
+ \tlong f(TimeUnit unit) {
+ \t\tswitch (unit) {
+ \t\tcase SECONDS:
+ \t\t\treturn TimeUnit.SECONDS.toMillis(1);
+ \t\tdefault:
+ \t\t\treturn 0;
+ \t\t}
+ \t}
+
+ \tString g(TimeUnit unit) {
+ \t\treturn switch (unit) {
+ \t\tcase SECONDS -> "s";
+ \t\tdefault -> "?";
+ \t\t};
+ \t}
+ }
+ """);
+ }
+
+ @Test
+ void constantCaseLabelGetsQualified() throws IOException {
+ source("q/Codes.java", """
+ package q;
+
+ public final class Codes {
+ public static final int OK = 0;
+ }
+ """);
+ assertReplaced("""
+ package p;
+
+ import static q.Codes.OK;
+
+ class A {
+ String f(int code) {
+ switch (code) {
+ case OK:
+ return "ok";
+ default:
+ return "?";
+ }
+ }
+ }
+ """, """
+ package p;
+
+ import q.Codes;
+
+ class A {
+ String f(int code) {
+ switch (code) {
+ case Codes.OK:
+ return "ok";
+ default:
+ return "?";
+ }
+ }
+ }
+ """);
+ }
+
+ @Test
+ void localVariableHidesTheImport() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.lang.Math.PI;
+
+ class A {
+ double f() {
+ double PI = 3;
+ return PI;
+ }
+
+ double g() {
+ return PI;
+ }
+ }
+ """, """
+ package p;
+
+ class A {
+ double f() {
+ double PI = 3;
+ return PI;
+ }
+
+ double g() {
+ return Math.PI;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void variableNamedLikeAnImportedMethodIsNotAUse() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.lang.Math.max;
+
+ class A {
+ int f(int a, int b) {
+ int max = max(a, b);
+ return max;
+ }
+ }
+ """, """
+ package p;
+
+ class A {
+ int f(int a, int b) {
+ int max = Math.max(a, b);
+ return max;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void methodOfTheClassHidesTheImport() throws IOException {
+ // JLS 15.12.1: a method of an enclosing class hides a static import of the same name, so the import is unused
+ assertReplaced("""
+ package p;
+
+ import static java.util.Objects.isNull;
+
+ class A {
+ boolean isNull(Object o) {
+ return o == null;
+ }
+
+ boolean f(Object o) {
+ return isNull(o);
+ }
+ }
+ """, """
+ package p;
+
+ class A {
+ boolean isNull(Object o) {
+ return o == null;
+ }
+
+ boolean f(Object o) {
+ return isNull(o);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void inheritedMethodHidesTheImport() throws IOException {
+ source("q/Base.java", """
+ package q;
+
+ public class Base {
+ protected static void check(boolean condition) {}
+ }
+ """);
+ source("q/Checks.java", """
+ package q;
+
+ public final class Checks {
+ public static void check(boolean condition) {}
+ }
+ """);
+ assertReplaced("""
+ package p;
+
+ import static q.Checks.check;
+
+ import q.Base;
+
+ class A extends Base {
+ void f() {
+ check(true);
+ }
+ }
+ """, """
+ package p;
+
+ import q.Base;
+
+ class A extends Base {
+ void f() {
+ check(true);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void unresolvableSupertypeKeepsTheImport() throws IOException {
+ // the missing supertype could declare a requireNonNull method that hides the import
+ assertUnchangedWithoutCompiling("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ class A extends Missing {
+ Object f(Object o) {
+ return requireNonNull(o);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void unresolvableImportIsLeftAlone() throws IOException {
+ assertUnchangedWithoutCompiling("""
+ package p;
+
+ import static org.junit.Assert.assertTrue;
+
+ class A {
+ void f() {
+ assertTrue(true);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void overloadsFromTwoImportedTypesAreLeftAlone() throws IOException {
+ // valueOf("1") is Integer.valueOf(String); picking the overload is left to the compiler
+ assertUnchanged("""
+ package p;
+
+ import static java.lang.Integer.valueOf;
+ import static java.lang.String.valueOf;
+
+ class A {
+ Object f() {
+ return valueOf("1");
+ }
+ }
+ """);
+ }
+
+ @Test
+ void secondTypeWithTheSameSimpleNameIsFullyQualified() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.sql.Date.valueOf;
+ import static java.util.Date.from;
+ import java.time.Instant;
+
+ class A {
+ long f(Instant instant) {
+ return valueOf("2020-01-01").getTime() + from(instant).getTime();
+ }
+ }
+ """, """
+ package p;
+
+ import java.time.Instant;
+ import java.sql.Date;
+
+ class A {
+ long f(Instant instant) {
+ return Date.valueOf("2020-01-01").getTime() + java.util.Date.from(instant).getTime();
+ }
+ }
+ """);
+ }
+
+ @Test
+ void typeDeclaredInTheFileForcesTheFullyQualifiedName() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ class A {
+ Object f(Object o) {
+ return requireNonNull(o);
+ }
+ }
+
+ class Objects {}
+ """, """
+ package p;
+
+ class A {
+ Object f(Object o) {
+ return java.util.Objects.requireNonNull(o);
+ }
+ }
+
+ class Objects {}
+ """);
+ }
+
+ @Test
+ void unusedTypeOfTheSamePackageIsShadowedByTheNewImport() throws IOException {
+ source("p/Objects.java", """
+ package p;
+
+ class Objects {}
+ """);
+ assertReplaced("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ class A {
+ Object f(Object o) {
+ return requireNonNull(o);
+ }
+ }
+ """, """
+ package p;
+
+ import java.util.Objects;
+
+ class A {
+ Object f(Object o) {
+ return Objects.requireNonNull(o);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void usedTypeOfTheSamePackageForcesTheFullyQualifiedName() throws IOException {
+ source("p/Objects.java", """
+ package p;
+
+ class Objects {}
+ """);
+ assertReplaced("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ class A {
+ Object f(Object o) {
+ return requireNonNull(new Objects());
+ }
+ }
+ """, """
+ package p;
+
+ class A {
+ Object f(Object o) {
+ return java.util.Objects.requireNonNull(new Objects());
+ }
+ }
+ """);
+ }
+
+ @Test
+ void staticImportOfANestedTypeBecomesARegularImport() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.util.Map.Entry;
+
+ import java.util.Map;
+
+ class A {
+ Entry first(Map map) {
+ return map.entrySet().iterator().next();
+ }
+ }
+ """, """
+ package p;
+
+ import java.util.Map;
+ import java.util.Map.Entry;
+
+ class A {
+ Entry first(Map map) {
+ return map.entrySet().iterator().next();
+ }
+ }
+ """);
+ }
+
+ @Test
+ void memberOfANestedTypeIsQualifiedThroughItsOuterType() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.util.Map.Entry.comparingByKey;
+
+ import java.util.Comparator;
+ import java.util.Map;
+
+ class A {
+ Comparator> byKey() {
+ return comparingByKey();
+ }
+ }
+ """, """
+ package p;
+
+ import java.util.Comparator;
+ import java.util.Map;
+
+ class A {
+ Comparator> byKey() {
+ return Map.Entry.comparingByKey();
+ }
+ }
+ """);
+ }
+
+ @Test
+ void interfaceConstant() throws IOException {
+ source("q/Limits.java", """
+ package q;
+
+ public interface Limits {
+ int MAX = 5;
+ }
+ """);
+ assertReplaced("""
+ package p;
+
+ import static q.Limits.MAX;
+
+ class A {
+ int f() {
+ return MAX;
+ }
+ }
+ """, """
+ package p;
+
+ import q.Limits;
+
+ class A {
+ int f() {
+ return Limits.MAX;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void constantInAnAnnotation() throws IOException {
+ source("q/Names.java", """
+ package q;
+
+ public final class Names {
+ public static final String UNCHECKED = "unchecked";
+ }
+ """);
+ assertReplaced("""
+ package p;
+
+ import static q.Names.UNCHECKED;
+
+ class A {
+ @SuppressWarnings(UNCHECKED)
+ void f() {}
+ }
+ """, """
+ package p;
+
+ import q.Names;
+
+ class A {
+ @SuppressWarnings(Names.UNCHECKED)
+ void f() {}
+ }
+ """);
+ }
+
+ @Test
+ void usesInLambdasAndAnonymousClasses() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ import java.util.function.Function;
+
+ class A {
+ Function f = o -> requireNonNull(o);
+ Runnable r = new Runnable() {
+ @Override
+ public void run() {
+ requireNonNull(f);
+ }
+ };
+ }
+ """, """
+ package p;
+
+ import java.util.function.Function;
+ import java.util.Objects;
+
+ class A {
+ Function f = o -> Objects.requireNonNull(o);
+ Runnable r = new Runnable() {
+ @Override
+ public void run() {
+ Objects.requireNonNull(f);
+ }
+ };
+ }
+ """);
+ }
+
+ @Test
+ void singleAndOnDemandImportOfTheSameType() throws IOException {
+ assertReplacedResource("java/replacestaticimports/SingleAndOnDemandUnformatted.test", "java/replacestaticimports/SingleAndOnDemandFormatted.test");
+ }
+
+ @Test
+ void unusedStaticImportIsRemoved() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ class A {}
+ """, """
+ package p;
+
+ class A {}
+ """);
+ }
+
+ @Test
+ void filesWithoutStaticImportsOrThatDoNotParseAreUnchanged() throws IOException {
+ assertUnchanged("""
+ package p;
+
+ import java.util.Objects;
+
+ class A {
+ Object f(Object o) {
+ return Objects.requireNonNull(o);
+ }
+ }
+ """);
+ assertUnchangedWithoutCompiling("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ class A {
+ Object f(Object o) {
+ return requireNonNull(o)
+ """);
+ }
+
+ @Test
+ void nullClasspathIsRejected() {
+ assertThrows(NullPointerException.class, () -> ReplaceStaticImportsStep.create(null, TestProvisioner.mavenCentral()));
+ }
+
+ @Test
+ void enumLabelOfASwitchOnAnotherTypeIsAUse() throws IOException {
+ // Java 21 allows enum constants as labels of a switch on any type; there, the label is an ordinary name
+ String before = """
+ package p;
+
+ import static java.util.concurrent.TimeUnit.SECONDS;
+
+ class A {
+ String f(Object o) {
+ return switch (o) {
+ case SECONDS -> "s";
+ default -> "?";
+ };
+ }
+ }
+ """;
+ String after = """
+ package p;
+
+ import java.util.concurrent.TimeUnit;
+
+ class A {
+ String f(Object o) {
+ return switch (o) {
+ case TimeUnit.SECONDS -> "s";
+ default -> "?";
+ };
+ }
+ }
+ """;
+ inASourceDirectory(before);
+ StepHarness.forStep(step()).test(before, after);
+ if (Runtime.version().feature() >= 21) {
+ assertCompiles(before);
+ assertCompiles(after);
+ }
+ }
+
+ @Test
+ void staticInterfaceMethodsAreNotInherited() throws IOException {
+ // JLS 8.4.8: Comparator.comparing is not a member of a class implementing Comparator, so it comes from the import
+ assertReplaced("""
+ package p;
+
+ import static java.util.Comparator.comparing;
+
+ import java.util.Comparator;
+
+ class ByLength implements Comparator {
+ public int compare(String a, String b) {
+ return Integer.compare(a.length(), b.length());
+ }
+
+ Comparator natural() {
+ return comparing((String s) -> s);
+ }
+ }
+ """, """
+ package p;
+
+ import java.util.Comparator;
+
+ class ByLength implements Comparator {
+ public int compare(String a, String b) {
+ return Integer.compare(a.length(), b.length());
+ }
+
+ Comparator natural() {
+ return Comparator.comparing((String s) -> s);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void privateMethodOfTheSuperclassDoesNotHideTheImport() throws IOException {
+ source("q/PrivateBase.java", """
+ package q;
+
+ public class PrivateBase {
+ private static void check(boolean condition) {}
+ }
+ """);
+ source("q/Checks.java", """
+ package q;
+
+ public final class Checks {
+ public static void check(boolean condition) {}
+ }
+ """);
+ assertReplaced("""
+ package p;
+
+ import static q.Checks.check;
+
+ import q.PrivateBase;
+
+ class A extends PrivateBase {
+ void f() {
+ check(true);
+ }
+ }
+ """, """
+ package p;
+
+ import q.PrivateBase;
+ import q.Checks;
+
+ class A extends PrivateBase {
+ void f() {
+ Checks.check(true);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void inheritedMemberTypeWithTheSameNameForcesTheFullyQualifiedName() throws IOException {
+ source("q/BaseWithObjects.java", """
+ package q;
+
+ public class BaseWithObjects {
+ public static class Objects {}
+ }
+ """);
+ assertReplaced("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ import q.BaseWithObjects;
+
+ class A extends BaseWithObjects {
+ Object f(Object o) {
+ return requireNonNull(o);
+ }
+ }
+ """, """
+ package p;
+
+ import q.BaseWithObjects;
+
+ class A extends BaseWithObjects {
+ Object f(Object o) {
+ return java.util.Objects.requireNonNull(o);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void unresolvableAncestorOfASupertypeKeepsTheImport() throws IOException {
+ // JavaParser silently skips supertypes it cannot resolve, which could declare a requireNonNull method
+ source("q/Middle.java", """
+ package q;
+
+ public class Middle extends Missing {}
+ """);
+ assertUnchangedWithoutCompiling("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ import q.Middle;
+
+ class A extends Middle {
+ Object f(Object o) {
+ return requireNonNull(o);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void instanceOverloadOfTheImportedTypeKeepsTheImport() throws IOException {
+ // Mixed.foo("x") would pick the instance method foo(String), which does not compile in a static context
+ source("q/Mixed.java", """
+ package q;
+
+ public class Mixed {
+ public static String foo(Object o) {
+ return "static";
+ }
+
+ public String foo(String s) {
+ return "instance";
+ }
+ }
+ """);
+ assertUnchanged("""
+ package p;
+
+ import static q.Mixed.foo;
+
+ class A {
+ String f() {
+ return foo("x");
+ }
+ }
+ """);
+ }
+
+ @Test
+ void simpleNameThatTwoOnDemandImportsSupplyGetsItsOwnImport() throws IOException {
+ // List is both java.util.List and java.awt.List: a single-type import makes List.of unambiguous
+ assertReplacedResource("java/replacestaticimports/AmbiguousOnDemandUnformatted.test", "java/replacestaticimports/AmbiguousOnDemandFormatted.test");
+ }
+
+ @Test
+ void fieldUsedAsTheScopeOfAMethodReference() throws IOException {
+ source("q/Holder.java", """
+ package q;
+
+ import java.util.ArrayList;
+ import java.util.List;
+
+ public final class Holder {
+ public static final List NAMES = new ArrayList<>();
+ }
+ """);
+ assertReplaced("""
+ package p;
+
+ import static q.Holder.NAMES;
+
+ import java.util.function.Consumer;
+
+ class A {
+ Consumer adder = NAMES::add;
+ }
+ """, """
+ package p;
+
+ import java.util.function.Consumer;
+ import q.Holder;
+
+ class A {
+ Consumer adder = Holder.NAMES::add;
+ }
+ """);
+ }
+
+ @Test
+ void referenceInADocCommentKeepsTheImport() throws IOException {
+ assertUnchanged("""
+ package p;
+
+ import static java.util.concurrent.TimeUnit.SECONDS;
+
+ /** Gives up after a few {@link SECONDS}. */
+ class A {}
+ """);
+ }
+
+ @Test
+ void useInsideSpotlessOffKeepsTheImport() throws IOException {
+ // toggleOffOn() would restore the unqualified use, while the import would stay deleted
+ assertUnchanged("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ class A {
+ // spotless:off
+ Object f(Object o) { return requireNonNull(o); }
+ // spotless:on
+ }
+ """);
+ }
+
+ @Test
+ void unresolvableSingleImportOfTheSameNameKeepsTheOthers() throws IOException {
+ assertUnchangedWithoutCompiling(getTestResource("java/replacestaticimports/UnresolvableSingleImportOfTheSameName.test"));
+ }
+
+ @Test
+ void unresolvableOnDemandImportLeavesTheFileAlone() throws IOException {
+ // it could supply any name in the file
+ assertUnchangedWithoutCompiling(getTestResource("java/replacestaticimports/UnresolvableOnDemandImport.test"));
+ }
+
+ @Test
+ void nestedTypeOfThisFileIsQualifiedWithItsOwnName() throws IOException {
+ String before = """
+ package p;
+
+ import static p.A.Color.RED;
+
+ class A {
+ enum Color {
+ RED, GREEN
+ }
+
+ Color color = RED;
+ }
+ """;
+ // the type solver sees the file through the source directory, as it does in a real project
+ source("p/A.java", before);
+ assertReplaced(before, """
+ package p;
+
+ class A {
+ enum Color {
+ RED, GREEN
+ }
+
+ Color color = Color.RED;
+ }
+ """);
+ }
+
+ @Test
+ void memberTypeInheritedByTheImportedTypeKeepsTheImport() throws IOException {
+ // `import q.SubHolder.Kind;` would not compile: an import needs the canonical name, q.SuperHolder.Kind
+ source("q/SuperHolder.java", """
+ package q;
+
+ public class SuperHolder {
+ public static class Kind {}
+ }
+ """);
+ source("q/SubHolder.java", """
+ package q;
+
+ public class SubHolder extends SuperHolder {}
+ """);
+ assertUnchanged("""
+ package p;
+
+ import static q.SubHolder.Kind;
+
+ class A {
+ Kind kind;
+ }
+ """);
+ }
+
+ @Test
+ void fieldNamedLikeANestedTypeKeepsTheImport() throws IOException {
+ // JLS 6.5.2: in Outer.Inner.m(), Outer.Inner would be the field, not the nested class
+ source("q/Outer.java", """
+ package q;
+
+ public class Outer {
+ public static final int Inner = 0;
+
+ public static class Inner {
+ public static String m() {
+ return "m";
+ }
+ }
+ }
+ """);
+ assertUnchanged("""
+ package p;
+
+ import static q.Outer.Inner.m;
+
+ class A {
+ String s = m();
+ }
+ """);
+ }
+
+ @Test
+ void classWithLombokAnnotationsKeepsTheImport() throws IOException {
+ // Lombok adds members that JavaParser cannot see, and that could hide the import
+ assertUnchangedWithoutCompiling("""
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ import lombok.Data;
+
+ @Data
+ class A {
+ Object f(Object o) {
+ return requireNonNull(o);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void excludedImportsAreKept() throws IOException {
+ String before = """
+ package p;
+
+ import static java.lang.Math.max;
+ import static java.util.Objects.requireNonNull;
+
+ class A {
+ int f(Object o) {
+ requireNonNull(o);
+ return max(1, 2);
+ }
+ }
+ """;
+ String after = """
+ package p;
+
+ import static java.util.Objects.requireNonNull;
+
+ class A {
+ int f(Object o) {
+ requireNonNull(o);
+ return Math.max(1, 2);
+ }
+ }
+ """;
+ inASourceDirectory(before);
+ StepHarness.forStep(step("java.util.Objects.*")).test(before, after);
+ StepHarness.forStep(step("java.util.Objects.requireNonNull")).test(before, after);
+ StepHarness.forStep(step("java.util.Objects")).test(before, after);
+ StepHarness.forStep(step("java.util.Objects.*", "java.lang.Math.*")).testUnaffected(before);
+ assertCompiles(after);
+ }
+
+ @Test
+ void equality() throws IOException {
+ File jar = newFile("libs/a.jar");
+ Files.createDirectories(jar.getParentFile().toPath());
+ Files.write(jar.toPath(), new byte[]{1, 2, 3});
+ new SerializableEqualityTester() {
+ Set classpath = Set.of();
+ List excludes = List.of();
+
+ @Override
+ protected void setupTest(API api) {
+ api.areDifferentThan();
+ excludes = List.of("java.util.Objects.*");
+ api.areDifferentThan();
+ excludes = List.of("java.util.Objects.*", "java.lang.Math.max");
+ api.areDifferentThan();
+ classpath = Set.of(jar);
+ api.areDifferentThan();
+ }
+
+ @Override
+ protected Serializable create() {
+ return ReplaceStaticImportsStep.create(classpath, excludes, TestProvisioner.mavenCentral());
+ }
+ }.testEquals();
+ }
+
+ @Test
+ void equalityDependsOnTheContentOfTheJarsNotOnWhereTheyAre() throws IOException {
+ File here = newFile("here/lib.jar");
+ File there = newFile("there/lib.jar");
+ File other = newFile("other/lib.jar");
+ for (File jar : List.of(here, there, other)) {
+ Files.createDirectories(jar.getParentFile().toPath());
+ Files.write(jar.toPath(), new byte[]{jar == other ? (byte) 2 : (byte) 1});
+ }
+ assertEquals(ReplaceStaticImportsStep.create(Set.of(here), List.of("b.B.*", "a.A.*"), TestProvisioner.mavenCentral()),
+ ReplaceStaticImportsStep.create(Set.of(there), List.of("a.A.*", "b.B.*"), TestProvisioner.mavenCentral()));
+ assertNotEquals(ReplaceStaticImportsStep.create(Set.of(here), TestProvisioner.mavenCentral()),
+ ReplaceStaticImportsStep.create(Set.of(other), TestProvisioner.mavenCentral()));
+ }
+
+ @Test
+ void sameDeclarationReachedThroughTwoImportsIsQualifiedWithItsDeclaringType() throws IOException {
+ // like Mockito, which inherits any() from ArgumentMatchers: both imports reach the same method
+ source("q/Matchers.java", """
+ package q;
+
+ public class Matchers {
+ public static T any() {
+ return null;
+ }
+ }
+ """);
+ source("q/Mocks.java", """
+ package q;
+
+ public class Mocks extends Matchers {
+ public static T when(T call) {
+ return call;
+ }
+ }
+ """);
+ assertReplacedResource("java/replacestaticimports/SameDeclarationThroughTwoImportsUnformatted.test", "java/replacestaticimports/SameDeclarationThroughTwoImportsFormatted.test");
+ }
+
+ @Test
+ void trailingCommentGoesWithTheImport() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.util.Objects.requireNonNull; // NOPMD
+
+ class A {
+ Object f(Object o) {
+ return requireNonNull(o);
+ }
+ }
+ """, """
+ package p;
+
+ import java.util.Objects;
+
+ class A {
+ Object f(Object o) {
+ return Objects.requireNonNull(o);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void javaLangTypeThatAnInvisibleOnDemandImportCouldShadowIsFullyQualified() throws IOException {
+ // javac sees x.Math, the type solver does not: `Math.max` would be ambiguous, and an import of
+ // java.lang.Math would not last, because removeUnusedImports() deletes java.lang imports
+ setFile("javac-only/x/Math.java").toContent("package x;\n\npublic class Math {}\n");
+ assertReplacedResource("java/replacestaticimports/JavaLangWithInvisibleOnDemandCompetitorUnformatted.test", "java/replacestaticimports/JavaLangWithInvisibleOnDemandCompetitorFormatted.test");
+ }
+
+ @Test
+ void classHeaderIsOutsideTheScopeOfTheClassMembers() throws IOException {
+ // JLS 6.3: NAME in the annotation of Impl is the import, while NAME in its body is the field Impl inherits
+ source("p/Base.java", """
+ package p;
+
+ public class Base {
+ public static final String NAME = "base";
+ }
+ """);
+ source("p/Other.java", """
+ package p;
+
+ public final class Other {
+ public static final String NAME = "unchecked";
+ }
+ """);
+ assertReplaced("""
+ package q;
+
+ import static p.Other.NAME;
+
+ import p.Base;
+
+ @SuppressWarnings(NAME)
+ class Impl extends Base {
+ String name = NAME;
+ }
+ """, """
+ package q;
+
+ import p.Base;
+ import p.Other;
+
+ @SuppressWarnings(Other.NAME)
+ class Impl extends Base {
+ String name = NAME;
+ }
+ """);
+ }
+
+ @Test
+ void singleImportOfAFieldShadowsAnOnDemandOne() throws IOException {
+ source("p/A.java", """
+ package p;
+
+ public class A {
+ public static final String X = "A.X";
+
+ public static String a() {
+ return "a";
+ }
+ }
+ """);
+ source("p/B.java", """
+ package p;
+
+ public class B {
+ public static final String X = "B.X";
+ }
+ """);
+ assertReplacedResource("java/replacestaticimports/SingleImportOfAFieldShadowsOnDemandUnformatted.test", "java/replacestaticimports/SingleImportOfAFieldShadowsOnDemandFormatted.test");
+ }
+
+ @Test
+ void typeNamedBeforeSuperIsAType() throws IOException {
+ source("p/Registry.java", """
+ package p;
+
+ public final class Registry {
+ public interface Listener {
+ default int id() {
+ return 1;
+ }
+ }
+ }
+ """);
+ assertReplaced("""
+ package q;
+
+ import static p.Registry.Listener;
+
+ class Impl implements Listener {
+ public int id() {
+ return Listener.super.id() + 1;
+ }
+ }
+ """, """
+ package q;
+
+ import p.Registry.Listener;
+
+ class Impl implements Listener {
+ public int id() {
+ return Listener.super.id() + 1;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void excludedMemberKeepsTheOnDemandImportThatSuppliesIt() throws IOException {
+ String source = getTestResource("java/replacestaticimports/ExcludedMemberUsedThroughOnDemandImport.test");
+ inASourceDirectory(source);
+ StepHarness.forStep(step("java.util.concurrent.TimeUnit.SECONDS")).testUnaffected(source);
+ }
+
+ @Test
+ void nameSpelledWithAUnicodeEscapeKeepsTheImport() throws IOException {
+ // javac reads max as max, so the import is still in use
+ assertUnchanged("""
+ package p;
+
+ import static java.lang.Math.max;
+
+ class A {
+ int a = \\u006dax(1, 2);
+ }
+ """);
+ }
+
+ @Test
+ void newImportStartsALineWhenTheLastImportSharesItsLine() throws IOException {
+ assertReplaced("""
+ package p; import java.util.List; import static java.util.concurrent.TimeUnit.SECONDS; class A { Object f(List l) { return SECONDS; } }
+ """, """
+ package p; import java.util.List;
+ import java.util.concurrent.TimeUnit; class A { Object f(List l) { return TimeUnit.SECONDS; } }
+ """);
+ }
+
+ @Test
+ void editInsideASpotlessOffRegionLeavesTheFileAlone() throws IOException {
+ // the new import would go inside the region, and toggleOffOn() would throw it away
+ assertUnchanged("""
+ package p;
+
+ import static java.util.concurrent.TimeUnit.SECONDS;
+ import java.util.List; // spotless:off
+ // spotless:on
+
+ class A {
+ Object f(List l) {
+ return SECONDS;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void moduleInfoIsLeftAlone() throws IOException {
+ StepHarness.forStep(step()).testUnaffected("""
+ import static java.util.Map.Entry;
+
+ module m {
+ uses Entry;
+ }
+ """);
+ }
+
+ @Test
+ void patternVariableInAConditionalHidesTheImport() throws IOException {
+ // JavaParser does not see `out` in the then-operand, but javac does
+ assertUnchanged("""
+ package p;
+
+ import static java.lang.System.out;
+
+ import java.io.PrintStream;
+
+ class A {
+ PrintStream target(Object sink) {
+ return sink instanceof PrintStream out ? out : null;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void memberTypeInheritedFromASuperclassHidesTheNestedTypeOfThisFile() throws IOException {
+ // inside Worker, State is Thread.State, so the constant is qualified through Job
+ assertReplaced("""
+ package p;
+
+ import static p.Job.State.DONE;
+
+ public class Job {
+ enum State {
+ WAITING, DONE
+ }
+
+ volatile State state;
+
+ class Worker extends Thread {
+ public void run() {
+ state = DONE;
+ }
+ }
+ }
+ """, """
+ package p;
+
+ public class Job {
+ enum State {
+ WAITING, DONE
+ }
+
+ volatile State state;
+
+ class Worker extends Thread {
+ public void run() {
+ state = Job.State.DONE;
+ }
+ }
+ }
+ """);
+ }
+
+ @Test
+ void unresolvableImportOfTheSameSimpleNameForcesTheFullyQualifiedName() throws IOException {
+ // javac sees com.acme.forum.Thread, the type solver does not
+ setFile("javac-only/com/acme/forum/Thread.java").toContent("package com.acme.forum;\n\npublic class Thread {}\n");
+ assertReplaced("""
+ package p;
+
+ import static java.lang.Thread.sleep;
+
+ import com.acme.forum.Thread;
+
+ class A {
+ void f(Thread thread) throws InterruptedException {
+ sleep(10);
+ }
+ }
+ """, """
+ package p;
+
+ import com.acme.forum.Thread;
+
+ class A {
+ void f(Thread thread) throws InterruptedException {
+ java.lang.Thread.sleep(10);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void loopVariableIsNotInScopeAfterTheLoop() throws IOException {
+ // the last PI is the import, though JavaParser resolves it to the loop variable
+ assertUnchanged("""
+ package p;
+
+ import static java.lang.Math.PI;
+
+ class A {
+ double f(double[] xs) {
+ double s = 0;
+ for (double PI : xs) {
+ s += PI;
+ }
+ return s + PI;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void cloneIsNotAMemberOfAnInterface() throws IOException {
+ source("q/Copies.java", """
+ package q;
+
+ public final class Copies {
+ public static T clone(T value) {
+ return value;
+ }
+ }
+ """);
+ assertReplaced("""
+ package p;
+
+ import static q.Copies.clone;
+
+ public interface A {
+ default String copy(String s) {
+ return clone(s);
+ }
+ }
+ """, """
+ package p;
+
+ import q.Copies;
+
+ public interface A {
+ default String copy(String s) {
+ return Copies.clone(s);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void typeParameterShadowsTheSimpleName() throws IOException {
+ assertReplaced("""
+ package p;
+
+ import static java.lang.Math.max;
+
+ public class A {
+ int f(int a, int b) {
+ return max(a, b);
+ }
+ }
+ """, """
+ package p;
+
+ public class A {
+ int f(int a, int b) {
+ return java.lang.Math.max(a, b);
+ }
+ }
+ """);
+ }
+
+ @Test
+ void fieldHiddenByAPrivateFieldOnTheWayKeepsTheImport() throws IOException {
+ // Mid's private NAME hides Base.NAME, so A inherits neither and NAME is the import
+ source("q/Base.java", "package q;\n\npublic class Base {\n public static final String NAME = \"base\";\n}\n");
+ source("q/Mid.java", "package q;\n\npublic class Mid extends Base {\n private static final String NAME = \"mid\";\n}\n");
+ source("q/Names.java", "package q;\n\npublic final class Names {\n public static final String NAME = \"names\";\n}\n");
+ assertUnchanged("""
+ package p;
+
+ import static q.Names.NAME;
+
+ import q.Mid;
+
+ class A extends Mid {
+ String name() {
+ return NAME;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void stackOverflowInJavaParserLeavesTheFileAlone() throws IOException {
+ assertUnchanged("""
+ package p;
+
+ import static p.A.Color;
+ import static p.A.Color.RED;
+
+ public class A {
+ enum Color {
+ RED, GREEN
+ }
+ }
+
+ class B {
+ Object f() {
+ return RED;
+ }
+ }
+ """);
+ }
+
+ @Test
+ void enumSwitchWhoseSelectorJavaParserCannotTypeKeepsTheImport() throws IOException {
+ // a qualified label would only compile from Java 21 on
+ assertUnchanged("""
+ package p;
+
+ import static java.util.concurrent.TimeUnit.SECONDS;
+
+ import java.util.Collections;
+ import java.util.List;
+ import java.util.concurrent.TimeUnit;
+
+ class A {
+ int f(List units) {
+ switch (Collections.max(units)) {
+ case SECONDS:
+ return 1;
+ default:
+ return 0;
+ }
+ }
+ }
+ """);
+ }
+
+ @Test
+ void classInTwoJarsKeepsTheImport() throws IOException {
+ // only version 2 of lib.Base has describe(Object), which hides the import: the compiler may see either version
+ File one = jar("lib-1", "lib/Base.java", "package lib;\n\npublic class Base {}\n");
+ File two = jar("lib-2", "lib/Base.java", "package lib;\n\npublic class Base {\n public String describe(Object o) {\n return \"base\";\n }\n}\n");
+ source("q/Util.java", """
+ package q;
+
+ public final class Util {
+ public static String describe(Object o) {
+ return "util";
+ }
+ }
+ """);
+ String source = """
+ package p;
+
+ import static q.Util.describe;
+
+ import lib.Base;
+
+ class A extends Base {
+ String run() {
+ return describe(this);
+ }
+ }
+ """;
+ inASourceDirectory(source);
+ StepHarness.forStep(ReplaceStaticImportsStep.create(Set.of(newFile("src"), one, two), TestProvisioner.mavenCentral())).testUnaffected(source);
+ }
+}