1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
/*
* Copyright 2000-2014 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.intellij.psi.scope.processor;
import com.intellij.psi.*;
import com.intellij.psi.impl.source.resolve.JavaResolveUtil;
import com.intellij.psi.infos.CandidateInfo;
import com.intellij.psi.infos.MethodCandidateInfo;
import com.intellij.psi.scope.PsiConflictResolver;
import com.intellij.psi.scope.conflictResolvers.DuplicateConflictResolver;
import com.intellij.psi.util.PsiUtil;
import com.intellij.util.SmartList;
import org.jetbrains.annotations.NotNull;
import java.util.List;
/**
* @author ik
* Date: 31.01.2003
*/
public class MethodCandidatesProcessor extends MethodsProcessor{
protected boolean myHasAccessibleStaticCorrectCandidate = false;
public MethodCandidatesProcessor(@NotNull PsiElement place, PsiFile placeFile, @NotNull PsiConflictResolver[] resolvers, @NotNull List<CandidateInfo> container) {
super(resolvers, container, place, placeFile);
}
public MethodCandidatesProcessor(@NotNull PsiElement place, PsiFile placeFile) {
super(new PsiConflictResolver[]{DuplicateConflictResolver.INSTANCE}, new SmartList<CandidateInfo>(), place, placeFile);
}
@Override
public void add(@NotNull PsiElement element, @NotNull PsiSubstitutor substitutor) {
if (element instanceof PsiMethod) {
final PsiMethod method = (PsiMethod)element;
addMethod(method, substitutor, isInStaticScope() && !method.hasModifierProperty(PsiModifier.STATIC));
}
}
public void addMethod(@NotNull PsiMethod method, final PsiSubstitutor substitutor, final boolean staticProblem) {
final boolean isAccessible = JavaResolveUtil.isAccessible(method, getContainingClass(method), method.getModifierList(),
myPlace, myAccessClass, myCurrentFileContext, myPlaceFile) &&
!isShadowed(method);
if (isAccepted(method)) {
add(createCandidateInfo(method, substitutor, staticProblem, isAccessible, false));
if (acceptVarargs() && method.isVarArgs() && PsiUtil.isLanguageLevel8OrHigher(myPlace)) {
add(createCandidateInfo(method, substitutor, staticProblem, isAccessible, true));
}
myHasAccessibleStaticCorrectCandidate |= isAccessible && !staticProblem;
}
}
protected PsiClass getContainingClass(PsiMethod method) {
return method.getContainingClass();
}
protected boolean acceptVarargs() {
return false;
}
protected MethodCandidateInfo createCandidateInfo(@NotNull PsiMethod method, @NotNull PsiSubstitutor substitutor,
final boolean staticProblem, final boolean accessible, final boolean varargs) {
final PsiExpressionList argumentList = getArgumentList();
return new MethodCandidateInfo(method, substitutor, !accessible, staticProblem, argumentList, myCurrentFileContext,
null, getTypeArguments(), getLanguageLevel()) {
private PsiType[] myExpressionTypes;
@Override
public PsiType[] getArgumentTypes() {
if (myExpressionTypes == null && argumentList != null) {
final PsiType[] expressionTypes = getExpressionTypes(argumentList);
if (!MethodCandidateInfo.ourOverloadGuard.currentStack().isEmpty()) {
return expressionTypes;
}
myExpressionTypes = expressionTypes;
}
return myExpressionTypes;
}
@Override
public boolean isVarargs() {
return varargs;
}
};
}
protected static PsiType[] getExpressionTypes(PsiExpressionList argumentList) {
return argumentList != null ? argumentList.getExpressionTypes() : null;
}
protected boolean isAccepted(final PsiMethod candidate) {
if (!isConstructor()) {
return !candidate.isConstructor() && candidate.getName().equals(getName(ResolveState.initial()));
}
else {
if (!candidate.isConstructor()) return false;
if (myAccessClass == null) return true;
if (myAccessClass instanceof PsiAnonymousClass) {
final PsiClass containingClass = getContainingClass(candidate);
return containingClass != null && containingClass.equals(myAccessClass.getSuperClass());
}
return myAccessClass.isEquivalentTo(getContainingClass(candidate));
}
}
protected boolean isShadowed(final PsiMethod candidate) {
if (myCurrentFileContext instanceof PsiImportStaticStatement) {
for (JavaResolveResult result : getResults()) {
if (result.getElement() != candidate &&
result.isAccessible() &&
!(result.getCurrentFileResolveScope() instanceof PsiImportStaticStatement)) return true;
}
}
return false;
}
public CandidateInfo[] getCandidates() {
final JavaResolveResult[] resolveResult = getResult();
if (resolveResult.length == 0) return CandidateInfo.EMPTY_ARRAY;
final CandidateInfo[] infos = new CandidateInfo[resolveResult.length];
//noinspection SuspiciousSystemArraycopy
System.arraycopy(resolveResult, 0, infos, 0, resolveResult.length);
return infos;
}
}
|
