public static boolean processDeclarationsInClass(
@NotNull PsiClass aClass,
@NotNull final PsiScopeProcessor processor,
@NotNull ResolveState state,
@Nullable Set<PsiClass> visited,
PsiElement last,
@NotNull PsiElement place,
boolean isRaw) {
if (last instanceof PsiTypeParameterList || last instanceof PsiModifierList) {
return true; // TypeParameterList and ModifierList do not see our declarations
}
if (visited != null && visited.contains(aClass)) return true;
PsiSubstitutor substitutor = state.get(PsiSubstitutor.KEY);
isRaw = isRaw || PsiUtil.isRawSubstitutor(aClass, substitutor);
ParameterizedCachedValue<MembersMap, PsiClass> cache =
getValues(aClass); // aClass.getUserData(MAP_IN_CLASS_KEY);
boolean upToDate = cache.hasUpToDateValue();
LanguageLevel languageLevel = PsiUtil.getLanguageLevel(place);
if (
/*true || */ upToDate) {
final NameHint nameHint = processor.getHint(NameHint.KEY);
if (nameHint != null) {
String name = nameHint.getName(state);
return processCachedMembersByName(
aClass,
processor,
state,
visited,
last,
place,
isRaw,
substitutor,
cache.getValue(aClass),
name,
languageLevel);
}
}
return processDeclarationsInClassNotCached(
aClass, processor, state, visited, last, place, isRaw, languageLevel);
}
private static MultiHostRegistrarImpl probeElementsUp(
@NotNull PsiElement element, @NotNull PsiFile hostPsiFile, boolean probeUp) {
PsiManager psiManager = hostPsiFile.getManager();
final Project project = psiManager.getProject();
InjectedLanguageManagerImpl injectedManager =
InjectedLanguageManagerImpl.getInstanceImpl(project);
if (injectedManager == null) {
return null; // for tests
}
MultiHostRegistrarImpl registrar = null;
PsiElement current = element;
nextParent:
while (current != null && current != hostPsiFile) {
ProgressManager.checkCanceled();
if ("EL".equals(current.getLanguage().getID())) break;
ParameterizedCachedValue<MultiHostRegistrarImpl, PsiElement> data =
current.getUserData(INJECTED_PSI);
if (data == null) {
registrar =
InjectedPsiCachedValueProvider.doCompute(
current, injectedManager, project, hostPsiFile);
} else {
registrar = data.getValue(current);
}
current = current.getParent(); // cache no injection for current
if (registrar != null) {
List<Pair<Place, PsiFile>> places = registrar.getResult();
// check that injections found intersect with queried element
TextRange elementRange = element.getTextRange();
for (Pair<Place, PsiFile> pair : places) {
Place place = pair.first;
for (PsiLanguageInjectionHost.Shred shred : place) {
if (shred.getHost().getTextRange().intersects(elementRange)) {
if (place.isValid()) break nextParent;
}
}
}
}
if (!probeUp) {
break;
}
}
if (probeUp) {
// cache only if we walked all parents
for (PsiElement e = element;
e != current && e != null && e != hostPsiFile;
e = e.getParent()) {
ProgressManager.checkCanceled();
if (registrar == null) {
e.putUserData(INJECTED_PSI, null);
} else {
ParameterizedCachedValue<MultiHostRegistrarImpl, PsiElement> cachedValue =
CachedValuesManager.getManager(project)
.createParameterizedCachedValue(INJECTED_PSI_PROVIDER, false);
CachedValueProvider.Result<MultiHostRegistrarImpl> result =
CachedValueProvider.Result.create(
registrar, PsiModificationTracker.MODIFICATION_COUNT, registrar);
((PsiParameterizedCachedValue<MultiHostRegistrarImpl, PsiElement>) cachedValue)
.setValue(result);
e.putUserData(INJECTED_PSI, cachedValue);
}
}
}
return registrar;
}
private static Map<String, List<Pair<PsiMember, PsiSubstitutor>>> getMap(
@NotNull PsiClass aClass, @NotNull MemberType type) {
ParameterizedCachedValue<MembersMap, PsiClass> value = getValues(aClass);
return value.getValue(aClass).get(type);
}