@NotNull
private static PsiClass[] getSupersInner(@NotNull PsiClass psiClass) {
PsiClassType[] extendsListTypes = psiClass.getExtendsListTypes();
PsiClassType[] implementsListTypes = psiClass.getImplementsListTypes();
if (psiClass.isInterface()) {
return resolveClassReferenceList(
extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), true);
}
if (psiClass instanceof PsiAnonymousClass) {
PsiAnonymousClass psiAnonymousClass = (PsiAnonymousClass) psiClass;
PsiClassType baseClassReference = psiAnonymousClass.getBaseClassType();
PsiClass baseClass = baseClassReference.resolve();
if (baseClass != null) {
if (baseClass.isInterface()) {
PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null
? new PsiClass[] {objectClass, baseClass}
: new PsiClass[] {baseClass};
}
return new PsiClass[] {baseClass};
}
PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY;
}
if (psiClass instanceof PsiTypeParameter) {
if (extendsListTypes.length == 0) {
final PsiClass objectClass =
JavaPsiFacade.getInstance(psiClass.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, psiClass.getResolveScope());
return objectClass != null ? new PsiClass[] {objectClass} : PsiClass.EMPTY_ARRAY;
}
return resolveClassReferenceList(
extendsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
}
PsiClass[] interfaces =
resolveClassReferenceList(
implementsListTypes, psiClass.getManager(), psiClass.getResolveScope(), false);
PsiClass superClass = getSuperClass(psiClass);
if (superClass == null) return interfaces;
PsiClass[] types = new PsiClass[interfaces.length + 1];
types[0] = superClass;
System.arraycopy(interfaces, 0, types, 1, interfaces.length);
return types;
}
@NotNull
private static PsiClass[] resolveClassReferenceList(
@NotNull PsiClassType[] listOfTypes,
@NotNull PsiManager manager,
@NotNull GlobalSearchScope resolveScope,
boolean includeObject) {
PsiClass objectClass =
JavaPsiFacade.getInstance(manager.getProject())
.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
if (objectClass == null) includeObject = false;
if (listOfTypes.length == 0) {
if (includeObject) return new PsiClass[] {objectClass};
return PsiClass.EMPTY_ARRAY;
}
int referenceCount = listOfTypes.length;
if (includeObject) referenceCount++;
PsiClass[] resolved = new PsiClass[referenceCount];
int resolvedCount = 0;
if (includeObject) resolved[resolvedCount++] = objectClass;
for (PsiClassType reference : listOfTypes) {
PsiClass refResolved = reference.resolve();
if (refResolved != null) resolved[resolvedCount++] = refResolved;
}
if (resolvedCount < referenceCount) {
PsiClass[] shorter = new PsiClass[resolvedCount];
System.arraycopy(resolved, 0, shorter, 0, resolvedCount);
resolved = shorter;
}
return resolved;
}
@Nullable
private static PsiType getTypeFromMapAccess(@NotNull GrReferenceExpression ref) {
// map access
GrExpression qualifier = ref.getQualifierExpression();
if (qualifier instanceof GrReferenceExpression) {
if (((GrReferenceExpression) qualifier).resolve() instanceof PsiClass) return null;
}
if (qualifier != null) {
PsiType qType = qualifier.getType();
if (qType instanceof PsiClassType) {
PsiClassType.ClassResolveResult qResult = ((PsiClassType) qType).resolveGenerics();
PsiClass clazz = qResult.getElement();
if (clazz != null) {
PsiClass mapClass =
JavaPsiFacade.getInstance(ref.getProject())
.findClass(CommonClassNames.JAVA_UTIL_MAP, ref.getResolveScope());
if (mapClass != null && mapClass.getTypeParameters().length == 2) {
PsiSubstitutor substitutor =
TypeConversionUtil.getClassSubstitutor(mapClass, clazz, qResult.getSubstitutor());
if (substitutor != null) {
PsiType substituted = substitutor.substitute(mapClass.getTypeParameters()[1]);
if (substituted != null) {
return PsiImplUtil.normalizeWildcardTypeByPosition(substituted, ref);
}
}
}
}
}
}
return null;
}
@Nullable
public static PsiClass getSuperClass(@NotNull PsiClass psiClass) {
PsiManager manager = psiClass.getManager();
GlobalSearchScope resolveScope = psiClass.getResolveScope();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(manager.getProject());
if (psiClass.isInterface()) {
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
}
if (psiClass.isEnum()) {
return facade.findClass(CommonClassNames.JAVA_LANG_ENUM, resolveScope);
}
if (psiClass instanceof PsiAnonymousClass) {
PsiClassType baseClassReference = ((PsiAnonymousClass) psiClass).getBaseClassType();
PsiClass baseClass = baseClassReference.resolve();
if (baseClass == null || baseClass.isInterface())
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
return baseClass;
}
if (CommonClassNames.JAVA_LANG_OBJECT.equals(psiClass.getQualifiedName())) return null;
final PsiClassType[] referenceElements = psiClass.getExtendsListTypes();
if (referenceElements.length == 0)
return facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope);
PsiClass psiResoved = referenceElements[0].resolve();
return psiResoved == null
? facade.findClass(CommonClassNames.JAVA_LANG_OBJECT, resolveScope)
: psiResoved;
}
@NotNull
public static PsiClassType[] getExtendsListTypes(@NotNull PsiClass psiClass) {
if (psiClass.isEnum()) {
PsiClassType enumSuperType =
getEnumSuperType(
psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory());
return enumSuperType == null ? PsiClassType.EMPTY_ARRAY : new PsiClassType[] {enumSuperType};
}
if (psiClass.isAnnotationType()) {
return new PsiClassType[] {
getAnnotationSuperType(
psiClass, JavaPsiFacade.getInstance(psiClass.getProject()).getElementFactory())
};
}
final PsiReferenceList extendsList = psiClass.getExtendsList();
if (extendsList != null) {
return extendsList.getReferencedTypes();
}
return PsiClassType.EMPTY_ARRAY;
}
public static boolean isSourceLevelAccessible(
PsiElement context, PsiClass psiClass, final boolean pkgContext) {
if (!JavaPsiFacade.getInstance(psiClass.getProject())
.getResolveHelper()
.isAccessible(psiClass, context, null)) {
return false;
}
if (pkgContext) {
PsiClass topLevel = PsiUtil.getTopLevelClass(psiClass);
if (topLevel != null) {
String fqName = topLevel.getQualifiedName();
if (fqName != null && StringUtil.isEmpty(StringUtil.getPackageName(fqName))) {
return false;
}
}
}
return true;
}
public static boolean isMainOrPremainMethod(@NotNull PsiMethod method) {
if (!PsiType.VOID.equals(method.getReturnType())) return false;
String name = method.getName();
if (!("main".equals(name) || "premain".equals(name))) return false;
PsiElementFactory factory = JavaPsiFacade.getInstance(method.getProject()).getElementFactory();
MethodSignature signature = method.getSignature(PsiSubstitutor.EMPTY);
try {
MethodSignature main = createSignatureFromText(factory, "void main(String[] args);");
if (MethodSignatureUtil.areSignaturesEqual(signature, main)) return true;
MethodSignature premain =
createSignatureFromText(
factory, "void premain(String args, java.lang.instrument.Instrumentation i);");
if (MethodSignatureUtil.areSignaturesEqual(signature, premain)) return true;
} catch (IncorrectOperationException e) {
LOG.error(e);
}
return false;
}
@NotNull
public static SearchScope getClassUseScope(@NotNull PsiClass aClass) {
if (aClass instanceof PsiAnonymousClass) {
return new LocalSearchScope(aClass);
}
final GlobalSearchScope maximalUseScope = ResolveScopeManager.getElementUseScope(aClass);
PsiFile file = aClass.getContainingFile();
if (PsiImplUtil.isInServerPage(file)) return maximalUseScope;
final PsiClass containingClass = aClass.getContainingClass();
if (aClass.hasModifierProperty(PsiModifier.PUBLIC)
|| aClass.hasModifierProperty(PsiModifier.PROTECTED)) {
return containingClass == null ? maximalUseScope : containingClass.getUseScope();
} else if (aClass.hasModifierProperty(PsiModifier.PRIVATE)
|| aClass instanceof PsiTypeParameter) {
PsiClass topClass = PsiUtil.getTopLevelClass(aClass);
return new LocalSearchScope(topClass == null ? aClass.getContainingFile() : topClass);
} else {
PsiPackage aPackage = null;
if (file instanceof PsiJavaFile) {
aPackage =
JavaPsiFacade.getInstance(aClass.getProject())
.findPackage(((PsiJavaFile) file).getPackageName());
}
if (aPackage == null) {
PsiDirectory dir = file.getContainingDirectory();
if (dir != null) {
aPackage = JavaDirectoryService.getInstance().getPackage(dir);
}
}
if (aPackage != null) {
SearchScope scope = PackageScope.packageScope(aPackage, false);
scope = scope.intersectWith(maximalUseScope);
return scope;
}
return new LocalSearchScope(file);
}
}
private static PsiClassType getEnumSuperType(
@NotNull PsiClass psiClass, @NotNull PsiElementFactory factory) {
PsiClassType superType;
final PsiManager manager = psiClass.getManager();
final PsiClass enumClass =
JavaPsiFacade.getInstance(manager.getProject())
.findClass("java.lang.Enum", psiClass.getResolveScope());
if (enumClass == null) {
try {
superType = (PsiClassType) factory.createTypeFromText("java.lang.Enum", null);
} catch (IncorrectOperationException e) {
superType = null;
}
} else {
final PsiTypeParameter[] typeParameters = enumClass.getTypeParameters();
PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
if (typeParameters.length == 1) {
substitutor = substitutor.put(typeParameters[0], factory.createType(psiClass));
}
superType = new PsiImmediateClassType(enumClass, substitutor);
}
return superType;
}
public PsiPackage getPsiElement() {
final String qualifiedName = myData.getPackageName();
return qualifiedName != null
? JavaPsiFacade.getInstance(getProject()).findPackage(qualifiedName)
: null;
}
private static boolean processDeclarationsInClassNotCached(
@NotNull PsiClass aClass,
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
@Nullable Set<PsiClass> visited,
PsiElement last,
@NotNull PsiElement place,
boolean isRaw,
@NotNull LanguageLevel languageLevel) {
if (visited == null) visited = new THashSet<PsiClass>();
if (!visited.add(aClass)) return true;
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
final NameHint nameHint = processor.getHint(NameHint.KEY);
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.FIELD)) {
if (nameHint != null) {
final PsiField fieldByName = aClass.findFieldByName(nameHint.getName(state), false);
if (fieldByName != null && !processor.execute(fieldByName, state)) return false;
} else {
final PsiField[] fields = aClass.getFields();
for (final PsiField field : fields) {
if (!processor.execute(field, state)) return false;
}
}
}
PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory();
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.METHOD)) {
PsiSubstitutor baseSubstitutor = state.get(PsiSubstitutor.KEY);
final PsiMethod[] methods =
nameHint != null
? aClass.findMethodsByName(nameHint.getName(state), false)
: aClass.getMethods();
for (final PsiMethod method : methods) {
PsiSubstitutor finalSubstitutor = checkRaw(isRaw, factory, method, baseSubstitutor);
ResolveState methodState =
finalSubstitutor == baseSubstitutor
? state
: state.put(PsiSubstitutor.KEY, finalSubstitutor);
if (!processor.execute(method, methodState)) return false;
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
if (last != null && last.getParent() == aClass) {
// Parameters
final PsiTypeParameterList list = aClass.getTypeParameterList();
if (list != null
&& !list.processDeclarations(processor, ResolveState.initial(), last, place))
return false;
}
if (!(last instanceof PsiReferenceList) && !(last instanceof PsiModifierList)) {
// Inners
if (nameHint != null) {
final PsiClass inner = aClass.findInnerClassByName(nameHint.getName(state), false);
if (inner != null) {
if (!processor.execute(inner, state)) return false;
}
} else {
final PsiClass[] inners = aClass.getInnerClasses();
for (final PsiClass inner : inners) {
if (!processor.execute(inner, state)) return false;
}
}
}
}
return last instanceof PsiReferenceList
|| processSuperTypes(
aClass, processor, visited, last, place, state, isRaw, factory, languageLevel);
}
private static boolean processCachedMembersByName(
@NotNull PsiClass aClass,
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
@Nullable Set<PsiClass> visited,
PsiElement last,
@NotNull PsiElement place,
boolean isRaw,
@NotNull PsiSubstitutor substitutor,
@NotNull MembersMap value,
String name,
@NotNull LanguageLevel languageLevel) {
final ElementClassHint classHint = processor.getHint(ElementClassHint.KEY);
PsiElementFactory factory = JavaPsiFacade.getInstance(aClass.getProject()).getElementFactory();
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.FIELD)) {
final PsiField fieldByName = aClass.findFieldByName(name, false);
if (fieldByName != null) {
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
if (!processor.execute(fieldByName, state)) return false;
} else {
final Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allFieldsMap =
value.get(MemberType.FIELD);
final List<Pair<PsiMember, PsiSubstitutor>> list = allFieldsMap.get(name);
if (list != null) {
for (final Pair<PsiMember, PsiSubstitutor> candidate : list) {
PsiMember candidateField = candidate.getFirst();
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
candidateField.getContainingClass(),
candidate.getSecond(),
aClass,
substitutor,
factory,
languageLevel);
processor.handleEvent(
PsiScopeProcessor.Event.SET_DECLARATION_HOLDER,
candidateField.getContainingClass());
if (!processor.execute(candidateField, state.put(PsiSubstitutor.KEY, finalSubstitutor)))
return false;
}
}
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.CLASS)) {
if (last != null && last.getParent() == aClass) {
if (last instanceof PsiClass) {
if (!processor.execute(last, state)) return false;
}
// Parameters
final PsiTypeParameterList list = aClass.getTypeParameterList();
if (list != null && !list.processDeclarations(processor, state, last, place)) return false;
}
if (!(last instanceof PsiReferenceList)) {
final PsiClass classByName = aClass.findInnerClassByName(name, false);
if (classByName != null) {
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
if (!processor.execute(classByName, state)) return false;
} else {
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allClassesMap =
value.get(MemberType.CLASS);
List<Pair<PsiMember, PsiSubstitutor>> list = allClassesMap.get(name);
if (list != null) {
for (final Pair<PsiMember, PsiSubstitutor> candidate : list) {
PsiMember inner = candidate.getFirst();
PsiClass containingClass = inner.getContainingClass();
if (containingClass != null) {
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
containingClass,
candidate.getSecond(),
aClass,
substitutor,
factory,
languageLevel);
processor.handleEvent(
PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass);
if (!processor.execute(inner, state.put(PsiSubstitutor.KEY, finalSubstitutor)))
return false;
}
}
}
}
}
}
if (classHint == null || classHint.shouldProcess(ElementClassHint.DeclarationKind.METHOD)) {
if (processor instanceof MethodResolverProcessor) {
final MethodResolverProcessor methodResolverProcessor = (MethodResolverProcessor) processor;
if (methodResolverProcessor.isConstructor()) {
final PsiMethod[] constructors = aClass.getConstructors();
methodResolverProcessor.handleEvent(
PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, aClass);
for (PsiMethod constructor : constructors) {
if (!methodResolverProcessor.execute(constructor, state)) return false;
}
return true;
}
}
Map<String, List<Pair<PsiMember, PsiSubstitutor>>> allMethodsMap =
value.get(MemberType.METHOD);
List<Pair<PsiMember, PsiSubstitutor>> list = allMethodsMap.get(name);
if (list != null) {
for (final Pair<PsiMember, PsiSubstitutor> candidate : list) {
ProgressIndicatorProvider.checkCanceled();
PsiMethod candidateMethod = (PsiMethod) candidate.getFirst();
if (processor instanceof MethodResolverProcessor) {
if (candidateMethod.isConstructor()
!= ((MethodResolverProcessor) processor).isConstructor()) continue;
}
final PsiClass containingClass = candidateMethod.getContainingClass();
if (visited != null && visited.contains(candidateMethod.getContainingClass())) {
continue;
}
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
containingClass,
candidate.getSecond(),
aClass,
substitutor,
factory,
languageLevel);
finalSubstitutor = checkRaw(isRaw, factory, candidateMethod, finalSubstitutor);
processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, containingClass);
if (!processor.execute(candidateMethod, state.put(PsiSubstitutor.KEY, finalSubstitutor)))
return false;
}
if (visited != null) {
for (Pair<PsiMember, PsiSubstitutor> aList : list) {
visited.add(aList.getFirst().getContainingClass());
}
}
}
}
return true;
}
@Nullable
private PsiType getNominalTypeInner(@Nullable PsiElement resolved) {
if (resolved == null && !"class".equals(getReferenceName())) {
resolved = resolve();
}
if (resolved instanceof PsiClass) {
final PsiElementFactory factory = JavaPsiFacade.getInstance(getProject()).getElementFactory();
if (PsiUtil.isInstanceThisRef(this)) {
final PsiClassType categoryType = GdkMethodUtil.getCategoryType((PsiClass) resolved);
if (categoryType != null) {
return categoryType;
} else {
return factory.createType((PsiClass) resolved);
}
} else if (PsiUtil.isSuperReference(this)) {
PsiClass contextClass = PsiUtil.getContextClass(this);
if (GrTraitUtil.isTrait(contextClass)) {
PsiClassType[] extendsTypes = contextClass.getExtendsListTypes();
PsiClassType[] implementsTypes = contextClass.getImplementsListTypes();
PsiClassType[] superTypes =
ArrayUtil.mergeArrays(implementsTypes, extendsTypes, PsiClassType.ARRAY_FACTORY);
return PsiIntersectionType.createIntersection(ArrayUtil.reverseArray(superTypes));
}
return factory.createType((PsiClass) resolved);
}
if (getParent() instanceof GrReferenceExpression) {
return factory.createType((PsiClass) resolved);
} else {
return TypesUtil.createJavaLangClassType(
factory.createType((PsiClass) resolved), getProject(), getResolveScope());
}
}
if (resolved instanceof GrVariable) {
return ((GrVariable) resolved).getDeclaredType();
}
if (resolved instanceof PsiVariable) {
return ((PsiVariable) resolved).getType();
}
if (resolved instanceof PsiMethod) {
PsiMethod method = (PsiMethod) resolved;
if (PropertyUtil.isSimplePropertySetter(method)
&& !method.getName().equals(getReferenceName())) {
return method.getParameterList().getParameters()[0].getType();
}
// 'class' property with explicit generic
PsiClass containingClass = method.getContainingClass();
if (containingClass != null
&& CommonClassNames.JAVA_LANG_OBJECT.equals(containingClass.getQualifiedName())
&& "getClass".equals(method.getName())) {
return TypesUtil.createJavaLangClassType(
PsiImplUtil.getQualifierType(this), getProject(), getResolveScope());
}
return PsiUtil.getSmartReturnType(method);
}
if (resolved == null) {
final PsiType fromClassRef = getTypeFromClassRef(this);
if (fromClassRef != null) {
return fromClassRef;
}
final PsiType fromMapAccess = getTypeFromMapAccess(this);
if (fromMapAccess != null) {
return fromMapAccess;
}
final PsiType fromSpreadOperator = getTypeFromSpreadOperator(this);
if (fromSpreadOperator != null) {
return fromSpreadOperator;
}
}
return null;
}
@NotNull
private GroovyResolveResult[] resolveTypeOrPropertyInner() {
PsiElement nameElement = getReferenceNameElement();
String name = getReferenceName();
if (name == null || nameElement == null) return GroovyResolveResult.EMPTY_ARRAY;
IElementType nameType = nameElement.getNode().getElementType();
if (nameType == GroovyTokenTypes.kTHIS) {
GroovyResolveResult[] results = GrThisReferenceResolver.resolveThisExpression(this);
if (results != null) {
return results;
}
} else if (nameType == GroovyTokenTypes.kSUPER) {
GroovyResolveResult[] results = GrSuperReferenceResolver.resolveSuperExpression(this);
if (results != null) {
return results;
}
}
EnumSet<ClassHint.ResolveKind> kinds =
getParent() instanceof GrReferenceExpression
? ClassHint.RESOLVE_KINDS_CLASS_PACKAGE
: ClassHint.RESOLVE_KINDS_CLASS;
GroovyResolveResult[] classCandidates = null;
GrReferenceResolveRunner resolveRunner = new GrReferenceResolveRunner(this);
ResolverProcessor processor = new PropertyResolverProcessor(name, this);
resolveRunner.resolveImpl(processor);
final GroovyResolveResult[] fieldCandidates = processor.getCandidates();
if (hasAt()) {
return fieldCandidates;
}
boolean canBeClassOrPackage = ResolveUtil.canBeClassOrPackage(this);
if (canBeClassOrPackage && findClassOrPackageAtFirst()) {
ResolverProcessor classProcessor = new ClassResolverProcessor(name, this, kinds);
resolveRunner.resolveImpl(classProcessor);
classCandidates = classProcessor.getCandidates();
if (classCandidates.length > 0 && containsPackage(classCandidates)) {
final PsiElement firstNonReferenceExprParent =
PsiTreeUtil.skipParentsOfType(this, GrReferenceExpressionImpl.class);
final GrReferenceExpressionImpl topRef =
(GrReferenceExpressionImpl)
PsiTreeUtil.findFirstParent(
this,
new Condition<PsiElement>() {
@Override
public boolean value(PsiElement parent) {
return parent.getParent() == firstNonReferenceExprParent
&& parent instanceof GrReferenceExpressionImpl;
}
});
if (topRef != null) {
final String fqn = topRef.getTextSkipWhiteSpaceAndComments();
if (JavaPsiFacade.getInstance(getProject()).findClass(fqn, getResolveScope()) != null) {
return classCandidates;
}
}
}
}
// if reference expression is in class we need to return field instead of accessor method
for (GroovyResolveResult candidate : fieldCandidates) {
final PsiElement element = candidate.getElement();
if (element instanceof PsiField) {
final PsiClass containingClass = ((PsiField) element).getContainingClass();
if (containingClass != null && PsiUtil.getContextClass(this) == containingClass)
return fieldCandidates;
} else if (!(element instanceof GrBindingVariable)) {
return fieldCandidates;
}
}
if (classCandidates != null && classCandidates.length > 0) return classCandidates;
final boolean isLValue = PsiUtil.isLValue(this);
String[] accessorNames =
isLValue
? GroovyPropertyUtils.suggestSettersName(name)
: GroovyPropertyUtils.suggestGettersName(name);
List<GroovyResolveResult> accessorResults = new ArrayList<GroovyResolveResult>();
for (String accessorName : accessorNames) {
AccessorResolverProcessor accessorResolver =
new AccessorResolverProcessor(
accessorName,
name,
this,
!isLValue,
false,
PsiImplUtil.getQualifierType(this),
getTypeArguments());
resolveRunner.resolveImpl(accessorResolver);
final GroovyResolveResult[] candidates = accessorResolver.getCandidates();
// can be only one correct candidate or some incorrect
if (candidates.length == 1 && candidates[0].isStaticsOK() && candidates[0].isAccessible()) {
return candidates;
} else {
ContainerUtil.addAll(accessorResults, candidates);
}
}
final ArrayList<GroovyResolveResult> fieldList = ContainerUtil.newArrayList(fieldCandidates);
filterOutBindings(fieldList);
if (!fieldList.isEmpty()) {
return fieldList.toArray(new GroovyResolveResult[fieldList.size()]);
}
if (classCandidates == null && canBeClassOrPackage) {
ResolverProcessor classProcessor = new ClassResolverProcessor(name, this, kinds);
resolveRunner.resolveImpl(classProcessor);
classCandidates = classProcessor.getCandidates();
}
if (classCandidates != null && classCandidates.length > 0) return classCandidates;
if (!accessorResults.isEmpty()) return new GroovyResolveResult[] {accessorResults.get(0)};
return GroovyResolveResult.EMPTY_ARRAY;
}