@Nullable
public static PsiType getFunctionalInterfaceReturnType(
@Nullable PsiType functionalInterfaceType) {
final PsiClassType.ClassResolveResult resolveResult =
PsiUtil.resolveGenericsClassInType(functionalInterfaceType);
final PsiClass psiClass = resolveResult.getElement();
if (psiClass != null) {
final MethodSignature methodSignature = getFunction(psiClass);
if (methodSignature != null) {
final PsiType returnType = getReturnType(psiClass, methodSignature);
return resolveResult.getSubstitutor().substitute(returnType);
}
}
return null;
}
private static PsiType getLambdaParameterFromType(
int parameterIndex, PsiLambdaExpression lambdaExpression, PsiType conjunct) {
final PsiClassType.ClassResolveResult resolveResult =
PsiUtil.resolveGenericsClassInType(conjunct);
if (resolveResult != null) {
final PsiMethod method = getFunctionalInterfaceMethod(conjunct);
if (method != null) {
final PsiParameter[] parameters = method.getParameterList().getParameters();
if (parameterIndex < parameters.length) {
final PsiType psiType =
getSubstitutor(method, resolveResult)
.substitute(parameters[parameterIndex].getType());
if (!dependsOnTypeParams(psiType, conjunct, lambdaExpression)) {
return GenericsUtil.eliminateWildcards(psiType);
}
}
}
}
return null;
}
public TypeParamsChecker(PsiElement expression) {
this(
expression,
PsiUtil.resolveGenericsClassInType(getFunctionalInterfaceType(expression, false))
.getElement());
}
@Nullable
public static PsiMethod getFunctionalInterfaceMethod(@Nullable PsiType functionalInterfaceType) {
return getFunctionalInterfaceMethod(
PsiUtil.resolveGenericsClassInType(functionalInterfaceType));
}
@Nullable
public static PsiType getFunctionalInterfaceType(
PsiElement expression, final boolean tryToSubstitute, int paramIdx) {
PsiElement parent = expression.getParent();
PsiElement element = expression;
while (parent instanceof PsiParenthesizedExpression
|| parent instanceof PsiConditionalExpression) {
if (parent instanceof PsiConditionalExpression
&& ((PsiConditionalExpression) parent).getThenExpression() != element
&& ((PsiConditionalExpression) parent).getElseExpression() != element) break;
element = parent;
parent = parent.getParent();
}
if (parent instanceof PsiArrayInitializerExpression) {
final PsiType psiType = ((PsiArrayInitializerExpression) parent).getType();
if (psiType instanceof PsiArrayType) {
return ((PsiArrayType) psiType).getComponentType();
}
} else if (parent instanceof PsiTypeCastExpression) {
final PsiType castType = ((PsiTypeCastExpression) parent).getType();
if (castType instanceof PsiIntersectionType) {
for (PsiType conjunctType : ((PsiIntersectionType) castType).getConjuncts()) {
if (getFunctionalInterfaceMethod(conjunctType) != null) return conjunctType;
}
}
return castType;
} else if (parent instanceof PsiVariable) {
return ((PsiVariable) parent).getType();
} else if (parent instanceof PsiAssignmentExpression
&& expression instanceof PsiExpression
&& !PsiUtil.isOnAssignmentLeftHand((PsiExpression) expression)) {
final PsiExpression lExpression = ((PsiAssignmentExpression) parent).getLExpression();
return lExpression.getType();
} else if (parent instanceof PsiExpressionList) {
final PsiExpressionList expressionList = (PsiExpressionList) parent;
final int lambdaIdx = getLambdaIdx(expressionList, expression);
if (lambdaIdx > -1) {
PsiType cachedType = null;
final Pair<PsiMethod, PsiSubstitutor> method = MethodCandidateInfo.getCurrentMethod(parent);
if (method != null) {
final PsiParameter[] parameters = method.first.getParameterList().getParameters();
cachedType =
lambdaIdx < parameters.length
? method.second.substitute(
getNormalizedType(
parameters[adjustLambdaIdx(lambdaIdx, method.first, parameters)]))
: null;
if (!tryToSubstitute) return cachedType;
}
PsiElement gParent = expressionList.getParent();
if (gParent instanceof PsiAnonymousClass) {
gParent = gParent.getParent();
}
if (gParent instanceof PsiCall) {
final PsiCall contextCall = (PsiCall) gParent;
final JavaResolveResult resolveResult = contextCall.resolveMethodGenerics();
final PsiElement resolve = resolveResult.getElement();
if (resolve instanceof PsiMethod) {
final PsiParameter[] parameters =
((PsiMethod) resolve).getParameterList().getParameters();
final int finalLambdaIdx = adjustLambdaIdx(lambdaIdx, (PsiMethod) resolve, parameters);
if (finalLambdaIdx < parameters.length) {
if (!tryToSubstitute) return getNormalizedType(parameters[finalLambdaIdx]);
if (cachedType != null && paramIdx > -1) {
final PsiMethod interfaceMethod = getFunctionalInterfaceMethod(cachedType);
if (interfaceMethod != null) {
final PsiClassType.ClassResolveResult cachedResult =
PsiUtil.resolveGenericsClassInType(cachedType);
final PsiType interfaceMethodParameterType =
interfaceMethod.getParameterList().getParameters()[paramIdx].getType();
if (!dependsOnTypeParams(
cachedResult.getSubstitutor().substitute(interfaceMethodParameterType),
cachedType,
expression)) {
return cachedType;
}
}
}
return PsiResolveHelper.ourGuard.doPreventingRecursion(
expression,
true,
new Computable<PsiType>() {
@Override
public PsiType compute() {
return resolveResult
.getSubstitutor()
.substitute(getNormalizedType(parameters[finalLambdaIdx]));
}
});
}
}
return null;
}
}
} else if (parent instanceof PsiReturnStatement) {
final PsiLambdaExpression gParent =
PsiTreeUtil.getParentOfType(parent, PsiLambdaExpression.class);
if (gParent != null) {
return getFunctionalInterfaceTypeByContainingLambda(gParent);
} else {
final PsiMethod method = PsiTreeUtil.getParentOfType(parent, PsiMethod.class);
if (method != null) {
return method.getReturnType();
}
}
} else if (parent instanceof PsiLambdaExpression) {
return getFunctionalInterfaceTypeByContainingLambda((PsiLambdaExpression) parent);
}
return null;
}
public static boolean isAcceptable(
PsiLambdaExpression lambdaExpression, final PsiType leftType, boolean checkReturnType) {
if (leftType instanceof PsiIntersectionType) {
for (PsiType conjunctType : ((PsiIntersectionType) leftType).getConjuncts()) {
if (isAcceptable(lambdaExpression, conjunctType, checkReturnType)) return true;
}
return false;
}
final PsiClassType.ClassResolveResult resolveResult =
PsiUtil.resolveGenericsClassInType(GenericsUtil.eliminateWildcards(leftType));
final PsiClass psiClass = resolveResult.getElement();
if (psiClass instanceof PsiAnonymousClass) {
return isAcceptable(
lambdaExpression, ((PsiAnonymousClass) psiClass).getBaseClassType(), checkReturnType);
}
final MethodSignature methodSignature = getFunction(psiClass);
if (methodSignature == null) return false;
final PsiParameter[] lambdaParameters = lambdaExpression.getParameterList().getParameters();
final PsiType[] parameterTypes = methodSignature.getParameterTypes();
if (lambdaParameters.length != parameterTypes.length) return false;
for (int lambdaParamIdx = 0, length = lambdaParameters.length;
lambdaParamIdx < length;
lambdaParamIdx++) {
PsiParameter parameter = lambdaParameters[lambdaParamIdx];
final PsiTypeElement typeElement = parameter.getTypeElement();
if (typeElement != null) {
final PsiType lambdaFormalType = typeElement.getType();
final PsiType methodParameterType = parameterTypes[lambdaParamIdx];
if (lambdaFormalType instanceof PsiPrimitiveType) {
if (methodParameterType instanceof PsiPrimitiveType)
return methodParameterType.equals(lambdaFormalType);
return false;
}
if (!TypeConversionUtil.erasure(lambdaFormalType)
.isAssignableFrom(
TypeConversionUtil.erasure(
GenericsUtil.eliminateWildcards(
resolveResult
.getSubstitutor()
.substitute(
methodSignature
.getSubstitutor()
.substitute(methodParameterType)))))) {
return false;
}
}
}
if (checkReturnType) {
final String uniqueVarName =
JavaCodeStyleManager.getInstance(lambdaExpression.getProject())
.suggestUniqueVariableName("l", lambdaExpression, true);
String canonicalText = leftType.getCanonicalText();
if (leftType instanceof PsiEllipsisType) {
canonicalText = ((PsiEllipsisType) leftType).toArrayType().getCanonicalText();
}
final PsiStatement assignmentFromText =
JavaPsiFacade.getElementFactory(lambdaExpression.getProject())
.createStatementFromText(
canonicalText + " " + uniqueVarName + " = " + lambdaExpression.getText(),
lambdaExpression);
final PsiLocalVariable localVariable =
(PsiLocalVariable)
((PsiDeclarationStatement) assignmentFromText).getDeclaredElements()[0];
LOG.assertTrue(psiClass != null);
PsiType methodReturnType = getReturnType(psiClass, methodSignature);
if (methodReturnType != null) {
methodReturnType =
resolveResult
.getSubstitutor()
.substitute(methodSignature.getSubstitutor().substitute(methodReturnType));
return LambdaHighlightingUtil.checkReturnTypeCompatible(
(PsiLambdaExpression) localVariable.getInitializer(), methodReturnType)
== null;
}
}
return true;
}
