private static void checkMethodReference(
PsiMethodReferenceExpression expression,
InspectionManager inspectionManager,
List<ProblemDescriptor> problems) {
final PsiTypeElement qualifierTypeElement = expression.getQualifierType();
if (qualifierTypeElement != null) {
final PsiType psiType = qualifierTypeElement.getType();
if (psiType instanceof PsiClassType && !(((PsiClassType) psiType).isRaw())) {
final JavaResolveResult result = expression.advancedResolve(false);
final PsiElement element = result.getElement();
if (element instanceof PsiTypeParameterListOwner) {
final PsiMethodReferenceExpression copy =
createMethodReference(expression, qualifierTypeElement);
final JavaResolveResult simplifiedResolve = copy.advancedResolve(false);
final PsiElement candidate = simplifiedResolve.getElement();
if (candidate == element) {
final PsiJavaCodeReferenceElement referenceElement =
qualifierTypeElement.getInnermostComponentReferenceElement();
LOG.assertTrue(referenceElement != null, qualifierTypeElement);
final PsiReferenceParameterList parameterList = referenceElement.getParameterList();
LOG.assertTrue(parameterList != null);
final ProblemDescriptor descriptor =
inspectionManager.createProblemDescriptor(
parameterList,
InspectionsBundle.message("inspection.redundant.type.problem.descriptor"),
new MyMethodReferenceFixAction(),
ProblemHighlightType.LIKE_UNUSED_SYMBOL,
false);
problems.add(descriptor);
}
}
}
}
}
public void testInferWithBounds1() throws Exception {
PsiReferenceExpression ref = configure();
JavaResolveResult resolveResult = ref.advancedResolve(false);
PsiSubstitutor substitutor = resolveResult.getSubstitutor();
PsiMethod method = (PsiMethod) resolveResult.getElement();
PsiType type = substitutor.substitute(method.getTypeParameters()[0]);
assertEquals("java.lang.String", type.getCanonicalText());
}
private JavaResolveResult advancedResolveInner(final PsiElement psiElement, final String qName) {
final PsiManager manager = psiElement.getManager();
final GlobalSearchScope scope = getScope();
if (myIndex == myJavaClassReferenceSet.getReferences().length - 1) {
final PsiClass aClass =
JavaPsiFacade.getInstance(manager.getProject()).findClass(qName, scope);
if (aClass != null) {
return new ClassCandidateInfo(aClass, PsiSubstitutor.EMPTY, false, psiElement);
} else {
if (!JavaClassReferenceProvider.ADVANCED_RESOLVE.getBooleanValue(getOptions())) {
return JavaResolveResult.EMPTY;
}
}
}
PsiElement resolveResult = JavaPsiFacade.getInstance(manager.getProject()).findPackage(qName);
if (resolveResult == null) {
resolveResult = JavaPsiFacade.getInstance(manager.getProject()).findClass(qName, scope);
}
if (myInStaticImport && resolveResult == null) {
resolveResult = resolveMember(qName, manager, getElement().getResolveScope());
}
if (resolveResult == null) {
PsiFile containingFile = psiElement.getContainingFile();
if (containingFile instanceof PsiJavaFile) {
if (containingFile instanceof JspFile) {
containingFile = containingFile.getViewProvider().getPsi(StdLanguages.JAVA);
if (containingFile == null) return JavaResolveResult.EMPTY;
}
final ClassResolverProcessor processor =
new ClassResolverProcessor(getCanonicalText(), psiElement);
containingFile.processDeclarations(processor, ResolveState.initial(), null, psiElement);
if (processor.getResult().length == 1) {
final JavaResolveResult javaResolveResult = processor.getResult()[0];
if (javaResolveResult != JavaResolveResult.EMPTY && getOptions() != null) {
final Boolean value =
JavaClassReferenceProvider.RESOLVE_QUALIFIED_CLASS_NAME.getValue(getOptions());
final PsiClass psiClass = (PsiClass) javaResolveResult.getElement();
if (value != null && value.booleanValue() && psiClass != null) {
final String qualifiedName = psiClass.getQualifiedName();
if (!qName.equals(qualifiedName)) {
return JavaResolveResult.EMPTY;
}
}
}
return javaResolveResult;
}
}
}
return resolveResult != null
? new CandidateInfo(resolveResult, PsiSubstitutor.EMPTY, false, false, psiElement)
: JavaResolveResult.EMPTY;
}
@NotNull
@Override
public JavaResolveResult[] resolve(
@NotNull ClsJavaCodeReferenceElementImpl ref, boolean incompleteCode) {
final JavaResolveResult resolveResult = ref.advancedResolveImpl();
return resolveResult.getElement() == null
? JavaResolveResult.EMPTY_ARRAY
: new JavaResolveResult[] {resolveResult};
}
public MethodCallUsageInfo(
final PsiElement ref, boolean isToChangeArguments, boolean isToCatchExceptions) {
super(ref);
myToChangeArguments = isToChangeArguments;
myToCatchExceptions = isToCatchExceptions;
final JavaResolveResult resolveResult = resolveMethod(ref);
myReferencedMethod = (PsiMethod) resolveResult.getElement();
mySubstitutor = resolveResult.getSubstitutor();
}
@Override
@Nullable
public PsiType fun(final PsiMethodCallExpression call) {
PsiReferenceExpression methodExpression = call.getMethodExpression();
PsiType theOnly = null;
final JavaResolveResult[] results = methodExpression.multiResolve(false);
LanguageLevel languageLevel = PsiUtil.getLanguageLevel(call);
final PsiElement callParent = PsiUtil.skipParenthesizedExprUp(call.getParent());
final PsiExpressionList parentArgList;
if (languageLevel.isAtLeast(LanguageLevel.JDK_1_8)) {
parentArgList =
callParent instanceof PsiConditionalExpression
&& !PsiPolyExpressionUtil.isPolyExpression((PsiExpression) callParent)
? null
: PsiTreeUtil.getParentOfType(call, PsiExpressionList.class);
} else {
parentArgList = null;
}
final MethodCandidateInfo.CurrentCandidateProperties properties =
MethodCandidateInfo.getCurrentMethod(parentArgList);
final boolean genericMethodCall =
properties != null && properties.getInfo().isToInferApplicability();
for (int i = 0; i < results.length; i++) {
final JavaResolveResult candidateInfo = results[i];
if (genericMethodCall
&& PsiPolyExpressionUtil.isMethodCallPolyExpression(
call, (PsiMethod) candidateInfo.getElement())) {
if (callParent instanceof PsiAssignmentExpression) {
return null;
}
LOG.error("poly expression evaluation during overload resolution");
}
final PsiType type = getResultType(call, methodExpression, candidateInfo, languageLevel);
if (type == null) {
return null;
}
if (i == 0) {
theOnly = type;
} else if (!theOnly.equals(type)) {
return null;
}
}
return PsiClassImplUtil.correctType(theOnly, call.getResolveScope());
}
private void specialCase(
InferenceSession session,
List<ConstraintFormula> constraints,
PsiSubstitutor substitutor,
PsiParameter[] targetParameters,
boolean ignoreRaw) {
final PsiElement qualifier = myExpression.getQualifier();
PsiType qualifierType = null;
if (qualifier instanceof PsiTypeElement) {
qualifierType = ((PsiTypeElement) qualifier).getType();
final PsiClass qualifierClass = PsiUtil.resolveClassInType(qualifierType);
if (qualifierClass != null) {
qualifierType =
JavaPsiFacade.getElementFactory(myExpression.getProject())
.createType(qualifierClass, PsiSubstitutor.EMPTY);
}
} else if (qualifier instanceof PsiExpression) {
qualifierType = ((PsiExpression) qualifier).getType();
if (qualifierType == null && qualifier instanceof PsiReferenceExpression) {
final JavaResolveResult resolveResult =
((PsiReferenceExpression) qualifier).advancedResolve(false);
final PsiElement res = resolveResult.getElement();
if (res instanceof PsiClass) {
PsiClass containingClass = (PsiClass) res;
final boolean isRawSubst =
!ignoreRaw
&& !myExpression.isConstructor()
&& PsiUtil.isRawSubstitutor(containingClass, resolveResult.getSubstitutor());
qualifierType =
JavaPsiFacade.getElementFactory(res.getProject())
.createType(
containingClass,
isRawSubst ? PsiSubstitutor.EMPTY : resolveResult.getSubstitutor());
}
}
}
final PsiClass qualifierClass = PsiUtil.resolveClassInType(qualifierType);
if (qualifierClass != null) {
session.initBounds(myExpression, qualifierClass.getTypeParameters());
constraints.add(
new StrictSubtypingConstraint(
session.substituteWithInferenceVariables(qualifierType),
session.substituteWithInferenceVariables(
substitutor.substitute(targetParameters[0].getType()))));
}
}
public void registerReference(
@NotNull PsiJavaReference ref, @NotNull JavaResolveResult resolveResult) {
PsiElement refElement = resolveResult.getElement();
PsiFile psiFile = refElement == null ? null : refElement.getContainingFile();
if (psiFile != null)
psiFile =
(PsiFile)
psiFile
.getNavigationElement(); // look at navigation elements because all references
// resolve into Cls elements when highlighting library
// source
if (refElement != null
&& psiFile != null
&& myFile.getViewProvider().equals(psiFile.getViewProvider())) {
registerLocalRef(ref, refElement.getNavigationElement());
}
PsiElement resolveScope = resolveResult.getCurrentFileResolveScope();
if (resolveScope instanceof PsiImportStatementBase) {
registerImportStatement(ref, (PsiImportStatementBase) resolveScope);
}
}
public static PsiType captureReturnType(
PsiMethodCallExpression call,
PsiMethod method,
PsiType ret,
JavaResolveResult result,
LanguageLevel languageLevel) {
PsiSubstitutor substitutor = result.getSubstitutor();
PsiType substitutedReturnType = substitutor.substitute(ret);
if (substitutedReturnType == null) {
return TypeConversionUtil.erasure(ret);
}
if (InferenceSession.wasUncheckedConversionPerformed(call)) {
// 18.5.2
// if unchecked conversion was necessary, then this substitution provides the parameter types
// of the invocation type,
// while the return type and thrown types are given by the erasure of m's type (without
// applying θ').
// due to https://bugs.openjdk.java.net/browse/JDK-8135087 erasure is called on
// substitutedReturnType and not on ret type itself as by spec
return TypeConversionUtil.erasure(substitutedReturnType);
}
// 15.12.2.6. Method Invocation Type
// If unchecked conversion was necessary for the method to be applicable,
// the parameter types of the invocation type are the parameter types of the method's type,
// and the return type and thrown types are given by the erasures of the return type and thrown
// types of the method's type.
if (!languageLevel.isAtLeast(LanguageLevel.JDK_1_8)
&& (method.hasTypeParameters()
|| JavaVersionService.getInstance().isAtLeast(call, JavaSdkVersion.JDK_1_8))
&& result instanceof MethodCandidateInfo
&& ((MethodCandidateInfo) result).isApplicable()) {
final PsiType[] args = call.getArgumentList().getExpressionTypes();
final boolean allowUncheckedConversion = false;
final int applicabilityLevel =
PsiUtil.getApplicabilityLevel(
method, substitutor, args, languageLevel, allowUncheckedConversion, true);
if (applicabilityLevel == MethodCandidateInfo.ApplicabilityLevel.NOT_APPLICABLE) {
return TypeConversionUtil.erasure(substitutedReturnType);
}
}
if (PsiUtil.isRawSubstitutor(method, substitutor)) {
final PsiType returnTypeErasure = TypeConversionUtil.erasure(ret);
if (Comparing.equal(TypeConversionUtil.erasure(substitutedReturnType), returnTypeErasure)) {
return returnTypeErasure;
}
}
return PsiUtil.captureToplevelWildcards(substitutedReturnType, call);
}
@Nullable
private static PsiType getResultType(
PsiMethodCallExpression call,
PsiReferenceExpression methodExpression,
JavaResolveResult result,
@NotNull final LanguageLevel languageLevel) {
final PsiMethod method = (PsiMethod) result.getElement();
if (method == null) return null;
boolean is15OrHigher = languageLevel.compareTo(LanguageLevel.JDK_1_5) >= 0;
final PsiType getClassReturnType =
PsiTypesUtil.patchMethodGetClassReturnType(
call,
methodExpression,
method,
new Condition<IElementType>() {
@Override
public boolean value(IElementType type) {
return type != JavaElementType.CLASS;
}
},
languageLevel);
if (getClassReturnType != null) {
return getClassReturnType;
}
PsiType ret = method.getReturnType();
if (ret == null) return null;
if (ret instanceof PsiClassType) {
ret = ((PsiClassType) ret).setLanguageLevel(languageLevel);
}
if (is15OrHigher) {
return captureReturnType(call, method, ret, result, languageLevel);
}
return TypeConversionUtil.erasure(ret);
}
@Override
public boolean reduce(InferenceSession session, List<ConstraintFormula> constraints) {
if (!LambdaUtil.isFunctionalType(myT)) {
return false;
}
final PsiType groundTargetType =
FunctionalInterfaceParameterizationUtil.getGroundTargetType(myT);
final PsiClassType.ClassResolveResult classResolveResult =
PsiUtil.resolveGenericsClassInType(groundTargetType);
final PsiMethod interfaceMethod = LambdaUtil.getFunctionalInterfaceMethod(classResolveResult);
if (interfaceMethod == null) {
return false;
}
final PsiSubstitutor substitutor =
LambdaUtil.getSubstitutor(interfaceMethod, classResolveResult);
final PsiParameter[] targetParameters = interfaceMethod.getParameterList().getParameters();
final PsiType interfaceMethodReturnType = interfaceMethod.getReturnType();
final PsiType returnType = substitutor.substitute(interfaceMethodReturnType);
final PsiType[] typeParameters = myExpression.getTypeParameters();
final PsiMethodReferenceUtil.QualifierResolveResult qualifierResolveResult =
PsiMethodReferenceUtil.getQualifierResolveResult(myExpression);
if (!myExpression.isExact()) {
for (PsiParameter parameter : targetParameters) {
if (!session.isProperType(substitutor.substitute(parameter.getType()))) {
return false;
}
}
} else {
final PsiMember applicableMember = myExpression.getPotentiallyApplicableMember();
LOG.assertTrue(applicableMember != null);
final PsiClass applicableMemberContainingClass = applicableMember.getContainingClass();
final PsiClass containingClass = qualifierResolveResult.getContainingClass();
PsiSubstitutor psiSubstitutor = qualifierResolveResult.getSubstitutor();
psiSubstitutor =
applicableMemberContainingClass == null
|| containingClass == null
|| myExpression.isConstructor()
? psiSubstitutor
: TypeConversionUtil.getSuperClassSubstitutor(
applicableMemberContainingClass, containingClass, psiSubstitutor);
PsiType applicableMethodReturnType =
applicableMember instanceof PsiMethod
? ((PsiMethod) applicableMember).getReturnType()
: null;
int idx = 0;
for (PsiTypeParameter param :
((PsiTypeParameterListOwner) applicableMember).getTypeParameters()) {
if (idx < typeParameters.length) {
psiSubstitutor = psiSubstitutor.put(param, typeParameters[idx++]);
}
}
final PsiParameter[] parameters =
applicableMember instanceof PsiMethod
? ((PsiMethod) applicableMember).getParameterList().getParameters()
: PsiParameter.EMPTY_ARRAY;
if (targetParameters.length == parameters.length + 1) {
specialCase(session, constraints, substitutor, targetParameters, true);
for (int i = 1; i < targetParameters.length; i++) {
constraints.add(
new TypeCompatibilityConstraint(
session.substituteWithInferenceVariables(
psiSubstitutor.substitute(parameters[i - 1].getType())),
substitutor.substitute(targetParameters[i].getType())));
}
} else if (targetParameters.length == parameters.length) {
for (int i = 0; i < targetParameters.length; i++) {
constraints.add(
new TypeCompatibilityConstraint(
session.substituteWithInferenceVariables(
psiSubstitutor.substitute(parameters[i].getType())),
substitutor.substitute(targetParameters[i].getType())));
}
} else {
return false;
}
if (returnType != PsiType.VOID && returnType != null) {
if (applicableMethodReturnType == PsiType.VOID) {
return false;
}
if (applicableMethodReturnType != null) {
constraints.add(
new TypeCompatibilityConstraint(
returnType,
session.substituteWithInferenceVariables(
psiSubstitutor.substitute(applicableMethodReturnType))));
} else if (applicableMember instanceof PsiClass
|| applicableMember instanceof PsiMethod
&& ((PsiMethod) applicableMember).isConstructor()) {
final PsiElementFactory elementFactory =
JavaPsiFacade.getElementFactory(applicableMember.getProject());
if (containingClass != null) {
final PsiType classType =
session.substituteWithInferenceVariables(
elementFactory.createType(containingClass, psiSubstitutor));
constraints.add(new TypeCompatibilityConstraint(returnType, classType));
}
}
}
return true;
}
final Map<PsiElement, PsiType> map = LambdaUtil.getFunctionalTypeMap();
final PsiType added = map.put(myExpression, session.startWithFreshVars(groundTargetType));
final JavaResolveResult resolve;
try {
resolve = myExpression.advancedResolve(true);
} finally {
if (added == null) {
map.remove(myExpression);
}
}
final PsiElement element = resolve.getElement();
if (element == null) {
return false;
}
if (PsiType.VOID.equals(returnType) || returnType == null) {
return true;
}
if (element instanceof PsiMethod) {
final PsiMethod method = (PsiMethod) element;
final PsiType referencedMethodReturnType;
final PsiClass containingClass = method.getContainingClass();
LOG.assertTrue(containingClass != null, method);
PsiClass qContainingClass = qualifierResolveResult.getContainingClass();
PsiSubstitutor psiSubstitutor = qualifierResolveResult.getSubstitutor();
if (qContainingClass != null) {
if (PsiUtil.isRawSubstitutor(qContainingClass, psiSubstitutor)) {
psiSubstitutor = PsiSubstitutor.EMPTY;
}
if (qContainingClass.isInheritor(containingClass, true)) {
psiSubstitutor =
TypeConversionUtil.getClassSubstitutor(
containingClass, qContainingClass, PsiSubstitutor.EMPTY);
LOG.assertTrue(psiSubstitutor != null);
}
}
if (method.isConstructor()) {
referencedMethodReturnType =
JavaPsiFacade.getElementFactory(method.getProject())
.createType(containingClass, PsiSubstitutor.EMPTY);
} else {
referencedMethodReturnType = method.getReturnType();
}
LOG.assertTrue(referencedMethodReturnType != null, method);
if (!PsiTreeUtil.isContextAncestor(containingClass, myExpression, false)
|| PsiUtil.getEnclosingStaticElement(myExpression, containingClass) != null) {
session.initBounds(myExpression, containingClass.getTypeParameters());
}
session.initBounds(myExpression, method.getTypeParameters());
// if i) the method reference elides NonWildTypeArguments,
// ii) the compile-time declaration is a generic method, and
// iii) the return type of the compile-time declaration mentions at least one of the method's
// type parameters;
if (typeParameters.length == 0 && method.getTypeParameters().length > 0) {
final PsiClass interfaceClass = classResolveResult.getElement();
LOG.assertTrue(interfaceClass != null);
if (PsiPolyExpressionUtil.mentionsTypeParameters(
referencedMethodReturnType, ContainerUtil.newHashSet(method.getTypeParameters()))) {
// the constraint reduces to the bound set B3 which would be used to determine the method
// reference's invocation type
// when targeting the return type of the function type, as defined in 18.5.2.
session.collectApplicabilityConstraints(
myExpression, ((MethodCandidateInfo) resolve), groundTargetType);
session.registerReturnTypeConstraints(referencedMethodReturnType, returnType);
return true;
}
}
if (PsiType.VOID.equals(referencedMethodReturnType)) {
return false;
}
int idx = 0;
for (PsiTypeParameter param : method.getTypeParameters()) {
if (idx < typeParameters.length) {
psiSubstitutor = psiSubstitutor.put(param, typeParameters[idx++]);
}
}
final PsiParameter[] parameters = method.getParameterList().getParameters();
if (targetParameters.length == parameters.length + 1
&& !method.isVarArgs()
&& PsiPolyExpressionUtil.mentionsTypeParameters(
referencedMethodReturnType,
ContainerUtil.newHashSet(
containingClass.getTypeParameters()))) { // todo specification bug?
specialCase(session, constraints, substitutor, targetParameters, false);
}
constraints.add(
new TypeCompatibilityConstraint(
returnType,
session.substituteWithInferenceVariables(
psiSubstitutor.substitute(referencedMethodReturnType))));
}
return true;
}
@Nullable
public static String getSuspiciousMethodCallMessage(
@NotNull PsiMethodCallExpression methodCall,
PsiType argType,
boolean reportConvertibleMethodCalls,
@NotNull List<PsiMethod> patternMethods,
@NotNull IntArrayList indices) {
final PsiReferenceExpression methodExpression = methodCall.getMethodExpression();
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (qualifier == null
|| qualifier instanceof PsiThisExpression
|| qualifier instanceof PsiSuperExpression) return null;
if (argType instanceof PsiPrimitiveType) {
argType = ((PsiPrimitiveType) argType).getBoxedType(methodCall);
}
if (!(argType instanceof PsiClassType)) return null;
final JavaResolveResult resolveResult = methodExpression.advancedResolve(false);
PsiMethod calleeMethod = (PsiMethod) resolveResult.getElement();
if (calleeMethod == null) return null;
PsiMethod contextMethod = PsiTreeUtil.getParentOfType(methodCall, PsiMethod.class);
//noinspection SynchronizationOnLocalVariableOrMethodParameter
synchronized (patternMethods) {
if (patternMethods.isEmpty()) {
setupPatternMethods(
methodCall.getManager(), methodCall.getResolveScope(), patternMethods, indices);
}
}
for (int i = 0; i < patternMethods.size(); i++) {
PsiMethod patternMethod = patternMethods.get(i);
if (!patternMethod.getName().equals(methodExpression.getReferenceName())) continue;
int index = indices.get(i);
// we are in collections method implementation
if (contextMethod != null && isInheritorOrSelf(contextMethod, patternMethod)) return null;
final PsiClass calleeClass = calleeMethod.getContainingClass();
PsiSubstitutor substitutor = resolveResult.getSubstitutor();
final PsiClass patternClass = patternMethod.getContainingClass();
assert patternClass != null;
assert calleeClass != null;
substitutor = TypeConversionUtil.getClassSubstitutor(patternClass, calleeClass, substitutor);
if (substitutor == null) continue;
if (!patternMethod
.getSignature(substitutor)
.equals(calleeMethod.getSignature(PsiSubstitutor.EMPTY))) continue;
PsiTypeParameter[] typeParameters = patternClass.getTypeParameters();
if (typeParameters.length <= index) return null;
final PsiTypeParameter typeParameter = typeParameters[index];
PsiType typeParamMapping = substitutor.substitute(typeParameter);
if (typeParamMapping == null) return null;
PsiParameter[] parameters = patternMethod.getParameterList().getParameters();
if (parameters.length == 1 && "removeAll".equals(patternMethod.getName())) {
PsiType paramType = parameters[0].getType();
if (InheritanceUtil.isInheritor(paramType, CommonClassNames.JAVA_UTIL_COLLECTION)) {
PsiType qualifierType = qualifier.getType();
if (qualifierType != null) {
final PsiType itemType =
JavaGenericsUtil.getCollectionItemType(argType, calleeMethod.getResolveScope());
final PsiType qualifierItemType =
JavaGenericsUtil.getCollectionItemType(
qualifierType, calleeMethod.getResolveScope());
if (qualifierItemType != null
&& itemType != null
&& !qualifierItemType.isAssignableFrom(itemType)) {
return InspectionsBundle.message(
"inspection.suspicious.collections.method.calls.problem.descriptor",
PsiFormatUtil.formatType(qualifierType, 0, PsiSubstitutor.EMPTY),
PsiFormatUtil.formatType(itemType, 0, PsiSubstitutor.EMPTY));
}
}
return null;
}
}
String message = null;
if (typeParamMapping instanceof PsiCapturedWildcardType) {
typeParamMapping = ((PsiCapturedWildcardType) typeParamMapping).getWildcard();
}
if (!typeParamMapping.isAssignableFrom(argType)) {
if (typeParamMapping.isConvertibleFrom(argType)) {
if (reportConvertibleMethodCalls) {
message =
InspectionsBundle.message(
"inspection.suspicious.collections.method.calls.problem.descriptor1",
PsiFormatUtil.formatMethod(
calleeMethod,
substitutor,
PsiFormatUtilBase.SHOW_NAME | PsiFormatUtilBase.SHOW_CONTAINING_CLASS,
PsiFormatUtilBase.SHOW_TYPE));
}
} else {
PsiType qualifierType = qualifier.getType();
if (qualifierType != null) {
message =
InspectionsBundle.message(
"inspection.suspicious.collections.method.calls.problem.descriptor",
PsiFormatUtil.formatType(qualifierType, 0, PsiSubstitutor.EMPTY),
PsiFormatUtil.formatType(argType, 0, PsiSubstitutor.EMPTY));
}
}
}
return message;
}
return null;
}
private static void addNamesToImport(
@NotNull Set<String> names,
@NotNull PsiElement scope,
@NotNull String thisPackageName,
@NotNull Set<String> namesToImportStaticly,
PsiFile context) {
if (scope instanceof PsiImportList) return;
final LinkedList<PsiElement> stack = new LinkedList<PsiElement>();
stack.add(scope);
while (!stack.isEmpty()) {
final PsiElement child = stack.removeFirst();
if (child instanceof PsiImportList) continue;
stack.addAll(Arrays.asList(child.getChildren()));
for (final PsiReference reference : child.getReferences()) {
if (!(reference instanceof PsiJavaReference)) continue;
final PsiJavaReference javaReference = (PsiJavaReference) reference;
if (javaReference instanceof JavaClassReference) {
if (((JavaClassReference) javaReference).getContextReference() != null) continue;
}
PsiJavaCodeReferenceElement referenceElement = null;
if (reference instanceof PsiJavaCodeReferenceElement) {
referenceElement = (PsiJavaCodeReferenceElement) child;
if (referenceElement.getQualifier() != null) {
continue;
}
if (reference instanceof PsiJavaCodeReferenceElementImpl
&& ((PsiJavaCodeReferenceElementImpl) reference).getKind()
== PsiJavaCodeReferenceElementImpl.CLASS_IN_QUALIFIED_NEW_KIND) {
continue;
}
}
final JavaResolveResult resolveResult = javaReference.advancedResolve(true);
PsiElement refElement = resolveResult.getElement();
if (refElement == null && referenceElement != null) {
refElement = ResolveClassUtil.resolveClass(referenceElement); // might be uncomplete code
}
PsiElement currentFileResolveScope = resolveResult.getCurrentFileResolveScope();
if (!(currentFileResolveScope instanceof PsiImportStatementBase)) continue;
if (context != null
&& currentFileResolveScope instanceof JspxImportStatement
&& context != ((JspxImportStatement) currentFileResolveScope).getDeclarationFile()) {
continue;
}
if (refElement != null) {
// Add names imported statically
if (referenceElement != null) {
if (currentFileResolveScope instanceof PsiImportStaticStatement) {
PsiImportStaticStatement importStaticStatement =
(PsiImportStaticStatement) currentFileResolveScope;
String name = importStaticStatement.getImportReference().getCanonicalText();
if (importStaticStatement.isOnDemand()) {
String refName = referenceElement.getReferenceName();
if (refName != null) name = name + "." + refName;
}
names.add(name);
namesToImportStaticly.add(name);
continue;
}
}
if (refElement instanceof PsiClass) {
String qName = ((PsiClass) refElement).getQualifiedName();
if (hasPackage(qName, thisPackageName)) continue;
names.add(qName);
}
}
}
}
}
private NamesByExprInfo suggestVariableNameByExpressionPlace(
PsiExpression expr, final VariableKind variableKind, boolean correctKeywords) {
if (expr.getParent() instanceof PsiExpressionList) {
PsiExpressionList list = (PsiExpressionList) expr.getParent();
PsiElement listParent = list.getParent();
PsiSubstitutor subst = PsiSubstitutor.EMPTY;
PsiMethod method = null;
if (listParent instanceof PsiMethodCallExpression) {
final JavaResolveResult resolveResult =
((PsiMethodCallExpression) listParent).getMethodExpression().advancedResolve(false);
method = (PsiMethod) resolveResult.getElement();
subst = resolveResult.getSubstitutor();
} else {
if (listParent instanceof PsiAnonymousClass) {
listParent = listParent.getParent();
}
if (listParent instanceof PsiNewExpression) {
method = ((PsiNewExpression) listParent).resolveConstructor();
}
}
if (method != null) {
final PsiElement navElement = method.getNavigationElement();
if (navElement instanceof PsiMethod) {
method = (PsiMethod) navElement;
}
PsiExpression[] expressions = list.getExpressions();
int index = -1;
for (int i = 0; i < expressions.length; i++) {
if (expressions[i] == expr) {
index = i;
break;
}
}
PsiParameter[] parameters = method.getParameterList().getParameters();
if (index < parameters.length) {
String name = parameters[index].getName();
if (name != null
&& TypeConversionUtil.areTypesAssignmentCompatible(
subst.substitute(parameters[index].getType()), expr)) {
name = variableNameToPropertyName(name, VariableKind.PARAMETER);
String[] names = getSuggestionsByName(name, variableKind, false, correctKeywords);
if (expressions.length == 1) {
final String methodName = method.getName();
String[] words = NameUtil.nameToWords(methodName);
if (words.length > 0) {
final String firstWord = words[0];
if (SET_PREFIX.equals(firstWord)) {
final String propertyName = methodName.substring(firstWord.length());
final String[] setterNames =
getSuggestionsByName(propertyName, variableKind, false, correctKeywords);
names = ArrayUtil.mergeArrays(names, setterNames);
}
}
}
return new NamesByExprInfo(name, names);
}
}
}
} else if (expr.getParent() instanceof PsiAssignmentExpression
&& variableKind == VariableKind.PARAMETER) {
final PsiAssignmentExpression assignmentExpression =
(PsiAssignmentExpression) expr.getParent();
if (expr == assignmentExpression.getRExpression()) {
final PsiExpression leftExpression = assignmentExpression.getLExpression();
if (leftExpression instanceof PsiReferenceExpression
&& ((PsiReferenceExpression) leftExpression).getQualifier() == null) {
String name = leftExpression.getText();
if (name != null) {
final PsiElement resolve = ((PsiReferenceExpression) leftExpression).resolve();
if (resolve instanceof PsiVariable) {
name = variableNameToPropertyName(name, getVariableKind((PsiVariable) resolve));
}
String[] names = getSuggestionsByName(name, variableKind, false, correctKeywords);
return new NamesByExprInfo(name, names);
}
}
}
}
return new NamesByExprInfo(null, ArrayUtil.EMPTY_STRING_ARRAY);
}
public void registerCastActions(
CandidateInfo[] candidates,
PsiCall call,
HighlightInfo highlightInfo,
final TextRange fixRange) {
if (candidates.length == 0) return;
List<CandidateInfo> methodCandidates = new ArrayList<CandidateInfo>(Arrays.asList(candidates));
PsiExpressionList list = call.getArgumentList();
PsiExpression[] expressions = list.getExpressions();
if (expressions.length == 0) return;
// filter out not castable candidates
nextMethod:
for (int i = methodCandidates.size() - 1; i >= 0; i--) {
CandidateInfo candidate = methodCandidates.get(i);
PsiMethod method = (PsiMethod) candidate.getElement();
PsiSubstitutor substitutor = candidate.getSubstitutor();
assert method != null;
PsiParameter[] parameters = method.getParameterList().getParameters();
if (expressions.length != parameters.length) {
methodCandidates.remove(i);
continue;
}
for (int j = 0; j < parameters.length; j++) {
PsiParameter parameter = parameters[j];
PsiExpression expression = expressions[j];
// check if we can cast to this method
PsiType exprType = expression.getType();
PsiType parameterType = substitutor.substitute(parameter.getType());
if (exprType == null
|| parameterType == null
|| !areTypesConvertible(exprType, parameterType, call)) {
methodCandidates.remove(i);
continue nextMethod;
}
}
}
if (methodCandidates.isEmpty()) return;
try {
for (int i = 0; i < expressions.length; i++) {
PsiExpression expression = expressions[i];
PsiType exprType = expression.getType();
Set<String> suggestedCasts = new THashSet<String>();
// find to which type we can cast this param to get valid method call
for (CandidateInfo candidate : methodCandidates) {
PsiMethod method = (PsiMethod) candidate.getElement();
PsiSubstitutor substitutor = candidate.getSubstitutor();
assert method != null;
PsiParameter[] parameters = method.getParameterList().getParameters();
PsiType originalParameterType = parameters[i].getType();
PsiType parameterType = substitutor.substitute(originalParameterType);
if (parameterType instanceof PsiWildcardType) continue;
if (!GenericsUtil.isFromExternalTypeLanguage(parameterType)) continue;
if (suggestedCasts.contains(parameterType.getCanonicalText())) continue;
// strict compare since even widening cast may help
if (Comparing.equal(exprType, parameterType)) continue;
PsiCall newCall = (PsiCall) call.copy();
PsiExpression modifiedExpression = getModifiedArgument(expression, parameterType);
if (modifiedExpression == null) continue;
newCall.getArgumentList().getExpressions()[i].replace(modifiedExpression);
JavaResolveResult resolveResult = newCall.resolveMethodGenerics();
if (resolveResult.getElement() != null && resolveResult.isValidResult()) {
suggestedCasts.add(parameterType.getCanonicalText());
QuickFixAction.registerQuickFixAction(
highlightInfo, fixRange, createFix(list, i, parameterType), null);
}
}
}
} catch (IncorrectOperationException e) {
LOG.error(e);
}
}
@NotNull
public JavaResolveResult[] multiResolve(boolean incompleteCode) {
final JavaResolveResult javaResolveResult = advancedResolve(incompleteCode);
if (javaResolveResult.getElement() == null) return JavaResolveResult.EMPTY_ARRAY;
return new JavaResolveResult[] {javaResolveResult};
}