private void getVariantsFromQualifierType(
@NotNull PsiType qualifierType, @NotNull Project project) {
final ResolveState state = ResolveState.initial();
if (qualifierType instanceof PsiClassType) {
PsiClassType.ClassResolveResult result = ((PsiClassType) qualifierType).resolveGenerics();
PsiClass qualifierClass = result.getElement();
if (qualifierClass != null) {
qualifierClass.processDeclarations(
myProcessor, state.put(PsiSubstitutor.KEY, result.getSubstitutor()), null, myRefExpr);
}
} else if (qualifierType instanceof PsiArrayType) {
final GrTypeDefinition arrayClass =
GroovyPsiManager.getInstance(project)
.getArrayClass(((PsiArrayType) qualifierType).getComponentType());
if (arrayClass != null) {
if (!arrayClass.processDeclarations(myProcessor, state, null, myRefExpr)) return;
}
} else if (qualifierType instanceof PsiIntersectionType) {
for (PsiType conjunct : ((PsiIntersectionType) qualifierType).getConjuncts()) {
getVariantsFromQualifierType(conjunct, project);
}
return;
}
ResolveUtil.processNonCodeMembers(qualifierType, myProcessor, myRefExpr, state);
}
private static boolean doProcessSingleStaticImport(
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
@NotNull String importedName,
@Nullable PsiElement lastParent,
@NotNull PsiElement place,
PsiClass clazz,
String refName) {
final String hintName = ResolveUtil.getNameHint(processor);
if (hintName == null || importedName.equals(hintName)) {
if (!clazz.processDeclarations(
new GrDelegatingScopeProcessorWithHints(processor, refName, null),
state,
lastParent,
place)) {
return false;
}
}
if (ResolveUtil.shouldProcessMethods(processor.getHint(ElementClassHint.KEY))) {
if (hintName == null
|| importedName.equals(GroovyPropertyUtils.getPropertyNameByGetterName(hintName, true))) {
if (!clazz.processDeclarations(
new StaticGetterProcessor(refName, processor), state, lastParent, place)) {
return false;
}
}
if (hintName == null
|| importedName.equals(GroovyPropertyUtils.getPropertyNameBySetterName(hintName))) {
if (!clazz.processDeclarations(
new StaticSetterProcessor(refName, processor), state, lastParent, place)) {
return false;
}
}
}
return true;
}
private boolean processDeclarationsForMultipleElements(
@NotNull final PsiScopeProcessor processor,
@Nullable PsiElement lastParent,
@NotNull PsiElement place,
@NotNull ResolveState state) {
GrCodeReferenceElement ref = getImportReference();
if (ref == null) return true;
if (isStatic()) {
final PsiElement resolved = ref.resolve();
if (resolved instanceof PsiClass) {
state = state.put(ClassHint.RESOLVE_CONTEXT, this);
final PsiClass clazz = (PsiClass) resolved;
for (final PsiScopeProcessor each : GroovyResolverProcessor.allProcessors(processor)) {
if (!clazz.processDeclarations(
new DelegatingScopeProcessor(each) {
@Override
public boolean execute(@NotNull PsiElement element, @NotNull ResolveState state) {
if (element instanceof PsiMember
&& ((PsiMember) element).hasModifierProperty(PsiModifier.STATIC)) {
return super.execute(element, state);
}
return true;
}
},
state,
lastParent,
place)) return false;
}
}
} else {
if (ResolveUtil.shouldProcessClasses(processor.getHint(ElementClassHint.KEY))) {
String qName = PsiUtil.getQualifiedReferenceText(ref);
if (qName != null) {
PsiPackage aPackage = JavaPsiFacade.getInstance(getProject()).findPackage(qName);
if (aPackage != null
&& !((GroovyFile) getContainingFile())
.getPackageName()
.equals(aPackage.getQualifiedName())) {
state = state.put(ClassHint.RESOLVE_CONTEXT, this);
if (!aPackage.processDeclarations(processor, state, lastParent, place)) return false;
}
}
}
}
return true;
}
