@Nullable
private ProblemDescriptor createDescription(
@NotNull PsiTypeCastExpression cast, @NotNull InspectionManager manager, boolean onTheFly) {
PsiExpression operand = cast.getOperand();
PsiTypeElement castType = cast.getCastType();
if (operand == null || castType == null) return null;
PsiElement parent = cast.getParent();
while (parent instanceof PsiParenthesizedExpression) {
parent = parent.getParent();
}
if (parent instanceof PsiReferenceExpression) {
if (IGNORE_ANNOTATED_METHODS) {
final PsiElement gParent = parent.getParent();
if (gParent instanceof PsiMethodCallExpression) {
final PsiMethod psiMethod = ((PsiMethodCallExpression) gParent).resolveMethod();
if (psiMethod != null && NullableNotNullManager.isNotNull(psiMethod)) {
final PsiClass superClass = PsiUtil.resolveClassInType(operand.getType());
final PsiClass containingClass = psiMethod.getContainingClass();
if (containingClass != null
&& superClass != null
&& containingClass.isInheritor(superClass, true)) {
for (PsiMethod method : psiMethod.findSuperMethods(superClass)) {
if (NullableNotNullManager.isNullable(method)) {
return null;
}
}
}
}
}
}
} else if (parent instanceof PsiExpressionList) {
final PsiElement gParent = parent.getParent();
if (gParent instanceof PsiMethodCallExpression && IGNORE_SUSPICIOUS_METHOD_CALLS) {
final String message =
SuspiciousCollectionsMethodCallsInspection.getSuspiciousMethodCallMessage(
(PsiMethodCallExpression) gParent,
operand.getType(),
true,
new ArrayList<PsiMethod>(),
new IntArrayList());
if (message != null) {
return null;
}
}
}
String message =
InspectionsBundle.message(
"inspection.redundant.cast.problem.descriptor",
"<code>" + operand.getText() + "</code>",
"<code>#ref</code> #loc");
return manager.createProblemDescriptor(
castType, message, myQuickFixAction, ProblemHighlightType.LIKE_UNUSED_SYMBOL, onTheFly);
}
private static String createInitializerReplacementText(
PsiType varType, PsiExpression initializer) {
final PsiType initializerType = initializer.getType();
final PsiClassType rawType =
initializerType instanceof PsiClassType
? ((PsiClassType) initializerType).rawType()
: null;
final PsiClassType rawVarType =
varType instanceof PsiClassType ? ((PsiClassType) varType).rawType() : null;
if (rawType != null
&& rawVarType != null
&& rawType.equalsToText(CommonClassNames.JAVA_UTIL_ARRAY_LIST)
&& rawVarType.equalsToText(CommonClassNames.JAVA_UTIL_LIST)) {
return "toList()";
} else if (rawType != null
&& rawVarType != null
&& rawType.equalsToText(CommonClassNames.JAVA_UTIL_HASH_SET)
&& rawVarType.equalsToText(CommonClassNames.JAVA_UTIL_SET)) {
return "toSet()";
} else if (rawType != null) {
return "toCollection(" + rawType.getClassName() + "::new)";
} else {
return "toCollection(() -> " + initializer.getText() + ")";
}
}
private static boolean isCollectCall(PsiStatement body, final PsiParameter parameter) {
PsiIfStatement ifStatement = extractIfStatement(body);
final PsiMethodCallExpression methodCallExpression = extractAddCall(body, ifStatement);
if (methodCallExpression != null) {
final PsiReferenceExpression methodExpression = methodCallExpression.getMethodExpression();
final PsiExpression qualifierExpression = methodExpression.getQualifierExpression();
PsiClass qualifierClass = null;
if (qualifierExpression instanceof PsiReferenceExpression) {
if (ReferencesSearch.search(parameter, new LocalSearchScope(qualifierExpression))
.findFirst()
!= null) {
return false;
}
final PsiElement resolve = ((PsiReferenceExpression) qualifierExpression).resolve();
if (resolve instanceof PsiVariable) {
if (ReferencesSearch.search(
resolve, new LocalSearchScope(methodCallExpression.getArgumentList()))
.findFirst()
!= null) {
return false;
}
}
qualifierClass = PsiUtil.resolveClassInType(qualifierExpression.getType());
} else if (qualifierExpression == null) {
final PsiClass enclosingClass = PsiTreeUtil.getParentOfType(body, PsiClass.class);
if (PsiUtil.getEnclosingStaticElement(body, enclosingClass) == null) {
qualifierClass = enclosingClass;
}
}
if (qualifierClass != null
&& InheritanceUtil.isInheritor(
qualifierClass, false, CommonClassNames.JAVA_UTIL_COLLECTION)) {
while (ifStatement != null && PsiTreeUtil.isAncestor(body, ifStatement, false)) {
final PsiExpression condition = ifStatement.getCondition();
if (condition != null
&& isConditionDependsOnUpdatedCollections(condition, qualifierExpression))
return false;
ifStatement = PsiTreeUtil.getParentOfType(ifStatement, PsiIfStatement.class);
}
final PsiElement resolve = methodExpression.resolve();
if (resolve instanceof PsiMethod
&& "add".equals(((PsiMethod) resolve).getName())
&& ((PsiMethod) resolve).getParameterList().getParametersCount() == 1) {
final PsiExpression[] args = methodCallExpression.getArgumentList().getExpressions();
if (args.length == 1) {
if (args[0] instanceof PsiCallExpression) {
final PsiMethod method = ((PsiCallExpression) args[0]).resolveMethod();
return method != null && !method.hasTypeParameters() && !isThrowsCompatible(method);
}
return true;
}
}
}
}
return false;
}
@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);
}
private static String createMapperFunctionalExpressionText(
PsiParameter parameter, PsiExpression expression) {
String iteration = "";
if (!isIdentityMapping(parameter, expression)) {
iteration += ".map(";
iteration +=
compoundLambdaOrMethodReference(
parameter,
expression,
"java.util.function.Function",
new PsiType[] {parameter.getType(), expression.getType()});
iteration += ")";
}
return iteration;
}
private void checkExpression(@NotNull PsiExpression expression) {
if (expression.getParent() instanceof PsiParenthesizedExpression) {
return;
}
final PsiType expressionType = expression.getType();
if (expressionType == null
|| expressionType.equals(PsiType.VOID)
|| !TypeConversionUtil.isPrimitiveAndNotNull(expressionType)) {
return;
}
final PsiPrimitiveType primitiveType = (PsiPrimitiveType) expressionType;
final PsiClassType boxedType = primitiveType.getBoxedType(expression);
if (boxedType == null) {
return;
}
final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, false);
if (expectedType == null || ClassUtils.isPrimitive(expectedType)) {
return;
}
if (!expectedType.isAssignableFrom(boxedType)) {
// JLS 5.2 Assignment Conversion
// check if a narrowing primitive conversion is applicable
if (!(expectedType instanceof PsiClassType) || !PsiUtil.isConstantExpression(expression)) {
return;
}
final PsiClassType classType = (PsiClassType) expectedType;
final String className = classType.getCanonicalText();
if (!convertableBoxedClassNames.contains(className)) {
return;
}
if (!PsiType.BYTE.equals(expressionType)
&& !PsiType.CHAR.equals(expressionType)
&& !PsiType.SHORT.equals(expressionType)
&& !PsiType.INT.equals(expressionType)) {
return;
}
}
if (ignoreAddedToCollection && isAddedToCollection(expression)) {
return;
}
registerError(expression);
}
private void checkExpression(PsiExpression expression) {
if (expression == null) return;
final PsiType type = expression.getType();
if (!(type instanceof PsiClassType)) return;
if (IGNORE_TOSTRING
&& MethodUtils.isToString(PsiTreeUtil.getParentOfType(expression, PsiMethod.class)))
return;
if (IGNORE_EXCEPTION
&& (ExceptionUtils.isExceptionArgument(expression)
|| PsiTreeUtil.getParentOfType(
expression, PsiThrowStatement.class, true, PsiCodeBlock.class, PsiClass.class)
!= null)) return;
if (IGNORE_ASSERT
&& PsiTreeUtil.getParentOfType(
expression, PsiAssertStatement.class, true, PsiCodeBlock.class, PsiClass.class)
!= null) {
return;
}
if (IGNORE_NONNLS && NonNlsUtils.isNonNlsAnnotatedUse(expression)) return;
final PsiClassType classType = (PsiClassType) type;
if (type.equalsToText(CommonClassNames.JAVA_LANG_OBJECT)) return;
final PsiClass referencedClass = classType.resolve();
if (referencedClass == null || referencedClass instanceof PsiTypeParameter) return;
if (referencedClass.isEnum() || referencedClass.isInterface()) return;
if (referencedClass.hasModifierProperty(PsiModifier.ABSTRACT)
&& !(expression instanceof PsiSuperExpression)) return;
if (hasGoodToString(referencedClass)) return;
registerError(expression);
}
@Override
public void doFix(Project project, ProblemDescriptor descriptor) {
final PsiExpression expression = (PsiExpression) descriptor.getPsiElement();
final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, false);
if (expectedType == null) {
return;
}
final String expectedTypeText = expectedType.getCanonicalText();
final String classToConstruct;
if (s_boxingClasses.containsValue(expectedTypeText)) {
classToConstruct = expectedTypeText;
} else {
final PsiType type = expression.getType();
if (type == null) {
return;
}
final String expressionTypeText = type.getCanonicalText();
classToConstruct = s_boxingClasses.get(expressionTypeText);
}
if (shortcutReplace(expression, classToConstruct)) {
return;
}
final PsiExpression strippedExpression = ParenthesesUtils.stripParentheses(expression);
if (strippedExpression == null) {
return;
}
@NonNls final String expressionText = strippedExpression.getText();
@NonNls final String newExpression;
if ("true".equals(expressionText)) {
newExpression = "java.lang.Boolean.TRUE";
} else if ("false".equals(expressionText)) {
newExpression = "java.lang.Boolean.FALSE";
} else {
newExpression = classToConstruct + ".valueOf(" + expressionText + ')';
}
replaceExpression(expression, newExpression);
}
@Override
public void visitTypeCastExpression(@NotNull PsiTypeCastExpression expression) {
super.visitTypeCastExpression(expression);
final PsiExpression operand = expression.getOperand();
if (operand == null) {
return;
}
final PsiType operandType = operand.getType();
if (operandType == null) {
return;
}
final PsiType type = expression.getType();
if (type == null) {
return;
}
final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, true);
if (expectedType == null) {
return;
}
if (expectedType.equals(type)) {
return;
}
final PsiClass resolved = PsiUtil.resolveClassInType(expectedType);
if (resolved != null && !resolved.isPhysical()) {
return;
}
if (expectedType.isAssignableFrom(operandType)) {
// then it's redundant, and caught by the built-in exception
return;
}
if (isTypeParameter(expectedType)) {
return;
}
if (expectedType instanceof PsiArrayType) {
final PsiArrayType arrayType = (PsiArrayType) expectedType;
final PsiType componentType = arrayType.getDeepComponentType();
if (isTypeParameter(componentType)) {
return;
}
}
if (type instanceof PsiPrimitiveType || expectedType instanceof PsiPrimitiveType) {
return;
}
if (PsiPrimitiveType.getUnboxedType(type) != null
|| PsiPrimitiveType.getUnboxedType(expectedType) != null) {
return;
}
if (expectedType instanceof PsiClassType) {
final PsiClassType expectedClassType = (PsiClassType) expectedType;
final PsiClassType expectedRawType = expectedClassType.rawType();
if (type.equals(expectedRawType)) {
return;
}
if (type instanceof PsiClassType) {
final PsiClassType classType = (PsiClassType) type;
final PsiClassType rawType = classType.rawType();
if (rawType.equals(expectedRawType)) {
return;
}
}
if (type instanceof PsiArrayType) {
return;
}
}
if (ignoreInMatchingInstanceof && InstanceOfUtils.hasAgreeingInstanceof(expression)) {
return;
}
final PsiTypeElement castTypeElement = expression.getCastType();
if (castTypeElement == null) {
return;
}
registerError(castTypeElement, expectedType);
}