public static boolean treeWalkUp(PsiElement place, PsiScopeProcessor processor) {
PsiElement lastParent = null;
PsiElement run = place;
while (run != null) {
if (!run.processDeclarations(processor, ResolveState.initial(), lastParent, place))
return false;
lastParent = run;
run = run.getContext(); // same as getParent
}
return true;
}
private void getVariantsFromQualifier(@NotNull GrExpression qualifier) {
Project project = qualifier.getProject();
PsiType qualifierType = qualifier.getType();
final ResolveState state = ResolveState.initial();
if (qualifierType == null || qualifierType == PsiType.VOID) {
if (qualifier instanceof GrReferenceExpression) {
PsiElement resolved = ((GrReferenceExpression) qualifier).resolve();
if (resolved instanceof PsiPackage || resolved instanceof PsiVariable) {
resolved.processDeclarations(myProcessor, state, null, myRefExpr);
return;
}
}
getVariantsFromQualifierType(TypesUtil.getJavaLangObject(qualifier), project);
} else if (qualifierType instanceof PsiIntersectionType) {
for (PsiType conjunct : ((PsiIntersectionType) qualifierType).getConjuncts()) {
getVariantsFromQualifierType(conjunct, project);
}
} else if (qualifierType instanceof GrTraitType) {
GrTypeDefinition definition = ((GrTraitType) qualifierType).getMockTypeDefinition();
if (definition != null) {
PsiClassType classType = JavaPsiFacade.getElementFactory(project).createType(definition);
getVariantsFromQualifierType(classType, project);
} else {
getVariantsFromQualifierType(((GrTraitType) qualifierType).getExprType(), project);
for (PsiClassType traitType : ((GrTraitType) qualifierType).getTraitTypes()) {
getVariantsFromQualifierType(traitType, project);
}
}
} else {
getVariantsFromQualifierType(qualifierType, project);
if (qualifier instanceof GrReferenceExpression
&& !PsiUtil.isSuperReference(qualifier)
&& !PsiUtil.isInstanceThisRef(qualifier)) {
PsiElement resolved = ((GrReferenceExpression) qualifier).resolve();
if (resolved instanceof PsiClass) { // //omitted .class
GlobalSearchScope scope = myRefExpr.getResolveScope();
PsiClass javaLangClass = PsiUtil.getJavaLangClass(resolved, scope);
if (javaLangClass != null) {
PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
PsiTypeParameter[] typeParameters = javaLangClass.getTypeParameters();
if (typeParameters.length == 1) {
substitutor = substitutor.put(typeParameters[0], qualifierType);
}
PsiType javaLangClassType =
JavaPsiFacade.getElementFactory(myRefExpr.getProject())
.createType(javaLangClass, substitutor);
ResolveUtil.processAllDeclarations(javaLangClassType, myProcessor, state, myRefExpr);
}
}
}
}
}
public static boolean treeWalkUp(
@Nullable PsiElement place, @NotNull PsiScopeProcessor processor) {
PsiElement lastParent = null;
PsiElement run = place;
while (run != null) {
if (place != run
&& !run.processDeclarations(processor, ResolveState.initial(), lastParent, place))
return false;
lastParent = run;
run = run.getParent();
}
return true;
}
public static boolean processChildren(
PsiElement element,
PsiScopeProcessor processor,
ResolveState substitutor,
PsiElement lastParent,
PsiElement place) {
PsiElement run = lastParent == null ? element.getLastChild() : lastParent.getPrevSibling();
while (run != null) {
if (PsiTreeUtil.findCommonParent(place, run) != run
&& !run.processDeclarations(processor, substitutor, null, place)) return false;
run = run.getPrevSibling();
}
return true;
}
@Override
public boolean processDeclarations(
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
PsiElement lastParent,
@NotNull PsiElement place) {
DotNetStatement[] statements = getStatements();
List<PsiElement> elements = new ArrayList<PsiElement>(statements.length);
for (DotNetStatement statement : statements) {
if (statement == lastParent) {
break;
}
elements.add(statement);
}
Collections.reverse(elements);
for (PsiElement dotNetStatement : elements) {
if (!dotNetStatement.processDeclarations(processor, state, lastParent, place)) {
return false;
}
}
return true;
}