@Nullable
private static PsiClass findClass(PsiNewExpression newExpression) {
final PsiJavaCodeReferenceElement classReference =
newExpression.getClassOrAnonymousClassReference();
if (classReference != null) {
final String text = classReference.getReferenceName();
if (text != null) {
final Project project = newExpression.getProject();
final JavaPsiFacade facade = JavaPsiFacade.getInstance(project);
final PsiResolveHelper resolveHelper = facade.getResolveHelper();
final PsiExpression newExpressionQualifier = newExpression.getQualifier();
final PsiElement qualifierElement = classReference.getQualifier();
final String qualifier = qualifierElement != null ? qualifierElement.getText() : "";
final String qualifiedName = StringUtil.getQualifiedName(qualifier, text);
if (newExpressionQualifier != null) {
final PsiClass aClass =
PsiUtil.resolveClassInClassTypeOnly(newExpressionQualifier.getType());
if (aClass != null) {
return aClass.findInnerClassByName(qualifiedName, false);
}
}
return resolveHelper.resolveReferencedClass(qualifiedName, newExpression);
} else {
return null;
}
}
return null;
}
@Nullable
private static PsiClass resolveExtensionPointClass(PsiField psiField) {
final PsiType typeParameter =
PsiUtil.substituteTypeParameter(
psiField.getType(), ExtensionPointName.class.getName(), 0, false);
return PsiUtil.resolveClassInClassTypeOnly(typeParameter);
}
private static Boolean isInferenceVariableOrFreshTypeParameter(PsiType eqBound) {
final PsiClass psiClass = PsiUtil.resolveClassInClassTypeOnly(eqBound);
if (psiClass instanceof InferenceVariable
|| psiClass instanceof PsiTypeParameter
&& InferenceSession.isFreshVariable((PsiTypeParameter) psiClass)) return true;
return false;
}
private static CompoundInitialState createState(InferenceSession topLevelSession) {
final PsiSubstitutor topInferenceSubstitutor =
replaceVariables(topLevelSession.getInferenceVariables());
final Map<PsiElement, InitialInferenceState> nestedStates =
new LinkedHashMap<PsiElement, InitialInferenceState>();
final InferenceSessionContainer copy =
new InferenceSessionContainer() {
@Override
public PsiSubstitutor findNestedSubstitutor(
PsiElement arg, @Nullable PsiSubstitutor defaultSession) {
// for the case foo(bar(a -> m())): top level inference won't touch lambda "a -> m()"
// for the case foo(a -> bar(b -> m())): top level inference would go till nested lambda
// "b -> m()" and the state from top level could be found here by "bar(b -> m())"
// but proceeding with additional constraints from saved point would produce new
// expression constraints with different inference variables (could be found in
// myNestedSessions)
// which won't be found in the system if we won't reject stored sessions in such cases
final PsiSubstitutor substitutor = super.findNestedSubstitutor(arg, null);
if (substitutor != null) {
return substitutor;
}
final InitialInferenceState state =
nestedStates.get(PsiTreeUtil.getParentOfType(arg, PsiCall.class));
if (state != null) {
return state.getInferenceSubstitutor();
}
return super.findNestedSubstitutor(arg, defaultSession);
}
};
final Map<PsiElement, InferenceSession> nestedSessions =
topLevelSession.getInferenceSessionContainer().myNestedSessions;
for (Map.Entry<PsiElement, InferenceSession> entry : nestedSessions.entrySet()) {
nestedStates.put(
entry.getKey(),
entry
.getValue()
.createInitialState(
copy, topLevelSession.getInferenceVariables(), topInferenceSubstitutor));
}
PsiSubstitutor substitutor = PsiSubstitutor.EMPTY;
for (InferenceVariable variable : topLevelSession.getInferenceVariables()) {
final PsiType instantiation = variable.getInstantiation();
if (instantiation != PsiType.NULL) {
final PsiClass psiClass =
PsiUtil.resolveClassInClassTypeOnly(topInferenceSubstitutor.substitute(variable));
if (psiClass instanceof InferenceVariable) {
substitutor = substitutor.put((PsiTypeParameter) psiClass, instantiation);
}
}
}
return new CompoundInitialState(substitutor, nestedStates);
}
public void registerSingleClass(@Nullable InheritorsHolder inheritors) {
if (inheritors != null && myTypeItems.size() == 1) {
PsiType type = myTypeItems.get(0).getType();
PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(type);
if (aClass != null && !aClass.hasTypeParameters()) {
myTypeItems.get(0).setShowPackage();
inheritors.registerClass(aClass);
}
}
}
@Override
public boolean accepts(
@NotNull PsiSwitchStatement psiSwitchStatement,
ProcessingContext context) {
final PsiExpression expression =
psiSwitchStatement.getExpression();
if (expression == null) return false;
PsiClass aClass =
PsiUtil.resolveClassInClassTypeOnly(expression.getType());
return aClass != null && aClass.isEnum();
}
public String getConflictingConjunctsMessage() {
final PsiType[] conjuncts = getConjuncts();
for (int i = 0; i < conjuncts.length; i++) {
PsiClass conjunct = PsiUtil.resolveClassInClassTypeOnly(conjuncts[i]);
if (conjunct != null && !conjunct.isInterface()) {
for (int i1 = i + 1; i1 < conjuncts.length; i1++) {
PsiClass oppositeConjunct = PsiUtil.resolveClassInClassTypeOnly(conjuncts[i1]);
if (oppositeConjunct != null && !oppositeConjunct.isInterface()) {
if (!conjunct.isInheritor(oppositeConjunct, true)
&& !oppositeConjunct.isInheritor(conjunct, true)) {
return conjuncts[i].getPresentableText()
+ " and "
+ conjuncts[i1].getPresentableText();
}
}
}
}
}
return null;
}
@Override
public boolean isInheritor(@NotNull PsiClass baseClass, boolean checkDeep) {
for (PsiType type : getBounds(InferenceBound.UPPER)) {
PsiClass psiClass = PsiUtil.resolveClassInClassTypeOnly(type);
if (psiClass != null) {
if (getManager().areElementsEquivalent(baseClass, psiClass)) return true;
if (checkDeep && psiClass.isInheritor(baseClass, true)) return true;
}
}
return super.isInheritor(baseClass, checkDeep);
}
@NotNull
private static ExpectedTypeMatching preferByMemberName(
@Nullable String expectedMemberName, @Nullable PsiType itemType) {
if (expectedMemberName != null) {
PsiClass itemClass = PsiUtil.resolveClassInClassTypeOnly(itemType);
if (itemClass != null) {
if (itemClass.findMethodsByName(expectedMemberName, true).length > 0
|| itemClass.findFieldByName(expectedMemberName, true) != null
|| itemClass.findInnerClassByName(expectedMemberName, true) != null) {
return ExpectedTypeMatching.expected;
}
}
}
return ExpectedTypeMatching.normal;
}
static void addCollectConversion(
PsiReferenceExpression ref,
Collection<ExpectedTypeInfo> expectedTypes,
Consumer<LookupElement> consumer) {
final PsiExpression qualifier = ref.getQualifierExpression();
PsiType component =
qualifier == null
? null
: PsiUtil.substituteTypeParameter(
qualifier.getType(), JAVA_UTIL_STREAM_STREAM, 0, true);
if (component == null) return;
JavaPsiFacade facade = JavaPsiFacade.getInstance(ref.getProject());
GlobalSearchScope scope = ref.getResolveScope();
PsiClass list = facade.findClass(JAVA_UTIL_LIST, scope);
PsiClass set = facade.findClass(JAVA_UTIL_SET, scope);
if (facade.findClass(JAVA_UTIL_STREAM_COLLECTORS, scope) == null || list == null || set == null)
return;
boolean hasList = false;
boolean hasSet = false;
for (ExpectedTypeInfo info : expectedTypes) {
PsiType type = info.getDefaultType();
PsiClass expectedClass = PsiUtil.resolveClassInClassTypeOnly(type);
PsiType expectedComponent = PsiUtil.extractIterableTypeParameter(type, true);
if (expectedClass == null
|| expectedComponent == null
|| !TypeConversionUtil.isAssignable(expectedComponent, component)) continue;
if (!hasList && InheritanceUtil.isInheritorOrSelf(list, expectedClass, true)) {
hasList = true;
consumer.consume(new MyLookupElement("toList", type));
}
if (!hasSet && InheritanceUtil.isInheritorOrSelf(set, expectedClass, true)) {
hasSet = true;
consumer.consume(new MyLookupElement("toSet", type));
}
}
}
public boolean addBound(PsiType classType, InferenceBound inferenceBound) {
if (inferenceBound == InferenceBound.EQ
&& PsiUtil.resolveClassInClassTypeOnly(classType) == this) {
return false;
}
List<PsiType> list = myBounds.get(inferenceBound);
if (list == null) {
list = new ArrayList<PsiType>();
myBounds.put(inferenceBound, list);
}
if (classType == null) {
classType = PsiType.NULL;
}
final int idx = list.indexOf(classType);
if (idx < 0) {
list.add(classType);
return true;
}
return false;
}
private void correctMethodCall(
final PsiMethodCallExpression expression, final boolean isInternalCall) {
try {
final PsiManager manager = myMethod.getManager();
PsiReferenceExpression methodExpression = expression.getMethodExpression();
if (!methodExpression.isReferenceTo(myMethod)) return;
final PsiExpression oldQualifier = methodExpression.getQualifierExpression();
PsiExpression newQualifier = null;
final PsiClass classReferencedByThis =
MoveInstanceMembersUtil.getClassReferencedByThis(methodExpression);
if (myTargetVariable instanceof PsiParameter) {
final int index =
myMethod.getParameterList().getParameterIndex((PsiParameter) myTargetVariable);
final PsiExpression[] arguments = expression.getArgumentList().getExpressions();
if (index < arguments.length) {
newQualifier = (PsiExpression) arguments[index].copy();
arguments[index].delete();
}
} else {
VisibilityUtil.escalateVisibility((PsiField) myTargetVariable, expression);
String newQualifierName = myTargetVariable.getName();
if (myTargetVariable instanceof PsiField && oldQualifier != null) {
final PsiClass aClass = PsiUtil.resolveClassInClassTypeOnly(oldQualifier.getType());
if (aClass == ((PsiField) myTargetVariable).getContainingClass()) {
newQualifierName = oldQualifier.getText() + "." + newQualifierName;
}
}
newQualifier =
JavaPsiFacade.getInstance(manager.getProject())
.getElementFactory()
.createExpressionFromText(newQualifierName, null);
}
PsiExpression newArgument = null;
if (classReferencedByThis != null) {
@NonNls String thisArgumentText = null;
if (manager.areElementsEquivalent(myMethod.getContainingClass(), classReferencedByThis)) {
if (myOldClassParameterNames.containsKey(myMethod.getContainingClass())) {
thisArgumentText = "this";
}
} else {
thisArgumentText = classReferencedByThis.getName() + ".this";
}
if (thisArgumentText != null) {
newArgument =
JavaPsiFacade.getInstance(manager.getProject())
.getElementFactory()
.createExpressionFromText(thisArgumentText, null);
}
} else {
if (!isInternalCall && oldQualifier != null) {
final PsiType type = oldQualifier.getType();
if (type instanceof PsiClassType) {
final PsiClass resolved = ((PsiClassType) type).resolve();
if (resolved != null && getParameterNameToCreate(resolved) != null) {
newArgument =
replaceRefsToTargetVariable(
oldQualifier); // replace is needed in case old qualifier is e.g. the same as
// field as target variable
}
}
}
}
if (newArgument != null) {
expression.getArgumentList().add(newArgument);
}
if (newQualifier != null) {
if (newQualifier instanceof PsiThisExpression
&& ((PsiThisExpression) newQualifier).getQualifier() == null) {
// Remove now redundant 'this' qualifier
if (oldQualifier != null) oldQualifier.delete();
} else {
final PsiReferenceExpression refExpr =
(PsiReferenceExpression)
JavaPsiFacade.getInstance(manager.getProject())
.getElementFactory()
.createExpressionFromText("q." + myMethod.getName(), null);
refExpr.getQualifierExpression().replace(newQualifier);
methodExpression.replace(refExpr);
}
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
public static Set<LookupElement> processJavaReference(
PsiElement element,
PsiJavaReference javaReference,
ElementFilter elementFilter,
JavaCompletionProcessor.Options options,
final PrefixMatcher matcher,
CompletionParameters parameters) {
final Set<LookupElement> set = new LinkedHashSet<LookupElement>();
final Condition<String> nameCondition =
new Condition<String>() {
@Override
public boolean value(String s) {
return matcher.prefixMatches(s);
}
};
PsiMethodCallExpression call =
PsiTreeUtil.getParentOfType(element, PsiMethodCallExpression.class);
boolean checkInitialized =
parameters.getInvocationCount() <= 1
&& call != null
&& PsiKeyword.SUPER.equals(call.getMethodExpression().getText());
final JavaCompletionProcessor processor =
new JavaCompletionProcessor(
element, elementFilter, options.withInitialized(checkInitialized), nameCondition);
final PsiType plainQualifier = processor.getQualifierType();
PsiType qualifierType = plainQualifier;
PsiType runtimeQualifier = getQualifierCastType(javaReference, parameters);
if (runtimeQualifier != null) {
PsiType composite =
qualifierType == null
? runtimeQualifier
: PsiIntersectionType.createIntersection(qualifierType, runtimeQualifier);
PsiElement ctx = createContextWithXxxVariable(element, composite);
javaReference = createReference("xxx.xxx", ctx);
qualifierType = runtimeQualifier;
processor.setQualifierType(qualifierType);
}
javaReference.processVariants(processor);
final PsiTypeLookupItem castItem =
runtimeQualifier == null
? null
: PsiTypeLookupItem.createLookupItem(
runtimeQualifier, (PsiReferenceExpression) javaReference);
final boolean pkgContext = inSomePackage(element);
PsiClass qualifierClass = PsiUtil.resolveClassInClassTypeOnly(qualifierType);
final boolean honorExcludes =
qualifierClass == null || !isInExcludedPackage(qualifierClass, false);
final Set<PsiMember> mentioned = new THashSet<PsiMember>();
for (CompletionElement completionElement : processor.getResults()) {
for (LookupElement item : createLookupElements(completionElement, javaReference)) {
item.putUserData(QUALIFIER_TYPE_ATTR, qualifierType);
final Object o = item.getObject();
if (o instanceof PsiClass && !isSourceLevelAccessible(element, (PsiClass) o, pkgContext)) {
continue;
}
if (o instanceof PsiMember) {
if (honorExcludes && isInExcludedPackage((PsiMember) o, true)) {
continue;
}
mentioned.add(CompletionUtil.getOriginalOrSelf((PsiMember) o));
}
set.add(
highlightIfNeeded(
qualifierType,
castQualifier(item, castItem, plainQualifier, processor),
o,
element));
}
}
if (javaReference instanceof PsiJavaCodeReferenceElement) {
PsiElement refQualifier = ((PsiJavaCodeReferenceElement) javaReference).getQualifier();
if (refQualifier == null) {
final StaticMemberProcessor memberProcessor = new JavaStaticMemberProcessor(parameters);
memberProcessor.processMembersOfRegisteredClasses(
matcher,
new PairConsumer<PsiMember, PsiClass>() {
@Override
public void consume(PsiMember member, PsiClass psiClass) {
if (!mentioned.contains(member)
&& processor.satisfies(member, ResolveState.initial())) {
set.add(memberProcessor.createLookupElement(member, psiClass, true));
}
}
});
} else if (refQualifier instanceof PsiSuperExpression
&& ((PsiSuperExpression) refQualifier).getQualifier() == null) {
set.addAll(
SuperCalls.suggestQualifyingSuperCalls(
element, javaReference, elementFilter, options, nameCondition));
}
}
return set;
}
protected void checkSameSignatures(@NotNull List<CandidateInfo> conflicts) {
// candidates should go in order of class hierarchy traversal
// in order for this to work
Map<MethodSignature, CandidateInfo> signatures =
new THashMap<MethodSignature, CandidateInfo>(conflicts.size());
Set<PsiMethod> superMethods = new HashSet<PsiMethod>();
for (CandidateInfo conflict : conflicts) {
final PsiMethod method = ((MethodCandidateInfo) conflict).getElement();
for (HierarchicalMethodSignature methodSignature :
method.getHierarchicalMethodSignature().getSuperSignatures()) {
final PsiMethod superMethod = methodSignature.getMethod();
final PsiClass aClass = superMethod.getContainingClass();
if (aClass != null
&& !CommonClassNames.JAVA_LANG_OBJECT.equals(aClass.getQualifiedName())) {
superMethods.add(superMethod);
}
}
}
nextConflict:
for (int i = 0; i < conflicts.size(); i++) {
ProgressManager.checkCanceled();
CandidateInfo info = conflicts.get(i);
PsiMethod method = (PsiMethod) info.getElement();
if (!method.hasModifierProperty(PsiModifier.STATIC) && superMethods.contains(method)) {
conflicts.remove(i);
i--;
continue;
}
PsiClass class1 = method.getContainingClass();
PsiSubstitutor infoSubstitutor = ((MethodCandidateInfo) info).getSubstitutor(false);
MethodSignature signature = method.getSignature(infoSubstitutor);
CandidateInfo existing = signatures.get(signature);
if (existing == null) {
signatures.put(signature, info);
continue;
}
PsiMethod existingMethod = (PsiMethod) existing.getElement();
PsiClass existingClass = existingMethod.getContainingClass();
if (class1 != null
&& existingClass != null) { // prefer interface methods to methods from Object
if (class1.isInterface()
&& CommonClassNames.JAVA_LANG_OBJECT.equals(existingClass.getQualifiedName())) {
signatures.put(signature, info);
continue;
} else if (existingClass.isInterface()
&& CommonClassNames.JAVA_LANG_OBJECT.equals(class1.getQualifiedName())) {
conflicts.remove(info);
i--;
continue;
}
}
if (method == existingMethod) {
PsiElement scope1 = info.getCurrentFileResolveScope();
PsiElement scope2 = existing.getCurrentFileResolveScope();
if (scope1 instanceof PsiClass
&& scope2 instanceof PsiClass
&& PsiTreeUtil.isAncestor(scope1, scope2, true)
&& !existing
.isAccessible()) { // prefer methods from outer class to inaccessible base class
// methods
signatures.put(signature, info);
continue;
}
}
// filter out methods with incorrect inferred bounds (for unrelated methods only)
boolean existingTypeParamAgree = areTypeParametersAgree(existing);
boolean infoTypeParamAgree = areTypeParametersAgree(info);
if (existingTypeParamAgree
&& !infoTypeParamAgree
&& !PsiSuperMethodImplUtil.isSuperMethodSmart(method, existingMethod)) {
conflicts.remove(i);
i--;
continue;
}
if (!existingTypeParamAgree
&& infoTypeParamAgree
&& !PsiSuperMethodImplUtil.isSuperMethodSmart(existingMethod, method)) {
signatures.put(signature, info);
int index = conflicts.indexOf(existing);
conflicts.remove(index);
i--;
continue;
}
if (InheritanceUtil.isInheritorOrSelf(class1, existingClass, true)
|| InheritanceUtil.isInheritorOrSelf(existingClass, class1, true)) {
PsiParameter[] parameters = method.getParameterList().getParameters();
final PsiParameter[] existingParameters = existingMethod.getParameterList().getParameters();
for (int i1 = 0, parametersLength = parameters.length; i1 < parametersLength; i1++) {
if (parameters[i1].getType() instanceof PsiArrayType
&& !(existingParameters[i1].getType()
instanceof PsiArrayType)) { // prefer more specific type
signatures.put(signature, info);
continue nextConflict;
}
}
PsiType returnType1 = method.getReturnType();
PsiType returnType2 = existingMethod.getReturnType();
if (returnType1 != null && returnType2 != null) {
returnType1 = infoSubstitutor.substitute(returnType1);
returnType2 =
((MethodCandidateInfo) existing).getSubstitutor(false).substitute(returnType2);
if (!returnType1.equals(returnType2) && returnType1.isAssignableFrom(returnType2)) {
conflicts.remove(i);
i--;
continue;
}
}
// prefer derived class
signatures.put(signature, info);
} else {
final PsiMethodCallExpression methodCallExpression =
PsiTreeUtil.getParentOfType(myArgumentsList, PsiMethodCallExpression.class);
if (methodCallExpression != null) {
final PsiReferenceExpression expression = methodCallExpression.getMethodExpression();
final PsiExpression qualifierExpression = expression.getQualifierExpression();
PsiClass currentClass;
if (qualifierExpression != null) {
currentClass = PsiUtil.resolveClassInClassTypeOnly(qualifierExpression.getType());
} else {
currentClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class);
}
if (currentClass != null && existingClass != null && class1 != null) {
final PsiSubstitutor eSubstitutor =
TypeConversionUtil.getMaybeSuperClassSubstitutor(
existingClass, currentClass, PsiSubstitutor.EMPTY, null);
final PsiSubstitutor cSubstitutor =
TypeConversionUtil.getMaybeSuperClassSubstitutor(
class1, currentClass, PsiSubstitutor.EMPTY, null);
if (eSubstitutor != null
&& cSubstitutor != null
&& MethodSignatureUtil.areSignaturesEqual(
existingMethod.getSignature(eSubstitutor), method.getSignature(cSubstitutor))) {
final PsiType returnType = eSubstitutor.substitute(existingMethod.getReturnType());
final PsiType returnType1 = cSubstitutor.substitute(method.getReturnType());
if (returnType != null && returnType1 != null && !returnType1.equals(returnType)) {
if (TypeConversionUtil.isAssignable(returnType, returnType1, false)) {
if (class1.isInterface() && !existingClass.isInterface()) continue;
conflicts.remove(existing);
} else {
if (!TypeConversionUtil.isAssignable(returnType1, returnType, false)) continue;
conflicts.remove(i);
}
i--;
break;
}
}
}
}
}
}
}
