@NotNull
private static PsiElement findPackage(String qualifiedName, Project project) {
JavaPsiFacade javaFacade = JavaPsiFacade.getInstance(project);
PsiPackage javaFacadePackage = javaFacade.findPackage(qualifiedName);
assertNotNull("Package wasn't found: " + qualifiedName, javaFacadePackage);
return javaFacadePackage;
}
public static boolean processImplicitImports(
@NotNull PsiScopeProcessor processor,
ResolveState state,
PsiElement lastParent,
PsiElement place,
@NotNull GroovyFile file) {
JavaPsiFacade facade = JavaPsiFacade.getInstance(file.getProject());
final DelegatingScopeProcessor packageSkipper =
new DelegatingScopeProcessor(processor) {
@Override
public boolean execute(@NotNull PsiElement element, ResolveState state) {
if (element instanceof PsiPackage) return true;
return super.execute(element, state);
}
};
for (final String implicitlyImported : getImplicitlyImportedPackages(file)) {
PsiPackage aPackage = facade.findPackage(implicitlyImported);
if (aPackage == null) continue;
if (!aPackage.processDeclarations(packageSkipper, state, lastParent, place)) {
return false;
}
}
GroovyPsiManager groovyPsiManager = GroovyPsiManager.getInstance(file.getProject());
for (String implicitlyImportedClass : GroovyFileBase.IMPLICITLY_IMPORTED_CLASSES) {
PsiClass clazz =
groovyPsiManager.findClassWithCache(implicitlyImportedClass, file.getResolveScope());
if (clazz != null && !ResolveUtil.processElement(processor, clazz, state)) return false;
}
return true;
}
public static boolean hasJavaLangImportConflict(String fqName, PsiJavaFile file) {
final String shortName = ClassUtil.extractClassName(fqName);
final String packageName = ClassUtil.extractPackageName(fqName);
if (HardcodedMethodConstants.JAVA_LANG.equals(packageName)) {
return false;
}
final Project project = file.getProject();
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiPackage javaLangPackage = psiFacade.findPackage(HardcodedMethodConstants.JAVA_LANG);
if (javaLangPackage == null) {
return false;
}
return javaLangPackage.containsClassNamed(shortName);
}
public static boolean hasDefaultImportConflict(String fqName, PsiJavaFile file) {
final String shortName = ClassUtil.extractClassName(fqName);
final String packageName = ClassUtil.extractPackageName(fqName);
final String filePackageName = file.getPackageName();
if (filePackageName.equals(packageName)) {
return false;
}
final Project project = file.getProject();
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiPackage filePackage = psiFacade.findPackage(filePackageName);
if (filePackage == null) {
return false;
}
return filePackage.containsClassNamed(shortName);
}
public static boolean hasDefaultImportConflict(String fqName, PsiJavaFile file) {
final String shortName = ClassUtil.extractClassName(fqName);
final String packageName = ClassUtil.extractPackageName(fqName);
final String filePackageName = file.getPackageName();
if (filePackageName.equals(packageName)) {
return false;
}
final Project project = file.getProject();
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiPackage filePackage = psiFacade.findPackage(filePackageName);
if (filePackage == null) {
return false;
}
final PsiClass[] classes = filePackage.getClasses();
for (PsiClass aClass : classes) {
final String className = aClass.getName();
if (shortName.equals(className)) {
return true;
}
}
return false;
}
public static PsiElement getUpperScope(final PsiElement element) {
if (element instanceof PsiPackage) {
return ((PsiPackage) element).getParentPackage();
}
if (element instanceof PbFile) {
JavaPsiFacade facade = JavaPsiFacade.getInstance(element.getManager().getProject());
return facade.findPackage(((PbFile) element).getPackageName());
}
if (element instanceof PbPsiElement) {
PbPsiElement scope = (PbPsiElement) element.getParent();
while (scope != null && !(scope instanceof PbFile) && !(scope instanceof PbBlock)) {
scope = (PbPsiElement) scope.getParent();
}
/* // TC: This seems to skip from message block scope to package scope, preventing finding other messages
defined in the same file. Commenting out for now, since I don't see a good reason for it.
if (scope instanceof PbFile) {
JavaPsiFacade facade = JavaPsiFacade.getInstance(scope.getManager().getProject());
return facade.findPackage(((PbFile) scope).getPackageName());
}*/
return scope;
}
assert false;
return null;
}
/**
* Adds import if it is needed.
*
* @return false when the FQ-name have to be used in code (e.g. when conflicting imports already
* exist)
*/
public boolean addImport(@NotNull PsiJavaFile file, @NotNull PsiClass refClass) {
final JavaPsiFacade facade = JavaPsiFacade.getInstance(file.getProject());
PsiElementFactory factory = facade.getElementFactory();
PsiResolveHelper helper = facade.getResolveHelper();
String className = refClass.getQualifiedName();
if (className == null) return true;
String packageName = getPackageOrClassName(className);
String shortName = PsiNameHelper.getShortClassName(className);
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 = true;
if (packageName.length() == 0) {
useOnDemand = false;
}
PsiElement conflictPackageRef = findImportOnDemand(file, packageName);
if (conflictPackageRef != null) {
useOnDemand = false;
}
List<PsiElement> classesToReimport = new ArrayList<PsiElement>();
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;
}
// name of class we try to import is the same as of the class defined in this file
if (curRefClass != null) {
useOnDemand = true;
}
// check conflicts
if (useOnDemand) {
PsiElement[] onDemandRefs = file.getOnDemandImports(false, true);
if (onDemandRefs.length > 0) {
PsiPackage aPackage = facade.findPackage(packageName);
if (aPackage != null) {
PsiDirectory[] dirs = aPackage.getDirectories();
for (PsiDirectory dir : dirs) {
PsiFile[] files = dir.getFiles(); // do not iterate classes - too slow when not loaded
for (PsiFile aFile : files) {
if (aFile instanceof PsiJavaFile) {
String name = aFile.getVirtualFile().getNameWithoutExtension();
for (PsiElement ref : onDemandRefs) {
String refName =
ref instanceof PsiClass
? ((PsiClass) ref).getQualifiedName()
: ((PsiPackage) ref).getQualifiedName();
String conflictClassName = refName + "." + name;
GlobalSearchScope resolveScope = file.getResolveScope();
PsiClass conflictClass = facade.findClass(conflictClassName, resolveScope);
if (conflictClass != null && helper.isAccessible(conflictClass, file, null)) {
String conflictClassName2 = aPackage.getQualifiedName() + "." + name;
PsiClass conflictClass2 = facade.findClass(conflictClassName2, resolveScope);
if (conflictClass2 != null
&& helper.isAccessible(conflictClass2, file, null)) {
if (ReferencesSearch.search(
conflictClass, new LocalSearchScope(file), false)
.findFirst()
!= null) {
classesToReimport.add(conflictClass);
}
}
}
}
}
}
}
}
}
}
}
try {
PsiImportList importList = file.getImportList();
PsiImportStatement statement;
if (useOnDemand) {
statement = factory.createImportStatementOnDemand(packageName);
} else {
statement = factory.createImportStatement(refClass);
}
importList.add(statement);
if (useOnDemand) {
for (PsiJavaCodeReferenceElement ref : importRefs) {
LOG.assertTrue(ref.getParent() instanceof PsiImportStatement);
if (!ref.isValid()) continue; // todo[dsl] Q?
classesToReimport.add(ref.resolve());
PsiImportStatement importStatement = (PsiImportStatement) ref.getParent();
importStatement.delete();
}
}
for (PsiElement aClassesToReimport : classesToReimport) {
PsiClass aClass = (PsiClass) aClassesToReimport;
if (aClass != null) {
addImport(file, aClass);
}
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
return true;
}
@NotNull
private PsiElement findPackage(String qualifiedName) {
JavaPsiFacade javaFacade = JavaPsiFacade.getInstance(getProject());
return javaFacade.findPackage(qualifiedName);
}