@Override
public void visitBinaryExpression(@NotNull PsiBinaryExpression expression) {
super.visitBinaryExpression(expression);
final PsiExpression rhs = expression.getROperand();
if (!(rhs != null)) {
return;
}
if (!ComparisonUtils.isComparison(expression)) {
return;
}
if (ComparisonUtils.isEqualityComparison(expression)) {
return;
}
final PsiExpression lhs = expression.getLOperand();
if (!isCharacter(lhs)) {
return;
}
if (!isCharacter(rhs)) {
return;
}
if (NonNlsUtils.isNonNlsAnnotated(lhs) || NonNlsUtils.isNonNlsAnnotated(rhs)) {
return;
}
registerError(expression);
}
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
final PsiExpressionList argumentList = expression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length == 0) {
return;
}
final PsiExpression xpathArgument = arguments[0];
if (!ExpressionUtils.hasStringType(xpathArgument)) {
return;
}
if (!PsiUtil.isConstantExpression(xpathArgument)) {
return;
}
final PsiType type = xpathArgument.getType();
if (type == null) {
return;
}
final String value = (String) ConstantExpressionUtil.computeCastTo(xpathArgument, type);
if (value == null) {
return;
}
if (!callTakesXPathExpression(expression)) {
return;
}
final XPathFactory xpathFactory = XPathFactory.newInstance();
final XPath xpath = xpathFactory.newXPath();
//noinspection UnusedCatchParameter,ProhibitedExceptionCaught
try {
xpath.compile(value);
} catch (XPathExpressionException ignore) {
registerError(xpathArgument);
}
}
@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 visitForStatement(PsiForStatement statement) {
super.visitForStatement(statement);
final PsiExpression condition = statement.getCondition();
final PsiStatement body = statement.getBody();
checkCondition(condition, body);
}
@Override
public void visitReferenceExpression(@NotNull PsiReferenceExpression expression) {
if (FileTypeUtils.isInServerPageFile(expression)) {
// disable for jsp files IDEADEV-12957
return;
}
super.visitReferenceExpression(expression);
if (expression.getQualifierExpression() == null) {
return;
}
final PsiElement referenceNameElement = expression.getReferenceNameElement();
if (referenceNameElement == null) {
return;
}
final PsiElement containingClass = getContainingContextClass(expression);
if (containingClass == null) {
return;
}
final PsiElement element = expression.resolve();
if (!(element instanceof PsiMethod || element instanceof PsiField)) {
return;
}
final PsiMember member = (PsiMember) element;
if (!member.hasModifierProperty(PsiModifier.PRIVATE)) {
return;
}
final PsiClass memberClass = ClassUtils.getContainingClass(member);
if (memberClass == null) {
return;
}
if (memberClass.equals(containingClass)) {
return;
}
registerError(referenceNameElement, memberClass, member);
}
@Override
public void visitIfStatement(PsiIfStatement statement) {
super.visitIfStatement(statement);
final PsiExpression condition = statement.getCondition();
final PsiStatement body = statement.getThenBranch();
checkCondition(condition, body);
}
@Override
public void visitMethod(@NotNull PsiMethod method) {
super.visitMethod(method);
final PsiCodeBlock body = method.getBody();
if (body == null) {
return;
}
if (method.getNameIdentifier() == null) {
return;
}
final PsiMethod leastConcreteSuperMethod = getLeastConcreteSuperMethod(method);
if (leastConcreteSuperMethod == null) {
return;
}
final PsiClass objectClass = ClassUtils.findObjectClass(method);
final PsiMethod[] superMethods = method.findSuperMethods(objectClass);
if (superMethods.length > 0) {
return;
}
if (ignoreEmptySuperMethods) {
final PsiMethod superMethod = (PsiMethod) leastConcreteSuperMethod.getNavigationElement();
if (MethodUtils.isTrivial(superMethod, true)) {
return;
}
}
if (onlyReportWhenAnnotated) {
if (!AnnotationUtil.isAnnotated(leastConcreteSuperMethod, annotations)) {
return;
}
}
if (containsSuperCall(body, leastConcreteSuperMethod)) {
return;
}
registerMethodError(method);
}
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression call) {
super.visitMethodCallExpression(call);
final PsiReferenceExpression methodExpression = call.getMethodExpression();
final PsiElement qualifier = methodExpression.getQualifier();
if (!(qualifier instanceof PsiReferenceExpression)) {
return;
}
final PsiMethod method = call.resolveMethod();
if (method == null) {
return;
}
if (!method.hasModifierProperty(PsiModifier.STATIC)) {
return;
}
final PsiElement referent = ((PsiReference) qualifier).resolve();
if (!(referent instanceof PsiClass)) {
return;
}
final PsiClass referencedClass = (PsiClass) referent;
final PsiClass declaringClass = method.getContainingClass();
if (declaringClass == null) {
return;
}
if (declaringClass.equals(referencedClass)) {
return;
}
final PsiClass containingClass = ClassUtils.getContainingClass(call);
if (!ClassUtils.isClassVisibleFromClass(containingClass, declaringClass)) {
return;
}
registerMethodCallError(call, declaringClass, referencedClass);
}
@Override
public void visitNewExpression(@NotNull PsiNewExpression expression) {
if (!PsiUtil.isLanguageLevel5OrHigher(expression)) {
return;
}
super.visitNewExpression(expression);
final PsiType type = expression.getType();
if (type == null) {
return;
}
final String canonicalText = type.getCanonicalText();
if (!cachedNumberTypes.contains(canonicalText)) {
return;
}
final PsiClass aClass = ClassUtils.getContainingClass(expression);
if (aClass != null && cachedNumberTypes.contains(aClass.getQualifiedName())) {
return;
}
final PsiExpressionList argumentList = expression.getArgumentList();
if (argumentList == null) {
return;
}
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 1) {
return;
}
final PsiExpression argument = arguments[0];
final PsiType argumentType = argument.getType();
if (argumentType == null || argumentType.equalsToText("java.lang.String")) {
return;
}
registerError(expression, expression);
}
@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(PsiMethodCallExpression methodCallExpression) {
super.visitMethodCallExpression(methodCallExpression);
if (!MethodCallUtils.isSimpleCallToMethod(
methodCallExpression,
"javax.servlet.http.HttpSession",
PsiType.VOID,
"putValue",
"java.lang.String",
"java.lang.Object")
&& !MethodCallUtils.isSimpleCallToMethod(
methodCallExpression,
"javax.servlet.http.HttpSession",
PsiType.VOID,
"setAttribute",
"java.lang.String",
"java.lang.Object")) {
return;
}
final PsiExpressionList argumentList = methodCallExpression.getArgumentList();
final PsiExpression[] arguments = argumentList.getExpressions();
if (arguments.length != 2) {
return;
}
final PsiExpression argument = arguments[1];
final PsiType argumentType = argument.getType();
if (argumentType == null) {
return;
}
if (SerializationUtils.isProbablySerializable(argumentType)) {
return;
}
registerError(argument);
}
@Override
public void visitLambdaExpression(PsiLambdaExpression lambdaExpression) {
super.visitLambdaExpression(lambdaExpression);
if (lambdaExpression.getBody() instanceof PsiExpression) {
registerError(lambdaExpression);
}
}
@Override
public void visitLiteralExpression(@NotNull PsiLiteralExpression expression) {
super.visitLiteralExpression(expression);
final PsiType type = expression.getType();
if (!ClassUtils.isPrimitiveNumericType(type)) {
return;
}
if (PsiType.CHAR.equals(type)) {
return;
}
if (isSpecialCaseLiteral(expression)) {
return;
}
if (ExpressionUtils.isDeclaredConstant(expression)) {
return;
}
if (ignoreInHashCode) {
final PsiMethod containingMethod = PsiTreeUtil.getParentOfType(expression, PsiMethod.class);
if (MethodUtils.isHashCode(containingMethod)) {
return;
}
}
if (ignoreInTestCode && TestUtils.isInTestCode(expression)) {
return;
}
final PsiElement parent = expression.getParent();
if (parent instanceof PsiPrefixExpression) {
registerError(parent);
} else {
registerError(expression);
}
}
@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);
}
@Override
public void visitNewExpression(PsiNewExpression expression) {
super.visitNewExpression(expression);
final PsiJavaCodeReferenceElement classReference = expression.getClassReference();
if (classReference == null) {
return;
}
final String name = classReference.getReferenceName();
if (!"BigDecimal".equals(name)) {
return;
}
final PsiMethod constructor = expression.resolveConstructor();
if (constructor == null) {
return;
}
final PsiParameterList parameterList = constructor.getParameterList();
final int length = parameterList.getParametersCount();
if (length != 1 && length != 2) {
return;
}
final PsiParameter[] parameters = parameterList.getParameters();
final PsiParameter firstParameter = parameters[0];
final PsiType type = firstParameter.getType();
if (type != PsiType.DOUBLE) {
return;
}
registerNewExpressionError(expression);
}
@Override
public void visitMethodCallExpression(PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
if (!isCallToRegexMethod(expression)) {
return;
}
registerMethodCallError(expression);
}
@Override
public void visitReturnStatement(@NotNull PsiReturnStatement statement) {
super.visitReturnStatement(statement);
if (!ControlFlowUtils.isInFinallyBlock(statement)) {
return;
}
registerStatementError(statement);
}
@Override
public void visitMethod(@NotNull PsiMethod method) {
super.visitMethod(method);
final String name = method.getName();
if (!PsiKeyword.ASSERT.equals(name)) {
return;
}
registerMethodError(method);
}
@Override
public void visitVariable(@NotNull PsiVariable variable) {
super.visitVariable(variable);
final String variableName = variable.getName();
if (!PsiKeyword.ASSERT.equals(variableName)) {
return;
}
registerVariableError(variable);
}
@Override
public void visitTypeParameter(PsiTypeParameter parameter) {
super.visitTypeParameter(parameter);
final String name = parameter.getName();
if (!PsiKeyword.ASSERT.equals(name)) {
return;
}
registerTypeParameterError(parameter);
}
@Override
public void visitElement(PsiElement element) {
if (element.getLanguage() != JavaLanguage.INSTANCE) {
return;
}
if (!PsiUtil.isLanguageLevel5OrHigher(element)) {
return;
}
super.visitElement(element);
}
@Override
public void visitField(@NotNull PsiField field) {
super.visitField(field);
final PsiType type = field.getType();
if (!type.equalsToText(CommonClassNames.JAVA_LANG_STRING_BUFFER)
&& !type.equalsToText(CommonClassNames.JAVA_LANG_STRING_BUILDER)) {
return;
}
registerFieldError(field, type);
}
@Override
public void visitThrowStatement(PsiThrowStatement statement) {
super.visitThrowStatement(statement);
final PsiCatchSection catchSection =
PsiTreeUtil.getParentOfType(statement, PsiCatchSection.class, true, PsiClass.class);
if (catchSection == null) {
return;
}
final PsiParameter parameter = catchSection.getParameter();
if (parameter == null) {
return;
}
@NonNls final String parameterName = parameter.getName();
if (PsiUtil.isIgnoredName(parameterName)) {
return;
}
final PsiExpression exception = statement.getException();
if (exception == null) {
return;
}
if (ignoreCantWrap) {
final PsiType thrownType = exception.getType();
if (thrownType instanceof PsiClassType) {
final PsiClassType classType = (PsiClassType) thrownType;
final PsiClass exceptionClass = classType.resolve();
if (exceptionClass != null) {
final PsiMethod[] constructors = exceptionClass.getConstructors();
final PsiClassType throwableType =
TypeUtils.getType(CommonClassNames.JAVA_LANG_THROWABLE, statement);
boolean canWrap = false;
outer:
for (PsiMethod constructor : constructors) {
final PsiParameterList parameterList = constructor.getParameterList();
final PsiParameter[] parameters = parameterList.getParameters();
for (PsiParameter constructorParameter : parameters) {
final PsiType type = constructorParameter.getType();
if (throwableType.equals(type)) {
canWrap = true;
break outer;
}
}
}
if (!canWrap) {
return;
}
}
}
}
final ReferenceFinder visitor = new ReferenceFinder(parameter);
exception.accept(visitor);
if (visitor.usesParameter()) {
return;
}
registerStatementError(statement);
}
@Override
public void visitPolyadicExpression(PsiPolyadicExpression expression) {
super.visitPolyadicExpression(expression);
if (!ExpressionUtils.hasStringType(expression)) {
return;
}
final PsiExpression[] operands = expression.getOperands();
for (PsiExpression operand : operands) {
checkExpression(operand);
}
}
@Override
public void visitMethod(@NotNull PsiMethod method) {
super.visitMethod(method);
if (!method.hasModifierProperty(PsiModifier.STATIC)) {
return;
}
final String name = method.getName();
if (isValid(name)) {
return;
}
registerMethodError(method, name);
}
@Override
public void visitEnumConstant(PsiEnumConstant constant) {
super.visitEnumConstant(constant);
final String name = constant.getName();
if (name == null) {
return;
}
if (isValid(name)) {
return;
}
registerFieldError(constant, name);
}
@Override
public void visitThrowStatement(PsiThrowStatement statement) {
super.visitThrowStatement(statement);
final PsiExpression exception = ParenthesesUtils.stripParentheses(statement.getException());
if (!(exception instanceof PsiLiteralExpression)) {
return;
}
final PsiType type = exception.getType();
if (!PsiType.NULL.equals(type)) {
return;
}
registerError(exception);
}
@Override
public void visitBinaryExpression(@NotNull PsiBinaryExpression expression) {
super.visitBinaryExpression(expression);
if (!ComparisonUtils.isComparison(expression)) {
return;
}
final PsiExpression lhs = expression.getLOperand();
final PsiExpression rhs = expression.getROperand();
if (rhs == null || !isConstantExpression(lhs) || isConstantExpression(rhs)) {
return;
}
registerError(expression);
}
@Override
public void visitAssignmentExpression(@NotNull PsiAssignmentExpression expression) {
super.visitAssignmentExpression(expression);
final IElementType tokenType = expression.getOperationTokenType();
if (!tokenType.equals(JavaTokenType.PLUSEQ)) {
return;
}
final PsiExpression lhs = expression.getLExpression();
if (!ExpressionUtils.hasStringType(lhs)) {
return;
}
final PsiExpression rhs = expression.getRExpression();
checkExpression(rhs);
}
@Override
public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) {
super.visitMethodCallExpression(expression);
if (!MethodCallUtils.isCallToMethod(
expression, "java.lang.Thread", PsiType.VOID, "sleep", PsiType.LONG)
&& !MethodCallUtils.isCallToMethod(
expression, "java.lang.Thread", PsiType.VOID, "sleep", PsiType.LONG, PsiType.INT)) {
return;
}
if (!ControlFlowUtils.isInLoop(expression)) {
return;
}
registerMethodCallError(expression);
}