@Override
public void visitMethodCallExpression(PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
@NonNls final String referenceName = methodExpression.getReferenceName();
if (!"toString".equals(referenceName)
|| ExpressionUtils.isConversionToStringNecessary(expression)) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 0) {
return;
}
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (qualifier != null) {
if (qualifier.getType() instanceof PsiArrayType) {
// do not warn on nonsensical code
return;
} else if (qualifier instanceof PsiSuperExpression) {
return;
}
}
registerMethodCallError(expression, calculateReplacementText(qualifier));
}
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
final String methodName = methodExpression.getReferenceName();
@NonNls final String signal = "signal";
if (!signal.equals(methodName)) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
if (argumentList.getExpressions().length != 0) {
return;
}
final PsiMethod method = expression.resolveMethod();
if (method == null) {
return;
}
final PsiClass containingClass = method.getContainingClass();
if (containingClass == null) {
return;
}
if (!ClassUtils.isSubclass(containingClass, "java.util.concurrent.locks.Condition")) {
return;
}
registerMethodCallError(expression);
}
@Override
public void doFix(Project project, ProblemDescriptor descriptor)
throws IncorrectOperationException {
final PsiIdentifier name = (PsiIdentifier) descriptor.getPsiElement();
final PsiReferenceExpression expression = (PsiReferenceExpression) name.getParent();
if (expression == null) {
return;
}
final PsiMethodCallExpression call = (PsiMethodCallExpression) expression.getParent();
final String methodName = expression.getReferenceName();
if (call == null) {
return;
}
final PsiMethod method = call.resolveMethod();
if (method == null) {
return;
}
final PsiClass containingClass = method.getContainingClass();
final PsiExpressionList argumentList = call.getArgumentList();
if (containingClass == null) {
return;
}
final String containingClassName = containingClass.getQualifiedName();
final String argText = argumentList.getText();
PsiReplacementUtil.replaceExpressionAndShorten(
call, containingClassName + '.' + methodName + argText);
}
@Nullable
private static PsiType guessElementTypeFromReference(
MethodPatternMap methodPatternMap, PsiElement ref, TextRange rangeToIgnore) {
PsiElement refParent = ref.getParent();
if (refParent instanceof PsiReferenceExpression) {
PsiReferenceExpression parentExpr = (PsiReferenceExpression) refParent;
if (ref.equals(parentExpr.getQualifierExpression())
&& parentExpr.getParent() instanceof PsiMethodCallExpression) {
String methodName = parentExpr.getReferenceName();
PsiMethodCallExpression methodCall = (PsiMethodCallExpression) parentExpr.getParent();
PsiExpression[] args = methodCall.getArgumentList().getExpressions();
MethodPattern pattern = methodPatternMap.findPattern(methodName, args.length);
if (pattern != null) {
if (pattern.parameterIndex < 0) { // return value
if (methodCall.getParent() instanceof PsiTypeCastExpression
&& (rangeToIgnore == null || !rangeToIgnore.contains(methodCall.getTextRange()))) {
return ((PsiTypeCastExpression) methodCall.getParent()).getType();
}
} else {
return args[pattern.parameterIndex].getType();
}
}
}
}
return null;
}
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
@NonNls final String methodName = methodExpression.getReferenceName();
if (methodName == null) {
return;
}
if (!methodName.startsWith("get") && !methodName.startsWith("update")) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length == 0) {
return;
}
final PsiExpression argument = arguments[0];
if (!TypeUtils.expressionHasType(argument, PsiKeyword.INT)) {
return;
}
if (!PsiUtil.isConstantExpression(argument)) {
return;
}
final Integer val = (Integer) ConstantExpressionUtil.computeCastTo(argument, PsiType.INT);
if (val == null || val.intValue() != 0) {
return;
}
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (!TypeUtils.expressionHasTypeOrSubtype(qualifier, "java.sql.ResultSet")) {
return;
}
registerError(argument);
}
private static boolean isIndexOfCall(@NotNull PsiMethodCallExpression expression) {
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
final String methodName = methodExpression.getReferenceName();
if (!HardcodedMethodConstants.INDEX_OF.equals(methodName)) {
return false;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 1) {
return false;
}
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (qualifier == null) {
return false;
}
final PsiType qualifierType = qualifier.getType();
if (qualifierType == null) {
return false;
}
final Project project = expression.getProject();
final GlobalSearchScope projectScope = GlobalSearchScope.allScope(project);
final JavaPsiFacade psiFacade = JavaPsiFacade.getInstance(project);
final PsiClass javaUtilListClass =
psiFacade.findClass(CommonClassNames.JAVA_UTIL_LIST, projectScope);
if (javaUtilListClass == null) {
return false;
}
final PsiElementFactory factory = psiFacade.getElementFactory();
final PsiClassType javaUtilListType = factory.createType(javaUtilListClass);
return javaUtilListType.isAssignableFrom(qualifierType);
}
public static boolean isJUnitAssertCall(PsiMethodCallExpression call) {
final PsiMethod containingMethod = PsiTreeUtil.getParentOfType(call, PsiMethod.class);
if (containingMethod == null) {
return false;
}
final PsiReferenceExpression methodExpression = call.getMethodExpression();
@NonNls final String methodName = methodExpression.getReferenceName();
return methodName != null
&& (methodName.startsWith("assert") || "fail".equals(methodName))
&& isJUnitTestMethod(containingMethod);
}
@Override
public void visitMethodCallExpression(PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
final String methodName = methodExpression.getReferenceName();
if (!"cast".equals(methodName)) {
return;
}
final PsiMethod method = expression.resolveMethod();
if (method == null) {
return;
}
final PsiClass containingClass = method.getContainingClass();
if (containingClass == null) {
return;
}
final String qualifiedName = containingClass.getQualifiedName();
if (!"java.lang.Class".equals(qualifiedName)) {
return;
}
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (!(qualifier instanceof PsiClassObjectAccessExpression)) {
return;
}
final PsiClassObjectAccessExpression classObjectAccessExpression =
(PsiClassObjectAccessExpression) qualifier;
final PsiTypeElement operand = classObjectAccessExpression.getOperand();
final PsiType castType = operand.getType();
if (!(castType instanceof PsiClassType)) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 1) {
return;
}
final PsiExpression argument = arguments[0];
if (!(argument instanceof PsiReferenceExpression)) {
return;
}
final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) argument;
final PsiInstanceOfExpression conflictingInstanceof =
InstanceOfUtils.getConflictingInstanceof(castType, referenceExpression, expression);
if (conflictingInstanceof == null) {
return;
}
final PsiTypeElement instanceofTypeElement = conflictingInstanceof.getCheckType();
registerError(expression, referenceExpression, operand, instanceofTypeElement);
}
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression call) {
if (containsAssertion) {
return;
}
super.visitMethodCallExpression(call);
final PsiReferenceExpression methodExpression = call.getMethodExpression();
@NonNls final String methodName = methodExpression.getReferenceName();
if (methodName == null) {
return;
}
if (methodName.startsWith("assert") || methodName.startsWith("fail")) {
containsAssertion = true;
}
}
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
final String methodName = methodExpression.getReferenceName();
if (!HardcodedMethodConstants.NOTIFY.equals(methodName)) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
if (argumentList.getExpressions().length != 0) {
return;
}
registerMethodCallError(expression);
}
@Override
public void visitMethodCallExpression(PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
@NonNls final String name = methodExpression.getReferenceName();
if (HardcodedMethodConstants.TO_STRING.equals(name)) {
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 0) {
return;
}
final PsiExpression qualifier = methodExpression.getQualifierExpression();
checkExpression(qualifier);
} else if ("append".equals(name)) {
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (!TypeUtils.expressionHasTypeOrSubtype(
qualifier, CommonClassNames.JAVA_LANG_ABSTRACT_STRING_BUILDER)) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 1) {
return;
}
final PsiExpression argument = arguments[0];
checkExpression(argument);
} else if ("valueOf".equals(name)) {
final PsiExpression qualifierExpression = methodExpression.getQualifierExpression();
if (!(qualifierExpression instanceof PsiReferenceExpression)) {
return;
}
final PsiReferenceExpression referenceExpression =
(PsiReferenceExpression) qualifierExpression;
final String canonicalText = referenceExpression.getCanonicalText();
if (!CommonClassNames.JAVA_LANG_STRING.equals(canonicalText)) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 1) {
return;
}
final PsiExpression argument = arguments[0];
checkExpression(argument);
}
}
private static boolean callTakesXPathExpression(PsiMethodCallExpression expression) {
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
final String name = methodExpression.getReferenceName();
if (!xpathMethodNames.contains(name)) {
return false;
}
final PsiMethod method = expression.resolveMethod();
if (method == null) {
return false;
}
final PsiClass containingClass = method.getContainingClass();
if (containingClass == null) {
return false;
}
final String className = containingClass.getQualifiedName();
return "javax.xml.xpath.XPath".equals(className);
}
@Override
public void visitExpressionStatement(@NotNull PsiExpressionStatement statement) {
super.visitExpressionStatement(statement);
final PsiExpression expression = statement.getExpression();
if (!(expression instanceof PsiMethodCallExpression)) {
return;
}
final PsiMethodCallExpression call = (PsiMethodCallExpression) expression;
final PsiMethod method = call.resolveMethod();
if (method == null || method.isConstructor()) {
return;
}
final PsiType returnType = method.getReturnType();
if (PsiType.VOID.equals(returnType)) {
return;
}
final PsiClass aClass = method.getContainingClass();
if (aClass == null) {
return;
}
if (PsiUtilCore.hasErrorElementChild(statement)) {
return;
}
if (m_reportAllNonLibraryCalls && !LibraryUtil.classIsInLibrary(aClass)) {
registerMethodCallError(call, aClass);
return;
}
final PsiReferenceExpression methodExpression = call.getMethodExpression();
final String methodName = methodExpression.getReferenceName();
if (methodName == null) {
return;
}
for (int i = 0; i < methodNamePatterns.size(); i++) {
final String methodNamePattern = methodNamePatterns.get(i);
if (!methodNamesMatch(methodName, methodNamePattern)) {
continue;
}
final String className = classNames.get(i);
if (!InheritanceUtil.isInheritor(aClass, className)) {
continue;
}
registerMethodCallError(call, aClass);
return;
}
}
private boolean isIteratorNext(
PsiElement element, String iteratorName, PsiType contentType) {
if (element == null) {
return false;
}
if (element instanceof PsiTypeCastExpression) {
final PsiTypeCastExpression castExpression =
(PsiTypeCastExpression)element;
final PsiType type = castExpression.getType();
if (type == null) {
return false;
}
if (!type.equals(contentType)) {
return false;
}
final PsiExpression operand =
castExpression.getOperand();
return isIteratorNext(operand, iteratorName, contentType);
}
if (!(element instanceof PsiMethodCallExpression)) {
return false;
}
final PsiMethodCallExpression callExpression =
(PsiMethodCallExpression)element;
final PsiExpressionList argumentList =
callExpression.getArgumentList();
final PsiExpression[] args = argumentList.getExpressions();
if (args.length != 0) {
return false;
}
final PsiReferenceExpression reference =
callExpression.getMethodExpression();
final PsiExpression qualifier = reference.getQualifierExpression();
if (qualifier == null) {
return false;
}
if (!iteratorName.equals(qualifier.getText())) {
return false;
}
final String referenceName = reference.getReferenceName();
return HardcodedMethodConstants.NEXT.equals(referenceName);
}
public boolean isAvailable(@NotNull Project project, Editor editor, PsiFile file) {
if (!(file instanceof PsiJavaFile)) return false;
if (myUnresolvedReference.isQualified()) return false;
final String referenceName = myUnresolvedReference.getReferenceName();
if (referenceName == null) return false;
PsiManager manager = file.getManager();
if (!myUnresolvedReference.isValid() || !manager.isInProject(myUnresolvedReference))
return false;
PsiElement container =
PsiTreeUtil.getParentOfType(myUnresolvedReference, PsiCodeBlock.class, PsiClass.class);
if (!(container instanceof PsiCodeBlock)) return false;
myOutOfScopeVariable = null;
while (container.getParent() instanceof PsiStatement
|| container.getParent() instanceof PsiCatchSection) container = container.getParent();
container.accept(
new JavaRecursiveElementWalkingVisitor() {
@Override
public void visitReferenceExpression(PsiReferenceExpression expression) {}
@Override
public void visitExpression(PsiExpression expression) {
// Don't look inside expressions
}
@Override
public void visitLocalVariable(PsiLocalVariable variable) {
if (referenceName.equals(variable.getName())) {
if (myOutOfScopeVariable == null) {
myOutOfScopeVariable = variable;
} else {
myOutOfScopeVariable = null; // 2 conflict variables
}
}
}
});
return myOutOfScopeVariable != null;
}
private boolean isAddedToCollection(PsiExpression expression) {
final PsiElement parent = expression.getParent();
if (!(parent instanceof PsiExpressionList)) {
return false;
}
final PsiExpressionList expressionList = (PsiExpressionList) parent;
final PsiElement grandParent = expressionList.getParent();
if (!(grandParent instanceof PsiMethodCallExpression)) {
return false;
}
final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) grandParent;
final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression();
@NonNls final String methodName = methodExpression.getReferenceName();
if (!"put".equals(methodName) && !"set".equals(methodName) && !"add".equals(methodName)) {
return false;
}
final PsiExpression qualifier = methodExpression.getQualifierExpression();
return TypeUtils.expressionHasTypeOrSubtype(
qualifier, CommonClassNames.JAVA_UTIL_COLLECTION, CommonClassNames.JAVA_UTIL_MAP)
!= null;
}
private void addExprTypesWhenContainerElement(LinkedHashSet<PsiType> set, PsiExpression expr) {
if (expr instanceof PsiMethodCallExpression) {
PsiMethodCallExpression callExpr = (PsiMethodCallExpression) expr;
PsiReferenceExpression methodExpr = callExpr.getMethodExpression();
String methodName = methodExpr.getReferenceName();
MethodPattern pattern =
myMethodPatternMap.findPattern(
methodName, callExpr.getArgumentList().getExpressions().length);
if (pattern != null && pattern.parameterIndex < 0 /* return value */) {
PsiExpression qualifier = methodExpr.getQualifierExpression();
if (qualifier != null) {
PsiType[] types = guessContainerElementType(qualifier, null);
for (PsiType type : types) {
if (type instanceof PsiClassType) {
if (((PsiClassType) type).resolve() instanceof PsiAnonymousClass) continue;
}
set.add(type);
}
}
}
}
}
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
@NonNls final String methodName = methodExpression.getReferenceName();
if (methodName == null) {
return;
}
final boolean resultSet;
if (methodName.startsWith("get") || methodName.startsWith("update")) {
resultSet = true;
} else if (methodName.startsWith("set")) {
resultSet = false;
} else {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length == 0) {
return;
}
final PsiExpression argument = arguments[0];
final Object val = ExpressionUtils.computeConstantExpression(argument);
if (!(val instanceof Integer) || ((Integer) val).intValue() != 0) {
return;
}
final PsiExpression qualifier = methodExpression.getQualifierExpression();
if (resultSet) {
if (TypeUtils.expressionHasTypeOrSubtype(qualifier, "java.sql.ResultSet")) {
registerError(argument, Boolean.valueOf(resultSet));
}
} else {
if (TypeUtils.expressionHasTypeOrSubtype(qualifier, "java.sql.PreparedStatement")) {
registerError(argument, Boolean.valueOf(resultSet));
}
}
}
private static boolean isCallToRegexMethod(PsiMethodCallExpression expression) {
final PsiReferenceExpression methodExpression = expression.getMethodExpression();
final String name = methodExpression.getReferenceName();
if (!regexMethodNames.contains(name)) {
return false;
}
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
for (PsiExpression argument : arguments) {
if (!PsiUtil.isConstantExpression(argument)) {
return false;
}
}
final PsiMethod method = expression.resolveMethod();
if (method == null) {
return false;
}
final PsiClass containingClass = method.getContainingClass();
if (containingClass == null) {
return false;
}
final String className = containingClass.getQualifiedName();
return "java.lang.String".equals(className);
}
private static boolean isInConcatenationContext(PsiElement element) {
final PsiElement parent = element.getParent();
if (parent instanceof PsiPolyadicExpression) {
final PsiPolyadicExpression parentExpression = (PsiPolyadicExpression) parent;
final PsiType parentType = parentExpression.getType();
if (parentType == null) {
return false;
}
final String parentTypeText = parentType.getCanonicalText();
return JAVA_LANG_STRING.equals(parentTypeText);
} else if (parent instanceof PsiAssignmentExpression) {
final PsiAssignmentExpression parentExpression = (PsiAssignmentExpression) parent;
final IElementType tokenType = parentExpression.getOperationTokenType();
if (!JavaTokenType.PLUSEQ.equals(tokenType)) {
return false;
}
final PsiType parentType = parentExpression.getType();
if (parentType == null) {
return false;
}
final String parentTypeText = parentType.getCanonicalText();
return JAVA_LANG_STRING.equals(parentTypeText);
} else if (parent instanceof PsiExpressionList) {
final PsiElement grandParent = parent.getParent();
if (!(grandParent instanceof PsiMethodCallExpression)) {
return false;
}
final PsiMethodCallExpression methodCall = (PsiMethodCallExpression) grandParent;
final PsiReferenceExpression methodExpression = methodCall.getMethodExpression();
final PsiExpression qualifierExpression = methodExpression.getQualifierExpression();
final PsiType type;
if (qualifierExpression == null) {
// to use the intention inside the source of
// String and StringBuffer
type = methodExpression.getType();
} else {
type = qualifierExpression.getType();
}
if (type == null) {
return false;
}
final String className = type.getCanonicalText();
if (CommonClassNames.JAVA_LANG_STRING_BUFFER.equals(className)
|| CommonClassNames.JAVA_LANG_STRING_BUILDER.equals(className)) {
@NonNls final String methodName = methodExpression.getReferenceName();
if (!"append".equals(methodName) && !"insert".equals(methodName)) {
return false;
}
final PsiElement method = methodExpression.resolve();
return method != null;
} else if (JAVA_LANG_STRING.equals(className)) {
@NonNls final String methodName = methodExpression.getReferenceName();
if (!"indexOf".equals(methodName)
&& !"lastIndexOf".equals(methodName)
&& !"replace".equals(methodName)) {
return false;
}
final PsiElement method = methodExpression.resolve();
return method != null;
}
}
return false;
}
@Override
public void visitClassObjectAccessExpression(PsiClassObjectAccessExpression expression) {
super.visitClassObjectAccessExpression(expression);
PsiElement parent = expression.getParent();
if (parent instanceof PsiReferenceExpression) {
final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) parent;
if (!expression.equals(referenceExpression.getQualifierExpression())) {
return;
}
@NonNls final String name = referenceExpression.getReferenceName();
if (!"getName".equals(name)) {
return;
}
final PsiElement grandParent = referenceExpression.getParent();
if (!(grandParent instanceof PsiMethodCallExpression)) {
return;
}
final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) grandParent;
final PsiExpressionList list = methodCallExpression.getArgumentList();
if (list.getExpressions().length != 0) {
return;
}
parent = methodCallExpression.getParent();
}
if (!(parent instanceof PsiExpressionList)) {
return;
}
final PsiElement grandParent = parent.getParent();
if (!(grandParent instanceof PsiMethodCallExpression)) {
return;
}
final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) grandParent;
final PsiExpressionList argumentList = methodCallExpression.getArgumentList();
final PsiExpression[] expressions = argumentList.getExpressions();
if (expressions.length != 1) {
return;
}
final PsiClass containingClass = PsiTreeUtil.getParentOfType(expression, PsiClass.class);
if (containingClass == null) {
return;
}
final String containingClassName = containingClass.getName();
if (containingClassName == null) {
return;
}
final PsiMethod method = methodCallExpression.resolveMethod();
if (method == null) {
return;
}
final PsiClass aClass = method.getContainingClass();
if (aClass == null) {
return;
}
final String className = aClass.getQualifiedName();
final int index = loggerFactoryClassNames.indexOf(className);
if (index < 0) {
return;
}
final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression();
final String referenceName = methodExpression.getReferenceName();
final String loggerFactoryMethodName = loggerFactoryMethodNames.get(index);
if (!loggerFactoryMethodName.equals(referenceName)) {
return;
}
final PsiTypeElement operand = expression.getOperand();
final PsiType type = operand.getType();
if (!(type instanceof PsiClassType)) {
return;
}
final PsiClassType classType = (PsiClassType) type;
final PsiClass initializerClass = classType.resolve();
if (initializerClass == null) {
return;
}
if (containingClass.equals(initializerClass)) {
return;
}
registerError(expression, containingClassName);
}
@Override
protected void doFix(Project project, ProblemDescriptor descriptor) {
final PsiElement element = descriptor.getPsiElement();
final PsiClass aClass = ClassUtils.getContainingStaticClass(element);
if (aClass == null) {
return;
}
final PsiElement parent = element.getParent();
if (!(parent instanceof PsiReferenceExpression)) {
return;
}
final PsiReferenceExpression methodExpression = (PsiReferenceExpression) parent;
final PsiElement grandParent = methodExpression.getParent();
if (!(grandParent instanceof PsiMethodCallExpression)) {
return;
}
final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) grandParent;
final PsiExpressionList list = methodCallExpression.getArgumentList();
final PsiExpression[] expressions = list.getExpressions();
@NonNls
final StringBuilder fieldText =
new StringBuilder(
"private static final java.util.regex.Pattern PATTERN = java.util.regex.Pattern.compile(");
final int expressionsLength = expressions.length;
if (expressionsLength > 0) {
fieldText.append(expressions[0].getText());
}
@NonNls final String methodName = methodExpression.getReferenceName();
final boolean literalReplacement = "replace".equals(methodName);
if (literalReplacement) {
fieldText.append(", java.util.regex.Pattern.LITERAL");
}
fieldText.append(");");
@NonNls final StringBuilder expressionText = new StringBuilder("PATTERN.");
final PsiExpression qualifier = methodExpression.getQualifierExpression();
@NonNls final String qualifierText = (qualifier == null) ? "this" : qualifier.getText();
if ("split".equals(methodName)) {
expressionText.append(methodName);
expressionText.append('(');
expressionText.append(qualifierText);
for (int i = 1; i < expressionsLength; i++) {
expressionText.append(',').append(expressions[i].getText());
}
expressionText.append(')');
} else {
expressionText.append("matcher(").append(qualifierText).append(").");
if (literalReplacement) {
expressionText.append("replaceAll");
} else {
expressionText.append(methodName);
}
expressionText.append('(');
if (literalReplacement) {
expressionText.append("java.util.regex.Matcher.quoteReplacement(");
}
if (expressionsLength > 1) {
expressionText.append(expressions[1].getText());
for (int i = 2; i < expressionsLength; i++) {
expressionText.append(',').append(expressions[i].getText());
}
}
if (literalReplacement) {
expressionText.append(')');
}
expressionText.append(')');
}
final PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
final PsiField newField = factory.createFieldFromText(fieldText.toString(), element);
final PsiElement field = aClass.add(newField);
final PsiExpression newExpression =
factory.createExpressionFromText(expressionText.toString(), element);
PsiMethodCallExpression newMethodCallExpression =
(PsiMethodCallExpression) methodCallExpression.replace(newExpression);
newMethodCallExpression =
CodeInsightUtilCore.forcePsiPostprocessAndRestoreElement(newMethodCallExpression);
final PsiReferenceExpression reference = getReference(newMethodCallExpression);
HighlightUtils.showRenameTemplate(aClass, (PsiNameIdentifierOwner) field, reference);
}
@Override
public void visitReferenceExpression(PsiReferenceExpression expression) {
if (myWritten && myRead) {
return;
}
super.visitReferenceExpression(expression);
final PsiElement target = expression.resolve();
if (target != myVariable) {
return;
}
if (PsiUtil.isAccessedForWriting(expression)) {
final PsiElement parent =
PsiTreeUtil.skipParentsOfType(expression, PsiParenthesizedExpression.class);
if (parent instanceof PsiAssignmentExpression) {
final PsiAssignmentExpression assignmentExpression = (PsiAssignmentExpression) parent;
final PsiExpression rhs = assignmentExpression.getRExpression();
if (isComplexArrayExpression(rhs)) {
myWritten = true;
myRead = true;
} else if (!isSimpleArrayExpression(rhs)) {
myWritten = true;
}
}
return;
}
myIsReferenced = true;
PsiElement parent = getParent(expression);
if (parent instanceof PsiArrayAccessExpression) {
PsiArrayAccessExpression arrayAccessExpression = (PsiArrayAccessExpression) parent;
parent = getParent(parent);
while (parent instanceof PsiArrayAccessExpression) {
arrayAccessExpression = (PsiArrayAccessExpression) parent;
parent = getParent(parent);
}
final PsiType type = arrayAccessExpression.getType();
if (type != null) {
final int dimensions = type.getArrayDimensions();
if (dimensions > 0 && dimensions != myVariable.getType().getArrayDimensions()) {
myWritten = true;
}
}
if (PsiUtil.isAccessedForWriting(arrayAccessExpression)) {
myWritten = true;
}
if (PsiUtil.isAccessedForReading(arrayAccessExpression)) {
myRead = true;
}
} else if (parent instanceof PsiReferenceExpression) {
final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) parent;
final String name = referenceExpression.getReferenceName();
if ("length".equals(name)
|| ("clone".equals(name)
&& referenceExpression.getParent() instanceof PsiMethodCallExpression)) {
myRead = true;
}
} else if (parent instanceof PsiForeachStatement) {
final PsiForeachStatement foreachStatement = (PsiForeachStatement) parent;
final PsiExpression iteratedValue = foreachStatement.getIteratedValue();
if (PsiTreeUtil.isAncestor(iteratedValue, expression, false)) {
myRead = true;
}
} else if (parent instanceof PsiExpressionList) {
final PsiExpressionList expressionList = (PsiExpressionList) parent;
parent = parent.getParent();
if (parent instanceof PsiMethodCallExpression) {
final PsiMethodCallExpression methodCallExpression = (PsiMethodCallExpression) parent;
final PsiMethod method = methodCallExpression.resolveMethod();
if (method != null) {
final PsiClass aClass = method.getContainingClass();
if (aClass != null) {
final String methodName = method.getName();
final String qualifiedName = aClass.getQualifiedName();
if ("java.lang.System".equals(qualifiedName)) {
if ("arraycopy".equals(methodName)) {
final PsiExpression[] expressions = expressionList.getExpressions();
if (expressions.length == 5) {
if (PsiTreeUtil.isAncestor(expressions[0], expression, false)) {
myRead = true;
return;
} else if (PsiTreeUtil.isAncestor(expressions[2], expression, false)) {
myWritten = true;
return;
}
}
}
} else if (CommonClassNames.JAVA_UTIL_ARRAYS.equals(qualifiedName)) {
if ("fill".equals(methodName)
|| "parallelPrefix".equals(methodName)
|| "parallelSetAll".equals(methodName)
|| "parallelSort".equals(methodName)
|| "setAll".equals(methodName)
|| "sort".equals(methodName)) {
myWritten = true;
} else {
myRead = true;
}
return;
}
}
}
}
myRead = true;
myWritten = true;
} else {
myWritten = true;
myRead = true;
}
}
@NotNull
private List<PsiMethod> getMethodsToImport() {
PsiShortNamesCache cache = PsiShortNamesCache.getInstance(myMethodCall.getProject());
PsiMethodCallExpression element = myMethodCall.getElement();
PsiReferenceExpression reference = element.getMethodExpression();
PsiExpressionList argumentList = element.getArgumentList();
String name = reference.getReferenceName();
List<PsiMethod> list = new ArrayList<PsiMethod>();
if (name == null) return list;
GlobalSearchScope scope = element.getResolveScope();
PsiMethod[] methods = cache.getMethodsByNameIfNotMoreThan(name, scope, 20);
List<PsiMethod> applicableList = new ArrayList<PsiMethod>();
final PsiResolveHelper resolveHelper =
JavaPsiFacade.getInstance(element.getProject()).getResolveHelper();
for (PsiMethod method : methods) {
ProgressManager.checkCanceled();
if (JavaCompletionUtil.isInExcludedPackage(method)) continue;
if (!method.hasModifierProperty(PsiModifier.STATIC)) continue;
PsiFile file = method.getContainingFile();
if (file instanceof PsiJavaFile
// do not show methods from default package
&& ((PsiJavaFile) file).getPackageName().length() != 0
&& PsiUtil.isAccessible(method, element, method.getContainingClass())) {
list.add(method);
PsiSubstitutor substitutorForMethod =
resolveHelper.inferTypeArguments(
method.getTypeParameters(),
method.getParameterList().getParameters(),
argumentList.getExpressions(),
PsiSubstitutor.EMPTY,
element.getParent(),
DefaultParameterTypeInferencePolicy.INSTANCE);
if (PsiUtil.isApplicable(method, substitutorForMethod, argumentList)) {
applicableList.add(method);
}
}
}
List<PsiMethod> result = applicableList.isEmpty() ? list : applicableList;
for (int i = result.size() - 1; i >= 0; i--) {
ProgressManager.checkCanceled();
PsiMethod method = result.get(i);
PsiClass containingClass = method.getContainingClass();
for (int j = i + 1; j < result.size(); j++) {
PsiMethod exMethod = result.get(j);
if (!Comparing.strEqual(exMethod.getName(), method.getName())) continue;
PsiClass exContainingClass = exMethod.getContainingClass();
if (containingClass != null
&& exContainingClass != null
&& !Comparing.equal(
containingClass.getQualifiedName(), exContainingClass.getQualifiedName())) continue;
// same named methods, drop one
result.remove(i);
break;
}
// check for manually excluded
if (isExcluded(method)) {
result.remove(i);
}
}
Collections.sort(result, new PsiProximityComparator(argumentList));
return result;
}
@Nullable
private String createCollectionIterationText(@NotNull PsiForStatement forStatement)
throws IncorrectOperationException {
final PsiStatement body = forStatement.getBody();
final PsiStatement firstStatement = getFirstStatement(body);
final PsiStatement initialization = forStatement.getInitialization();
if (!(initialization instanceof PsiDeclarationStatement)) {
return null;
}
final PsiDeclarationStatement declaration = (PsiDeclarationStatement) initialization;
final PsiElement declaredIterator = declaration.getDeclaredElements()[0];
if (!(declaredIterator instanceof PsiVariable)) {
return null;
}
final PsiVariable iteratorVariable = (PsiVariable) declaredIterator;
final PsiMethodCallExpression initializer =
(PsiMethodCallExpression) iteratorVariable.getInitializer();
if (initializer == null) {
return null;
}
final PsiType iteratorType = initializer.getType();
if (iteratorType == null) {
return null;
}
final PsiType iteratorContentType = extractContentTypeFromType(iteratorType);
final PsiType iteratorVariableType = iteratorVariable.getType();
final PsiType contentType;
final PsiClassType javaLangObject = TypeUtils.getObjectType(forStatement);
if (iteratorContentType == null) {
final PsiType iteratorVariableContentType =
extractContentTypeFromType(iteratorVariableType);
if (iteratorVariableContentType == null) {
contentType = javaLangObject;
} else {
contentType = iteratorVariableContentType;
}
} else {
contentType = iteratorContentType;
}
final PsiReferenceExpression methodExpression = initializer.getMethodExpression();
final PsiExpression collection = methodExpression.getQualifierExpression();
final String iteratorName = iteratorVariable.getName();
final boolean isDeclaration =
isIteratorNextDeclaration(firstStatement, iteratorName, contentType);
final PsiStatement statementToSkip;
@NonNls final String finalString;
final String contentVariableName;
if (isDeclaration) {
final PsiDeclarationStatement declarationStatement =
(PsiDeclarationStatement) firstStatement;
assert declarationStatement != null;
final PsiElement[] declaredElements = declarationStatement.getDeclaredElements();
final PsiElement declaredElement = declaredElements[0];
if (!(declaredElement instanceof PsiVariable)) {
return null;
}
final PsiVariable variable = (PsiVariable) declaredElement;
contentVariableName = variable.getName();
statementToSkip = declarationStatement;
if (variable.hasModifierProperty(PsiModifier.FINAL)) {
finalString = "final ";
} else {
finalString = "";
}
} else {
if (collection instanceof PsiReferenceExpression) {
final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) collection;
final String collectionName = referenceExpression.getReferenceName();
contentVariableName = createNewVariableName(forStatement, contentType, collectionName);
} else {
contentVariableName = createNewVariableName(forStatement, contentType, null);
}
final Project project = forStatement.getProject();
final CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getSettings(project);
if (codeStyleSettings.GENERATE_FINAL_LOCALS) {
finalString = "final ";
} else {
finalString = "";
}
statementToSkip = null;
}
final String contentTypeString = contentType.getCanonicalText();
@NonNls final StringBuilder out = new StringBuilder();
out.append("for(");
out.append(finalString);
out.append(contentTypeString);
out.append(' ');
out.append(contentVariableName);
out.append(": ");
if (!contentType.equals(javaLangObject)) {
@NonNls final String iterableTypeString = "java.lang.Iterable<" + contentTypeString + '>';
if (iteratorContentType == null) {
out.append('(');
out.append(iterableTypeString);
out.append(')');
}
}
if (collection == null) {
out.append("this");
} else {
out.append(collection.getText());
}
out.append(')');
replaceIteratorNext(
body, contentVariableName, iteratorName, statementToSkip, out, contentType);
return out.toString();
}
@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;
}
@Nullable
private String createArrayIterationText(@NotNull PsiForStatement forStatement) {
final PsiExpression condition = forStatement.getCondition();
final PsiBinaryExpression strippedCondition =
(PsiBinaryExpression) ParenthesesUtils.stripParentheses(condition);
if (strippedCondition == null) {
return null;
}
final PsiExpression lhs = ParenthesesUtils.stripParentheses(strippedCondition.getLOperand());
if (lhs == null) {
return null;
}
final PsiExpression rhs = ParenthesesUtils.stripParentheses(strippedCondition.getROperand());
if (rhs == null) {
return null;
}
final IElementType tokenType = strippedCondition.getOperationTokenType();
final PsiReferenceExpression arrayLengthExpression;
final String indexName;
if (tokenType.equals(JavaTokenType.LT)) {
arrayLengthExpression = (PsiReferenceExpression) ParenthesesUtils.stripParentheses(rhs);
indexName = lhs.getText();
} else if (tokenType.equals(JavaTokenType.GT)) {
arrayLengthExpression = (PsiReferenceExpression) ParenthesesUtils.stripParentheses(lhs);
indexName = rhs.getText();
} else {
return null;
}
if (arrayLengthExpression == null) {
return null;
}
PsiReferenceExpression arrayReference =
(PsiReferenceExpression) arrayLengthExpression.getQualifierExpression();
if (arrayReference == null) {
final PsiElement target = arrayLengthExpression.resolve();
if (!(target instanceof PsiVariable)) {
return null;
}
final PsiVariable variable = (PsiVariable) target;
final PsiExpression initializer = variable.getInitializer();
if (!(initializer instanceof PsiReferenceExpression)) {
return null;
}
final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) initializer;
arrayReference = (PsiReferenceExpression) referenceExpression.getQualifierExpression();
if (arrayReference == null) {
return null;
}
}
final PsiType type = arrayReference.getType();
if (!(type instanceof PsiArrayType)) {
return null;
}
final PsiArrayType arrayType = (PsiArrayType) type;
final PsiType componentType = arrayType.getComponentType();
final String typeText = componentType.getCanonicalText();
final PsiElement target = arrayReference.resolve();
if (!(target instanceof PsiVariable)) {
return null;
}
final PsiVariable arrayVariable = (PsiVariable) target;
final PsiStatement body = forStatement.getBody();
final PsiStatement firstStatement = getFirstStatement(body);
final boolean isDeclaration =
isArrayElementDeclaration(firstStatement, arrayVariable, indexName);
final String contentVariableName;
@NonNls final String finalString;
final PsiStatement statementToSkip;
if (isDeclaration) {
final PsiDeclarationStatement declarationStatement =
(PsiDeclarationStatement) firstStatement;
assert declarationStatement != null;
final PsiElement[] declaredElements = declarationStatement.getDeclaredElements();
final PsiElement declaredElement = declaredElements[0];
if (!(declaredElement instanceof PsiVariable)) {
return null;
}
final PsiVariable variable = (PsiVariable) declaredElement;
if (VariableAccessUtils.variableIsAssigned(variable, forStatement)) {
final String collectionName = arrayReference.getReferenceName();
contentVariableName = createNewVariableName(forStatement, componentType, collectionName);
final Project project = forStatement.getProject();
final CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getSettings(project);
if (codeStyleSettings.GENERATE_FINAL_LOCALS) {
finalString = "final ";
} else {
finalString = "";
}
statementToSkip = null;
} else {
contentVariableName = variable.getName();
statementToSkip = declarationStatement;
if (variable.hasModifierProperty(PsiModifier.FINAL)) {
finalString = "final ";
} else {
finalString = "";
}
}
} else {
final String collectionName = arrayReference.getReferenceName();
contentVariableName = createNewVariableName(forStatement, componentType, collectionName);
final Project project = forStatement.getProject();
final CodeStyleSettings codeStyleSettings = CodeStyleSettingsManager.getSettings(project);
if (codeStyleSettings.GENERATE_FINAL_LOCALS) {
finalString = "final ";
} else {
finalString = "";
}
statementToSkip = null;
}
@NonNls final StringBuilder out = new StringBuilder();
out.append("for(");
out.append(finalString);
out.append(typeText);
out.append(' ');
out.append(contentVariableName);
out.append(": ");
final String arrayName = arrayReference.getText();
out.append(arrayName);
out.append(')');
if (body != null) {
replaceArrayAccess(
body, contentVariableName, arrayVariable, indexName, statementToSkip, out);
}
return out.toString();
}
private NamesByExprInfo suggestVariableNameByExpressionOnly(
PsiExpression expr,
final VariableKind variableKind,
boolean correctKeywords,
boolean useAllMethodNames) {
if (expr instanceof PsiMethodCallExpression) {
PsiReferenceExpression methodExpr = ((PsiMethodCallExpression) expr).getMethodExpression();
String methodName = methodExpr.getReferenceName();
if (methodName != null) {
if ("of".equals(methodName) || "ofNullable".equals(methodName)) {
if (isJavaUtilMethodCall((PsiMethodCallExpression) expr)) {
PsiExpression[] expressions =
((PsiMethodCallExpression) expr).getArgumentList().getExpressions();
if (expressions.length > 0) {
return suggestVariableNameByExpressionOnly(
expressions[0], variableKind, correctKeywords, useAllMethodNames);
}
}
}
if ("map".equals(methodName)
|| "flatMap".equals(methodName)
|| "filter".equals(methodName)) {
if (isJavaUtilMethodCall((PsiMethodCallExpression) expr)) {
return new NamesByExprInfo(null);
}
}
String[] words = NameUtil.nameToWords(methodName);
if (words.length > 0) {
final String firstWord = words[0];
if (GET_PREFIX.equals(firstWord)
|| IS_PREFIX.equals(firstWord)
|| FIND_PREFIX.equals(firstWord)
|| CREATE_PREFIX.equals(firstWord)) {
if (words.length > 1) {
final String propertyName = methodName.substring(firstWord.length());
String[] names =
getSuggestionsByName(propertyName, variableKind, false, correctKeywords);
final PsiExpression qualifierExpression = methodExpr.getQualifierExpression();
if (qualifierExpression instanceof PsiReferenceExpression
&& ((PsiReferenceExpression) qualifierExpression).resolve()
instanceof PsiVariable) {
names =
ArrayUtil.append(
names,
StringUtil.sanitizeJavaIdentifier(
changeIfNotIdentifier(
qualifierExpression.getText()
+ StringUtil.capitalize(propertyName))));
}
return new NamesByExprInfo(propertyName, names);
}
} else if (words.length == 1 || useAllMethodNames) {
return new NamesByExprInfo(
methodName, getSuggestionsByName(methodName, variableKind, false, correctKeywords));
}
}
}
} else if (expr instanceof PsiReferenceExpression) {
String propertyName = ((PsiReferenceExpression) expr).getReferenceName();
PsiElement refElement = ((PsiReferenceExpression) expr).resolve();
if (refElement instanceof PsiVariable) {
VariableKind refVariableKind = getVariableKind((PsiVariable) refElement);
propertyName = variableNameToPropertyName(propertyName, refVariableKind);
}
if (refElement != null && propertyName != null) {
String[] names = getSuggestionsByName(propertyName, variableKind, false, correctKeywords);
return new NamesByExprInfo(propertyName, names);
}
} else if (expr instanceof PsiArrayAccessExpression) {
PsiExpression arrayExpr = ((PsiArrayAccessExpression) expr).getArrayExpression();
if (arrayExpr instanceof PsiReferenceExpression) {
String arrayName = ((PsiReferenceExpression) arrayExpr).getReferenceName();
PsiElement refElement = ((PsiReferenceExpression) arrayExpr).resolve();
if (refElement instanceof PsiVariable) {
VariableKind refVariableKind = getVariableKind((PsiVariable) refElement);
arrayName = variableNameToPropertyName(arrayName, refVariableKind);
}
if (arrayName != null) {
String name = StringUtil.unpluralize(arrayName);
if (name != null) {
String[] names = getSuggestionsByName(name, variableKind, false, correctKeywords);
return new NamesByExprInfo(name, names);
}
}
}
} else if (expr instanceof PsiLiteralExpression
&& variableKind == VariableKind.STATIC_FINAL_FIELD) {
final PsiLiteralExpression literalExpression = (PsiLiteralExpression) expr;
final Object value = literalExpression.getValue();
if (value instanceof String) {
final String stringValue = (String) value;
String[] names = getSuggestionsByValue(stringValue);
if (names.length > 0) {
return new NamesByExprInfo(null, constantValueToConstantName(names));
}
}
} else if (expr instanceof PsiParenthesizedExpression) {
return suggestVariableNameByExpressionOnly(
((PsiParenthesizedExpression) expr).getExpression(),
variableKind,
correctKeywords,
useAllMethodNames);
} else if (expr instanceof PsiTypeCastExpression) {
return suggestVariableNameByExpressionOnly(
((PsiTypeCastExpression) expr).getOperand(),
variableKind,
correctKeywords,
useAllMethodNames);
} else if (expr instanceof PsiLiteralExpression) {
final String text = StringUtil.stripQuotesAroundValue(expr.getText());
if (isIdentifier(text)) {
return new NamesByExprInfo(
text, getSuggestionsByName(text, variableKind, false, correctKeywords));
}
}
return new NamesByExprInfo(null, ArrayUtil.EMPTY_STRING_ARRAY);
}
@Nullable
private String createListIterationText(@NotNull PsiForStatement forStatement) {
final PsiBinaryExpression condition =
(PsiBinaryExpression) ParenthesesUtils.stripParentheses(forStatement.getCondition());
if (condition == null) {
return null;
}
final PsiExpression lhs = ParenthesesUtils.stripParentheses(condition.getLOperand());
if (lhs == null) {
return null;
}
final PsiExpression rhs = ParenthesesUtils.stripParentheses(condition.getROperand());
if (rhs == null) {
return null;
}
final IElementType tokenType = condition.getOperationTokenType();
final String indexName;
PsiExpression collectionSize;
if (JavaTokenType.LT.equals(tokenType)) {
indexName = lhs.getText();
collectionSize = rhs;
} else if (JavaTokenType.GT.equals(tokenType)) {
indexName = rhs.getText();
collectionSize = lhs;
} else {
return null;
}
if (collectionSize instanceof PsiReferenceExpression) {
final PsiReferenceExpression referenceExpression = (PsiReferenceExpression) collectionSize;
final PsiElement target = referenceExpression.resolve();
if (target instanceof PsiVariable) {
final PsiVariable variable = (PsiVariable) target;
collectionSize = ParenthesesUtils.stripParentheses(variable.getInitializer());
}
}
if (!(collectionSize instanceof PsiMethodCallExpression)) {
return null;
}
final PsiMethodCallExpression methodCallExpression =
(PsiMethodCallExpression) ParenthesesUtils.stripParentheses(collectionSize);
if (methodCallExpression == null) {
return null;
}
final PsiReferenceExpression listLengthExpression =
methodCallExpression.getMethodExpression();
final PsiExpression qualifier =
ParenthesesUtils.stripParentheses(listLengthExpression.getQualifierExpression());
final PsiReferenceExpression listReference;
if (qualifier instanceof PsiReferenceExpression) {
listReference = (PsiReferenceExpression) qualifier;
} else {
listReference = null;
}
PsiType parameterType;
if (listReference == null) {
parameterType = extractListTypeFromContainingClass(forStatement);
} else {
final PsiType type = listReference.getType();
if (type == null) {
return null;
}
parameterType = extractContentTypeFromType(type);
}
if (parameterType == null) {
parameterType = TypeUtils.getObjectType(forStatement);
}
final String typeString = parameterType.getCanonicalText();
final PsiVariable listVariable;
if (listReference == null) {
listVariable = null;
} else {
final PsiElement target = listReference.resolve();
if (!(target instanceof PsiVariable)) {
return null;
}
listVariable = (PsiVariable) target;
}
final PsiStatement body = forStatement.getBody();
final PsiStatement firstStatement = getFirstStatement(body);
final boolean isDeclaration =
isListElementDeclaration(firstStatement, listVariable, indexName, parameterType);
final String contentVariableName;
@NonNls final String finalString;
final PsiStatement statementToSkip;
if (isDeclaration) {
final PsiDeclarationStatement declarationStatement =
(PsiDeclarationStatement) firstStatement;
assert declarationStatement != null;
final PsiElement[] declaredElements = declarationStatement.getDeclaredElements();
final PsiElement declaredElement = declaredElements[0];
if (!(declaredElement instanceof PsiVariable)) {
return null;
}
final PsiVariable variable = (PsiVariable) declaredElement;
contentVariableName = variable.getName();
statementToSkip = declarationStatement;
if (variable.hasModifierProperty(PsiModifier.FINAL)) {
finalString = "final ";
} else {
finalString = "";
}
} else {
final String collectionName;
if (listReference == null) {
collectionName = null;
} else {
collectionName = listReference.getReferenceName();
}
contentVariableName = createNewVariableName(forStatement, parameterType, collectionName);
finalString = "";
statementToSkip = null;
}
@NonNls final StringBuilder out = new StringBuilder();
out.append("for(");
out.append(finalString);
out.append(typeString);
out.append(' ');
out.append(contentVariableName);
out.append(": ");
@NonNls final String listName;
if (listReference == null) {
listName = "this";
} else {
listName = listReference.getText();
}
out.append(listName);
out.append(')');
if (body != null) {
replaceCollectionGetAccess(
body, contentVariableName, listVariable, indexName, statementToSkip, out);
}
return out.toString();
}
