@Override
public void visitReferenceElement(PsiJavaCodeReferenceElement reference) {
super.visitReferenceElement(reference);
if (referenceFound) {
return;
}
final String text = reference.getText();
if (text.indexOf((int) '.') >= 0 || !name.equals(text)) {
return;
}
final PsiElement element = reference.resolve();
if (!(element instanceof PsiClass) || element instanceof PsiTypeParameter) {
return;
}
final PsiClass aClass = (PsiClass) element;
final String testClassName = aClass.getName();
final String testClassQualifiedName = aClass.getQualifiedName();
if (testClassQualifiedName == null
|| testClassName == null
|| testClassQualifiedName.equals(fullyQualifiedName)
|| !testClassName.equals(name)) {
return;
}
referenceFound = true;
}
/**
* The parameter <code>allowIndirect</code> determines if the method should look for indirect
* annotations, i.e. annotations which have themselves been annotated by the supplied annotation
* name. Currently, this only allows one level of indirection and returns an array of
* [base-annotation, indirect annotation]
*
* <p>The <code>annotationName</code> parameter is a pair of the target annotation class' fully
* qualified name as a String and as a Set. This is done for performance reasons because the Set
* is required by the {@link com.intellij.codeInsight.AnnotationUtil} utility class and allows to
* avoid unnecessary object constructions.
*/
public static PsiAnnotation[] getAnnotationsFromImpl(
PsiModifierListOwner owner,
Pair<String, ? extends Set<String>> annotationName,
boolean allowIndirect,
boolean inHierarchy) {
final PsiAnnotation directAnnotation =
inHierarchy
? AnnotationUtil.findAnnotationInHierarchy(owner, annotationName.second)
: AnnotationUtil.findAnnotation(owner, annotationName.second);
if (directAnnotation != null) {
return new PsiAnnotation[] {directAnnotation};
}
if (allowIndirect) {
final PsiAnnotation[] annotations = getAnnotations(owner, inHierarchy);
for (PsiAnnotation annotation : annotations) {
PsiJavaCodeReferenceElement nameReference = annotation.getNameReferenceElement();
if (nameReference == null) continue;
PsiElement resolved = nameReference.resolve();
if (resolved instanceof PsiClass) {
final PsiAnnotation psiAnnotation =
AnnotationUtil.findAnnotationInHierarchy(
(PsiModifierListOwner) resolved, annotationName.second);
if (psiAnnotation != null) {
return new PsiAnnotation[] {psiAnnotation, annotation};
}
}
}
}
return PsiAnnotation.EMPTY_ARRAY;
}
@Override
public void removeRedundantImports(@NotNull final PsiJavaFile file)
throws IncorrectOperationException {
final Collection<PsiImportStatementBase> redundant = findRedundantImports(file);
if (redundant == null) return;
for (final PsiImportStatementBase importStatement : redundant) {
final PsiJavaCodeReferenceElement ref = importStatement.getImportReference();
// Do not remove non-resolving refs
if (ref == null || ref.resolve() == null) {
continue;
}
importStatement.delete();
}
}
@Override
public void visitReferenceElement(PsiJavaCodeReferenceElement reference) {
if (referenceFound) {
return;
}
super.visitReferenceElement(reference);
if (reference.isQualified()) {
return;
}
final PsiElement target = reference.resolve();
for (PsiMember member : members) {
if (member.equals(target)) {
referenceFound = true;
return;
}
}
}
/**
* @param strict if strict is true this method checks if the conflicting class which is imported
* is actually used in the file. If it isn't the on demand import can be overridden with an
* exact import for the fqName without breaking stuff.
*/
private static boolean hasOnDemandImportConflict(
@NotNull String fqName, @NotNull PsiJavaFile file, boolean strict) {
final PsiImportList imports = file.getImportList();
if (imports == null) {
return false;
}
final PsiImportStatement[] importStatements = imports.getImportStatements();
final String shortName = ClassUtil.extractClassName(fqName);
final String packageName = ClassUtil.extractPackageName(fqName);
for (final PsiImportStatement importStatement : importStatements) {
if (!importStatement.isOnDemand()) {
continue;
}
final PsiJavaCodeReferenceElement importReference = importStatement.getImportReference();
if (importReference == null) {
continue;
}
final String packageText = importReference.getText();
if (packageText.equals(packageName)) {
continue;
}
final PsiElement element = importReference.resolve();
if (element == null || !(element instanceof PsiPackage)) {
continue;
}
final PsiPackage aPackage = (PsiPackage) element;
final PsiClass[] classes = aPackage.getClasses();
for (final PsiClass aClass : classes) {
final String className = aClass.getName();
if (!shortName.equals(className)) {
continue;
}
if (!strict) {
return true;
}
final String qualifiedClassName = aClass.getQualifiedName();
if (qualifiedClassName == null || fqName.equals(qualifiedClassName)) {
continue;
}
return containsReferenceToConflictingClass(file, qualifiedClassName);
}
}
return hasJavaLangImportConflict(fqName, file);
}
static AllowedValues getAllowedValues(
@NotNull PsiModifierListOwner element, PsiType type, Set<PsiClass> visited) {
PsiAnnotation[] annotations = AnnotationUtil.getAllAnnotations(element, true, null);
for (PsiAnnotation annotation : annotations) {
AllowedValues values;
if (type != null && MagicConstant.class.getName().equals(annotation.getQualifiedName())) {
// PsiAnnotation magic = AnnotationUtil.findAnnotationInHierarchy(element,
// Collections.singleton(MagicConstant.class.getName()));
values = getAllowedValuesFromMagic(element, type, annotation);
if (values != null) return values;
}
PsiJavaCodeReferenceElement ref = annotation.getNameReferenceElement();
PsiElement resolved = ref == null ? null : ref.resolve();
if (!(resolved instanceof PsiClass) || !((PsiClass) resolved).isAnnotationType()) continue;
PsiClass aClass = (PsiClass) resolved;
if (visited == null) visited = new THashSet<PsiClass>();
if (!visited.add(aClass)) continue;
values = getAllowedValues(aClass, type, visited);
if (values != null) return values;
}
return parseBeanInfo(element);
}
