From ebfea39620c67bc100dfbb4ec9b2aa53b50039e8 Mon Sep 17 00:00:00 2001 From: Bas Leijdekkers Date: Thu, 15 Oct 2015 16:51:44 +0200 Subject: [PATCH] EA-74356 (assert: MethodCallUtils.findMethodWithReplacedArgument) --- .../UnnecessaryUnboxingInspection.java | 109 ++++++++---------- .../UnnecessaryUnboxing.java | 9 ++ 2 files changed, 57 insertions(+), 61 deletions(-) diff --git a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/UnnecessaryUnboxingInspection.java b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/UnnecessaryUnboxingInspection.java index e832d7662a55..d86c4402a997 100644 --- a/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/UnnecessaryUnboxingInspection.java +++ b/plugins/InspectionGadgets/InspectionGadgetsAnalysis/src/com/siyeh/ig/migration/UnnecessaryUnboxingInspection.java @@ -151,89 +151,96 @@ public class UnnecessaryUnboxingInspection extends BaseInspection { } private class UnnecessaryUnboxingVisitor extends BaseInspectionVisitor { + @Override public void visitMethodCallExpression(@NotNull PsiMethodCallExpression expression) { super.visitMethodCallExpression(expression); if (!isUnboxingExpression(expression)) { return; } - final PsiExpression containingExpression = getContainingExpression(expression); - if (isPossibleObjectComparison(expression, containingExpression)) { + final PsiReferenceExpression methodExpression = expression.getMethodExpression(); + final PsiExpression qualifier = methodExpression.getQualifierExpression(); + if (qualifier == null || !canRemainBoxed(expression, qualifier)) { return; } - if (containingExpression instanceof PsiTypeCastExpression) { - final PsiTypeCastExpression typeCastExpression = (PsiTypeCastExpression)containingExpression; + registerError(expression); + } + + private boolean canRemainBoxed(@NotNull PsiExpression expression, @NotNull PsiExpression unboxedExpression) { + PsiElement parent = expression.getParent(); + while (parent instanceof PsiParenthesizedExpression) { + expression = (PsiExpression)parent; + parent = parent.getParent(); + } + if (parent instanceof PsiPolyadicExpression) { + final PsiPolyadicExpression polyadicExpression = (PsiPolyadicExpression)parent; + if (isPossibleObjectComparison(expression, polyadicExpression)) { + return false; + } + } + if (parent instanceof PsiTypeCastExpression) { + final PsiTypeCastExpression typeCastExpression = (PsiTypeCastExpression)parent; final PsiTypeElement typeElement = typeCastExpression.getCastType(); if (typeElement == null) { - return; + return false; } final PsiType castType = typeElement.getType(); final PsiType expressionType = expression.getType(); if (expressionType == null || !castType.isAssignableFrom(expressionType)) { - return; + return false; } } - else if (containingExpression instanceof PsiConditionalExpression) { - final PsiConditionalExpression conditionalExpression = (PsiConditionalExpression)containingExpression; + else if (parent instanceof PsiConditionalExpression) { + final PsiConditionalExpression conditionalExpression = (PsiConditionalExpression)parent; final PsiExpression thenExpression = conditionalExpression.getThenExpression(); if (thenExpression == null) { - return; + return false; } final PsiExpression elseExpression = conditionalExpression.getElseExpression(); if (elseExpression == null) { - return; + return false; } if (PsiTreeUtil.isAncestor(thenExpression, expression, false)) { final PsiType type = elseExpression.getType(); if (!(type instanceof PsiPrimitiveType)) { - return; + return false; } } else if (PsiTreeUtil.isAncestor(elseExpression, expression, false)) { final PsiType type = thenExpression.getType(); if (!(type instanceof PsiPrimitiveType)) { - return; + return false; } } } - else if (containingExpression instanceof PsiCallExpression) { - final PsiCallExpression methodCallExpression = (PsiCallExpression)containingExpression; - if (!isSameMethodCalledWithoutUnboxing(methodCallExpression, expression)) { - return; + else if (parent instanceof PsiExpressionList) { + final PsiElement grandParent = parent.getParent(); + if (!(grandParent instanceof PsiCallExpression)) { + return true; + } + final PsiCallExpression methodCallExpression = (PsiCallExpression)grandParent; + if (!isSameMethodCalledWithoutUnboxing(methodCallExpression, expression, unboxedExpression)) { + return false; } } if (onlyReportSuperfluouslyUnboxed) { final PsiType expectedType = ExpectedTypeUtils.findExpectedType(expression, false, true); if (!(expectedType instanceof PsiClassType)) { - return; + return false; } } - registerError(expression); + return true; } - private boolean isPossibleObjectComparison(PsiMethodCallExpression expression, PsiExpression containingExpression) { - if (!(containingExpression instanceof PsiBinaryExpression)) { + private boolean isPossibleObjectComparison(PsiExpression expression, PsiPolyadicExpression polyadicExpression) { + if (!ComparisonUtils.isEqualityComparison(polyadicExpression)) { return false; } - final PsiBinaryExpression binaryExpression = - (PsiBinaryExpression)containingExpression; - if (!ComparisonUtils.isEqualityComparison(binaryExpression)) { - return false; - } - final PsiExpression lhs = binaryExpression.getLOperand(); - final PsiExpression rhs = binaryExpression.getROperand(); - if (rhs == null) { - return true; - } - if (expression == lhs) { - if (!(rhs.getType() instanceof PsiPrimitiveType) || - isUnboxingExpression(rhs)) { - return true; + for (PsiExpression operand : polyadicExpression.getOperands()) { + if (operand == expression) { + continue; } - } - if (expression == rhs) { - if (!(lhs.getType() instanceof PsiPrimitiveType) || - isUnboxingExpression(lhs)) { + if (!(operand.getType() instanceof PsiPrimitiveType) || isUnboxingExpression(operand)) { return true; } } @@ -264,34 +271,14 @@ public class UnnecessaryUnboxingInspection extends BaseInspection { } private boolean isSameMethodCalledWithoutUnboxing(@NotNull PsiCallExpression callExpression, - @NotNull PsiMethodCallExpression unboxingExpression) { - final PsiReferenceExpression methodExpression = unboxingExpression.getMethodExpression(); - final PsiExpression qualifier = methodExpression.getQualifierExpression(); - if (qualifier == null) { - return false; - } + @NotNull PsiExpression unboxingExpression, + @NotNull PsiExpression unboxedExpression) { final PsiMethod originalMethod = callExpression.resolveMethod(); if (originalMethod == null) { return false; } - final PsiMethod method = MethodCallUtils.findMethodWithReplacedArgument(callExpression, unboxingExpression, qualifier); + final PsiMethod method = MethodCallUtils.findMethodWithReplacedArgument(callExpression, unboxingExpression, unboxedExpression); return originalMethod == method; } - - @Nullable - private PsiExpression getContainingExpression(@NotNull PsiElement expression) { - final PsiElement parent = expression.getParent(); - if (parent == null || !(parent instanceof PsiExpression) && - !(parent instanceof PsiExpressionList)) { - return null; - } - if (parent instanceof PsiParenthesizedExpression || - parent instanceof PsiExpressionList) { - return getContainingExpression(parent); - } - else { - return (PsiExpression)parent; - } - } } } \ No newline at end of file diff --git a/plugins/InspectionGadgets/test/com/siyeh/igtest/migration/unnecessary_unboxing/UnnecessaryUnboxing.java b/plugins/InspectionGadgets/test/com/siyeh/igtest/migration/unnecessary_unboxing/UnnecessaryUnboxing.java index 369314c531fd..f4eafc37974a 100644 --- a/plugins/InspectionGadgets/test/com/siyeh/igtest/migration/unnecessary_unboxing/UnnecessaryUnboxing.java +++ b/plugins/InspectionGadgets/test/com/siyeh/igtest/migration/unnecessary_unboxing/UnnecessaryUnboxing.java @@ -37,12 +37,21 @@ public class UnnecessaryUnboxing { void casting(Byte b) { System.out.println((byte)b.byteValue()); + casting((((b.byteValue())))); } byte cast(Integer v) { return (byte)v.intValue(); } + + void comparison() { + Integer a = Integer.valueOf(1024); + Integer b = Integer.valueOf(1024); + System.out.println(a == b == true); // false + System.out.println(a.intValue() == b.intValue() == true); // true + System.out.println(a.intValue() == 1024); + } }