private NamesByExprInfo suggestVariableNameByExpression(
PsiExpression expr, VariableKind variableKind, boolean correctKeywords) {
final LinkedHashSet<String> names = new LinkedHashSet<String>();
final String[] fromLiterals =
suggestVariableNameFromLiterals(expr, variableKind, correctKeywords);
if (fromLiterals != null) {
ContainerUtil.addAll(names, fromLiterals);
}
ContainerUtil.addAll(
names,
suggestVariableNameByExpressionOnly(expr, variableKind, correctKeywords, false).names);
ContainerUtil.addAll(
names, suggestVariableNameByExpressionPlace(expr, variableKind, correctKeywords).names);
PsiType type = expr.getType();
if (type != null) {
ContainerUtil.addAll(names, suggestVariableNameByType(type, variableKind, correctKeywords));
}
ContainerUtil.addAll(
names,
suggestVariableNameByExpressionOnly(expr, variableKind, correctKeywords, true).names);
String[] namesArray = ArrayUtil.toStringArray(names);
String propertyName =
suggestVariableNameByExpressionOnly(expr, variableKind, correctKeywords, false).propertyName
!= null
? suggestVariableNameByExpressionOnly(expr, variableKind, correctKeywords, false)
.propertyName
: suggestVariableNameByExpressionPlace(expr, variableKind, correctKeywords)
.propertyName;
return new NamesByExprInfo(propertyName, namesArray);
}
@Nullable
private String[] suggestVariableNameFromLiterals(
PsiExpression expr, VariableKind variableKind, boolean correctKeywords) {
final PsiElement[] literals =
PsiTreeUtil.collectElements(
expr,
new PsiElementFilter() {
@Override
public boolean isAccepted(PsiElement element) {
if (isStringPsiLiteral(element)
&& StringUtil.isJavaIdentifier(StringUtil.unquoteString(element.getText()))) {
final PsiElement exprList = element.getParent();
if (exprList instanceof PsiExpressionList) {
final PsiElement call = exprList.getParent();
if (call instanceof PsiNewExpression) {
return true;
} else if (call instanceof PsiMethodCallExpression) {
// TODO: exclude or not getA().getB("name").getC(); or
// getA(getB("name").getC()); It works fine for now in the most cases
return true;
}
}
}
return false;
}
});
if (literals.length == 1) {
final String text = StringUtil.unquoteString(literals[0].getText());
return getSuggestionsByName(
text, variableKind, expr.getType() instanceof PsiArrayType, correctKeywords);
}
return null;
}
@Override
public SuggestedNameInfo suggestVariableName(
@NotNull final VariableKind kind,
@Nullable final String propertyName,
@Nullable final PsiExpression expr,
@Nullable PsiType type,
final boolean correctKeywords) {
LinkedHashSet<String> names = new LinkedHashSet<String>();
if (expr != null && type == null) {
type = expr.getType();
}
if (propertyName != null) {
String[] namesByName = getSuggestionsByName(propertyName, kind, false, correctKeywords);
sortVariableNameSuggestions(namesByName, kind, propertyName, null);
ContainerUtil.addAll(names, namesByName);
}
final NamesByExprInfo namesByExpr;
if (expr != null) {
namesByExpr = suggestVariableNameByExpression(expr, kind, correctKeywords);
if (namesByExpr.propertyName != null) {
sortVariableNameSuggestions(namesByExpr.names, kind, namesByExpr.propertyName, null);
}
ContainerUtil.addAll(names, namesByExpr.names);
} else {
namesByExpr = null;
}
if (type != null) {
String[] namesByType = suggestVariableNameByType(type, kind, correctKeywords);
sortVariableNameSuggestions(namesByType, kind, null, type);
ContainerUtil.addAll(names, namesByType);
}
final String _propertyName;
if (propertyName != null) {
_propertyName = propertyName;
} else {
_propertyName = namesByExpr != null ? namesByExpr.propertyName : null;
}
addNamesFromStatistics(names, kind, _propertyName, type);
String[] namesArray = ArrayUtil.toStringArray(names);
sortVariableNameSuggestions(namesArray, kind, _propertyName, type);
final PsiType _type = type;
return new SuggestedNameInfo(namesArray) {
@Override
public void nameChosen(String name) {
if (_propertyName != null || _type != null && _type.isValid()) {
JavaStatisticsManager.incVariableNameUseCount(name, kind, _propertyName, _type);
}
}
};
}