boolean (@NotNull PsiJavaFile file, @NotNull PsiClass refClass, boolean forceReimport) { JavaPsiFacade facade = JavaPsiFacade.getInstance(file.getProject()); PsiElementFactory factory = facade.getElementFactory(); PsiResolveHelper helper = facade.getResolveHelper(); String className = refClass.getQualifiedName(); if (className == null) return true; if (!ImportFilter.shouldImport(file, className)) { return false; } String packageName = getPackageOrClassName(className); String shortName = PsiNameHelper.getShortClassName(className); PsiImportStatement unusedSingleImport = findUnusedSingleImport(file, shortName, className); if (unusedSingleImport != null) { unusedSingleImport.delete(); } if (!forceReimport) { PsiClass conflictSingleRef = findSingleImportByShortName(file, shortName); if (conflictSingleRef != null) { return className.equals(conflictSingleRef.getQualifiedName()); } } PsiClass curRefClass = helper.resolveReferencedClass(shortName, file); if (file.getManager().areElementsEquivalent(refClass, curRefClass)) { return true; } boolean useOnDemand = !packageName.isEmpty(); PsiElement conflictPackageRef = findImportOnDemand(file, packageName); if (conflictPackageRef != null) { useOnDemand = false; } List<PsiClass> classesToReimport = new ArrayList<>(); List<PsiJavaCodeReferenceElement> importRefs = getImportsFromPackage(file, packageName); if (useOnDemand){ if (mySettings.USE_SINGLE_CLASS_IMPORTS && importRefs.size() + 1 < mySettings.CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND && !mySettings.PACKAGES_TO_USE_IMPORT_ON_DEMAND.contains(packageName)) { useOnDemand = false; } // the name of class we try to import is the same as of the class defined in this package if (containsInCurrentPackage(file, curRefClass)) { useOnDemand = true; } // check conflicts if (useOnDemand){ PsiElement[] onDemandRefs = file.getOnDemandImports(true, true); List<String> refTexts = new ArrayList<>(onDemandRefs.length); for (PsiElement ref : onDemandRefs) { String refName = ref instanceof PsiClass psiClass ? psiClass.getQualifiedName() : ((PsiPackage)ref).getQualifiedName(); refTexts.add(refName); } calcClassesToReimport(file, facade, helper, packageName, refTexts, classesToReimport); } } if (useOnDemand && refClass.getContainingClass() != null && mySettings.isInsertInnerClassImportsFor(PsiNameHelper.getShortClassName(className)) && containsInCurrentPackage(file, curRefClass)) { return false; } if (curRefClass != null) { if (!classesToReimport.isEmpty()) { return false; } else { useOnDemand = false; } } try { PsiImportList importList = file.getImportList(); assert importList != null : file; PsiImportStatement statement = useOnDemand ? factory.createImportStatementOnDemand(packageName) : factory.createImportStatement(refClass); importList.add(statement); if (useOnDemand) { for (PsiJavaCodeReferenceElement ref : importRefs) { if (ref.getParent() instanceof PsiImportStatement importStatement) { if (!ref.isValid()) continue; // todo[dsl] Q? if (importStatement.isForeignFileImport()) { // we should not optimize imports from include files continue; } classesToReimport.add((PsiClass)ref.resolve()); importStatement.delete(); } else { LOG.error("Expected import statement but got: "+ref.getParent()); } } } for (PsiClass aClass : classesToReimport) { if (aClass != null) { addImport(file, aClass, true); } } } catch(IncorrectOperationException e){ LOG.error(e); } return true; }