private void addTypesByVariable(
HashSet<PsiType> typesSet,
PsiVariable var,
PsiFile scopeFile,
HashSet<PsiVariable> checkedVariables,
int flags,
TextRange rangeToIgnore) {
if (!checkedVariables.add(var)) return;
// System.out.println("analyzing usages of " + var + " in file " + scopeFile);
SearchScope searchScope = new LocalSearchScope(scopeFile);
if (BitUtil.isSet(flags, CHECK_USAGE) || BitUtil.isSet(flags, CHECK_DOWN)) {
for (PsiReference varRef : ReferencesSearch.search(var, searchScope, false)) {
PsiElement ref = varRef.getElement();
if (BitUtil.isSet(flags, CHECK_USAGE)) {
PsiType type = guessElementTypeFromReference(myMethodPatternMap, ref, rangeToIgnore);
if (type != null && !(type instanceof PsiPrimitiveType)) {
typesSet.add(type);
}
}
if (BitUtil.isSet(flags, CHECK_DOWN)) {
if (ref.getParent() instanceof PsiExpressionList
&& ref.getParent().getParent() instanceof PsiMethodCallExpression) { // TODO : new
PsiExpressionList list = (PsiExpressionList) ref.getParent();
PsiExpression[] args = list.getExpressions();
int argIndex = -1;
for (int j = 0; j < args.length; j++) {
PsiExpression arg = args[j];
if (arg.equals(ref)) {
argIndex = j;
break;
}
}
PsiMethodCallExpression methodCall = (PsiMethodCallExpression) list.getParent();
PsiMethod method = (PsiMethod) methodCall.getMethodExpression().resolve();
if (method != null) {
PsiParameter[] parameters = method.getParameterList().getParameters();
if (argIndex < parameters.length) {
addTypesByVariable(
typesSet,
parameters[argIndex],
method.getContainingFile(),
checkedVariables,
flags | CHECK_USAGE,
rangeToIgnore);
}
}
}
}
}
}
if (BitUtil.isSet(flags, CHECK_UP)) {
if (var instanceof PsiParameter
&& var.getParent() instanceof PsiParameterList
&& var.getParent().getParent() instanceof PsiMethod) {
PsiParameterList list = (PsiParameterList) var.getParent();
PsiParameter[] parameters = list.getParameters();
int argIndex = -1;
for (int i = 0; i < parameters.length; i++) {
PsiParameter parameter = parameters[i];
if (parameter.equals(var)) {
argIndex = i;
break;
}
}
PsiMethod method = (PsiMethod) var.getParent().getParent();
// System.out.println("analyzing usages of " + method + " in file " + scopeFile);
for (PsiReference methodRef : ReferencesSearch.search(method, searchScope, false)) {
PsiElement ref = methodRef.getElement();
if (ref.getParent() instanceof PsiMethodCallExpression) {
PsiMethodCallExpression methodCall = (PsiMethodCallExpression) ref.getParent();
PsiExpression[] args = methodCall.getArgumentList().getExpressions();
if (args.length <= argIndex) continue;
PsiExpression arg = args[argIndex];
if (arg instanceof PsiReferenceExpression) {
PsiElement refElement = ((PsiReferenceExpression) arg).resolve();
if (refElement instanceof PsiVariable) {
addTypesByVariable(
typesSet,
(PsiVariable) refElement,
scopeFile,
checkedVariables,
flags | CHECK_USAGE,
rangeToIgnore);
}
}
// TODO : constructor
}
}
}
}
}
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);
}
@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;
}