@Override
public boolean execute(@NotNull PsiElement element, @NotNull ResolveState state) {
if (element instanceof PsiMethod && ((PsiMethod) element).isConstructor()) return true;
if (element instanceof PsiNamedElement) {
PsiNamedElement namedElement = (PsiNamedElement) element;
boolean isAccessible = isAccessible(namedElement);
final PsiElement resolveContext = state.get(RESOLVE_CONTEXT);
final SpreadState spreadState = state.get(SpreadState.SPREAD_STATE);
boolean isStaticsOK =
isStaticsOK(namedElement, resolveContext, myParameters.getInvocationCount() <= 1);
PsiSubstitutor substitutor = state.get(PsiSubstitutor.KEY);
if (substitutor == null) substitutor = PsiSubstitutor.EMPTY;
if (element instanceof PsiMethod) {
substitutor =
mySubstitutorComputer.obtainSubstitutor(substitutor, (PsiMethod) element, state);
}
consume(
new GroovyResolveResultImpl(
namedElement, resolveContext, spreadState, substitutor, isAccessible, isStaticsOK));
}
return true;
}
@Override
public boolean execute(PsiElement element, ResolveState state) {
if (element instanceof PsiMethod || element instanceof PsiField) {
String propertyName;
PsiType type;
if (element instanceof PsiMethod) {
PsiMethod method = (PsiMethod) element;
if (!GroovyPropertyUtils.isSimplePropertySetter(method)) return true;
propertyName = GroovyPropertyUtils.getPropertyNameBySetter(method);
if (propertyName == null) return true;
type = method.getParameterList().getParameters()[0].getType();
} else {
type = ((PsiField) element).getType();
propertyName = ((PsiField) element).getName();
}
if (((PsiModifierListOwner) element).hasModifierProperty(PsiModifier.STATIC)) return true;
if (myResult.containsKey(propertyName) || propertyName.equals(METACLASS)) return true;
PsiSubstitutor substitutor = state.get(PsiSubstitutor.KEY);
if (substitutor != null) {
type = substitutor.substitute(type);
}
myResult.put(propertyName, new TypeCondition(type, element));
}
return true;
}
@Override
public boolean execute(@NotNull PsiElement element, @NotNull ResolveState state) {
if (element == member) {
subst.set(state.get(PsiSubstitutor.KEY));
}
return true;
}
@NotNull
private PsiSubstitutor inferSubstitutor(@NotNull PsiMethod method, @NotNull ResolveState state) {
PsiSubstitutor substitutor = state.get(PsiSubstitutor.KEY);
if (substitutor == null) substitutor = PsiSubstitutor.EMPTY;
return myByShape
? substitutor
: mySubstitutorComputer.obtainSubstitutor(substitutor, method, state);
}
public boolean satisfies(@NotNull PsiElement element, @NotNull ResolveState state) {
final String name = PsiUtilCore.getName(element);
if (StringUtil.isNotEmpty(name) && (myMatcher == null || myMatcher.value(name))) {
if (myFilter.isClassAcceptable(element.getClass())
&& myFilter.isAcceptable(
new CandidateInfo(element, state.get(PsiSubstitutor.KEY)), myElement)) {
return true;
}
}
return false;
}
@Override
public boolean execute(@NotNull PsiElement element, @NotNull ResolveState state) {
if (myStopExecuting) {
return false;
}
if (element instanceof PsiMethod) {
PsiMethod method = (PsiMethod) element;
if (method.isConstructor() != myIsConstructor) return true;
PsiSubstitutor substitutor = inferSubstitutor(method, state);
PsiElement resolveContext = state.get(RESOLVE_CONTEXT);
final SpreadState spreadState = state.get(SpreadState.SPREAD_STATE);
boolean isAccessible = isAccessible(method);
boolean isStaticsOK = isStaticsOK(method, resolveContext, false);
boolean isApplicable =
PsiUtil.isApplicable(myArgumentTypes, method, substitutor, myPlace, myByShape);
boolean isValidResult = isStaticsOK && isAccessible && isApplicable;
GroovyResolveResultImpl candidate =
new GroovyResolveResultImpl(
method,
resolveContext,
spreadState,
substitutor,
isAccessible,
isStaticsOK,
false,
isValidResult);
if (!myAllVariants && isValidResult) {
addCandidate(candidate);
} else {
addInapplicableCandidate(candidate);
}
}
return true;
}
@Override
public boolean execute(@NotNull PsiElement element, ResolveState state) {
DotNetGenericExtractor extractor = state.get(CSharpResolveUtil.EXTRACTOR);
assert extractor != null;
for (PsiElement psiElement : OverrideUtil.getAllMembers(element, myScope, extractor, true)) {
if (!ExecuteTargetUtil.isMyElement(this, psiElement)) {
continue;
}
addElement(psiElement);
}
return true;
}
private static boolean pushPath(@NotNull PsiFile file, @NotNull ResolveState state) {
synchronized (LOCK) {
if (!CssUtils.isDynamicCssLanguage(file)) {
return false;
}
Collection<String> paths = state.get(PROCESSED_PATHS);
if (paths == null) {
return false;
}
VirtualFile virtualFile = file.getVirtualFile();
if (virtualFile != null && paths.add(virtualFile.getPath())) {
return true;
}
return false;
}
}
@Override
public boolean execute(@NotNull PsiElement element, ResolveState state) {
if (!(element instanceof PsiClass)) return true;
final PsiClass aClass = (PsiClass) element;
final String name = aClass.getName();
if (!myClassName.equals(name)) {
return true;
}
boolean accessible = myPlace == null || checkAccessibility(aClass);
if (myCandidates == null) {
myCandidates = new SmartList<ClassCandidateInfo>();
} else {
String fqName = aClass.getQualifiedName();
if (fqName != null) {
for (int i = myCandidates.size() - 1; i >= 0; i--) {
ClassCandidateInfo info = myCandidates.get(i);
Domination domination =
dominates(aClass, accessible && isAccessible(aClass), fqName, info);
if (domination == Domination.DOMINATED_BY) {
return true;
} else if (domination == Domination.DOMINATES) {
myCandidates.remove(i);
}
}
}
}
myHasAccessibleCandidate |= accessible;
myHasInaccessibleCandidate |= !accessible;
myCandidates.add(
new ClassCandidateInfo(
aClass, state.get(PsiSubstitutor.KEY), !accessible, myCurrentFileContext));
myResult = null;
if (!accessible) return true;
if (aClass.hasModifierProperty(PsiModifier.PRIVATE)) {
final PsiClass containingPlaceClass =
PsiTreeUtil.getParentOfType(myPlace, PsiClass.class, false);
if (containingPlaceClass != null
&& !PsiTreeUtil.isAncestor(containingPlaceClass, aClass, true)) {
return true;
}
}
return myCurrentFileContext instanceof PsiImportStatementBase;
}
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 boolean processSuperTypes(
@NotNull PsiClass aClass,
@NotNull PsiScopeProcessor processor,
@Nullable Set<PsiClass> visited,
PsiElement last,
@NotNull PsiElement place,
@NotNull ResolveState state,
boolean isRaw,
@NotNull PsiElementFactory factory,
@NotNull LanguageLevel languageLevel) {
boolean resolved = false;
for (final PsiClassType superType : aClass.getSuperTypes()) {
final PsiClassType.ClassResolveResult superTypeResolveResult = superType.resolveGenerics();
PsiClass superClass = superTypeResolveResult.getElement();
if (superClass == null) continue;
PsiSubstitutor finalSubstitutor =
obtainFinalSubstitutor(
superClass,
superTypeResolveResult.getSubstitutor(),
aClass,
state.get(PsiSubstitutor.KEY),
factory,
languageLevel);
if (aClass instanceof PsiTypeParameter
&& PsiUtil.isRawSubstitutor(superClass, finalSubstitutor)) {
finalSubstitutor = PsiSubstitutor.EMPTY;
}
if (!processDeclarationsInClass(
superClass,
processor,
state.put(PsiSubstitutor.KEY, finalSubstitutor),
visited,
last,
place,
isRaw)) {
resolved = true;
}
}
return !resolved;
}
public boolean execute(PsiElement element, ResolveState state) {
//noinspection SuspiciousMethodCalls
if (myNonInitializedFields.contains(element)) {
return true;
}
if (!(element instanceof PsiClass) && element instanceof PsiModifierListOwner) {
PsiModifierListOwner modifierListOwner = (PsiModifierListOwner) element;
if (myStatic) {
if (!modifierListOwner.hasModifierProperty(PsiModifier.STATIC)) {
// we don't need non static method in static context.
return true;
}
} else {
if (!mySettings.SHOW_STATIC_AFTER_INSTANCE
&& modifierListOwner.hasModifierProperty(PsiModifier.STATIC)
&& !myMembersFlag) {
// according settings we don't need to process such fields/methods
return true;
}
}
}
final PsiElement elementParent = myElement.getParent();
if (element instanceof PsiPackage && myScope instanceof PsiClass) {
if (!(elementParent instanceof PsiQualifiedReference
&& ((PsiQualifiedReference) elementParent).getQualifier() != null)) {
return true;
}
}
if (satisfies(element, state) && isAccessible(element)) {
CompletionElement element1 =
new CompletionElement(
myQualifierType, element, state.get(PsiSubstitutor.KEY), myQualifierClass);
if (myResultNames.add(element1.getUniqueId())) {
myResults.add(element1);
}
}
return true;
}
@Override
public boolean execute(PsiElement element, ResolveState state) {
if (!(element instanceof PsiClass)) return true;
final PsiClass aClass = (PsiClass) element;
final String name = aClass.getName();
if (!myClassName.equals(name)) {
return true;
}
boolean accessible = myPlace == null || checkAccessibility(aClass);
if (myCandidates == null) {
myCandidates = new SmartList<ClassCandidateInfo>();
} else {
String fqName = aClass.getQualifiedName();
if (fqName != null) {
for (int i = myCandidates.size() - 1; i >= 0; i--) {
ClassCandidateInfo info = myCandidates.get(i);
Domination domination = dominates(aClass, accessible, fqName, info);
if (domination == Domination.DOMINATED_BY) {
return true;
} else if (domination == Domination.DOMINATES) {
myCandidates.remove(i);
}
}
}
}
myHasAccessibleCandidate |= accessible;
myHasInaccessibleCandidate |= !accessible;
myCandidates.add(
new ClassCandidateInfo(
aClass, state.get(PsiSubstitutor.KEY), !accessible, myCurrentFileContext));
myResult = null;
if (!accessible) return true;
return myCurrentFileContext instanceof PsiImportStatementBase;
}
public static boolean processDeclarations(
@NotNull GrTypeDefinition grType,
@NotNull PsiScopeProcessor processor,
@NotNull ResolveState state,
@Nullable PsiElement lastParent,
@NotNull PsiElement place) {
if (place instanceof GrCodeReferenceElement && lastParent instanceof GrModifierList) {
final PsiElement possibleAnnotation =
PsiTreeUtil.skipParentsOfType(place, GrCodeReferenceElement.class);
if (possibleAnnotation instanceof GrAnnotation
&& possibleAnnotation.getParent() == lastParent) {
return true; // don't process class members while resolving annotation which annotates
// current class
}
}
for (final PsiTypeParameter typeParameter : grType.getTypeParameters()) {
if (!processElement(processor, typeParameter, state)) return false;
}
NameHint nameHint = processor.getHint(NameHint.KEY);
String name = nameHint == null ? null : nameHint.getName(state);
ClassHint classHint = processor.getHint(ClassHint.KEY);
final PsiSubstitutor substitutor = state.get(PsiSubstitutor.KEY);
final PsiElementFactory factory = JavaPsiFacade.getElementFactory(place.getProject());
boolean processInstanceMethods =
(shouldProcessMethods(classHint) || shouldProcessProperties(classHint))
&& shouldProcessInstanceMembers(grType, lastParent);
LanguageLevel level = PsiUtil.getLanguageLevel(place);
if (shouldProcessProperties(classHint)) {
Map<String, CandidateInfo> fieldsMap = CollectClassMembersUtil.getAllFields(grType);
if (name != null) {
CandidateInfo fieldInfo = fieldsMap.get(name);
if (fieldInfo != null) {
if (!processField(
grType,
processor,
state,
place,
processInstanceMethods,
substitutor,
factory,
level,
fieldInfo)) {
return false;
}
} else if (grType.isTrait() && lastParent != null) {
PsiField field = findFieldByName(grType, name, false, true);
if (field != null && field.hasModifierProperty(PsiModifier.PUBLIC)) {
if (!processField(
grType,
processor,
state,
place,
processInstanceMethods,
substitutor,
factory,
level,
new CandidateInfo(field, PsiSubstitutor.EMPTY))) {
return false;
}
}
}
} else {
for (CandidateInfo info : fieldsMap.values()) {
if (!processField(
grType,
processor,
state,
place,
processInstanceMethods,
substitutor,
factory,
level,
info)) {
return false;
}
}
if (grType.isTrait() && lastParent != null) {
for (PsiField field : CollectClassMembersUtil.getFields(grType, true)) {
if (field.hasModifierProperty(PsiModifier.PUBLIC)) {
if (!processField(
grType,
processor,
state,
place,
processInstanceMethods,
substitutor,
factory,
level,
new CandidateInfo(field, PsiSubstitutor.EMPTY))) {
return false;
}
}
}
}
}
}
if (shouldProcessMethods(classHint)) {
Map<String, List<CandidateInfo>> methodsMap =
CollectClassMembersUtil.getAllMethods(grType, true);
boolean isPlaceGroovy = place.getLanguage() == GroovyFileType.GROOVY_LANGUAGE;
if (name == null) {
for (List<CandidateInfo> list : methodsMap.values()) {
for (CandidateInfo info : list) {
if (!processMethod(
grType,
processor,
state,
place,
processInstanceMethods,
substitutor,
factory,
level,
isPlaceGroovy,
info)) {
return false;
}
}
}
} else {
List<CandidateInfo> byName = methodsMap.get(name);
if (byName != null) {
for (CandidateInfo info : byName) {
if (!processMethod(
grType,
processor,
state,
place,
processInstanceMethods,
substitutor,
factory,
level,
isPlaceGroovy,
info)) {
return false;
}
}
}
}
}
final GrTypeDefinitionBody body = grType.getBody();
if (body != null) {
if (shouldProcessClasses(classHint)) {
for (PsiClass innerClass : getInnerClassesForResolve(grType, lastParent, place)) {
final String innerClassName = innerClass.getName();
if (nameHint != null && !innerClassName.equals(nameHint.getName(state))) {
continue;
}
if (!processor.execute(innerClass, state)) {
return false;
}
}
}
}
return true;
}
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);
}
