Issue checkstyle#14872: no violation on casting fix

mohitsatr · Dec 13, 2024 · a32c498 · a32c498
1 parent 68db178
commit a32c498
Show file tree

Hide file tree

Showing 7 changed files with 364 additions and 37 deletions.
diff --git a/config/checkstyle-checks.xml b/config/checkstyle-checks.xml
@@ -577,7 +577,7 @@
                        SL_ASSIGN, SR_ASSIGN, STAR_ASSIGN, LAMBDA, TEXT_BLOCK_LITERAL_BEGIN, LAND,
                        LOR, LITERAL_INSTANCEOF, GT, LT, GE, LE, EQUAL, NOT_EQUAL, UNARY_MINUS,
                        UNARY_PLUS, INC, DEC, LNOT, BNOT, POST_INC, POST_DEC, BOR, BXOR, BAND,
-                       QUESTION"/>
+                       QUESTION, TYPECAST"/>
     </module>
     <module name="UnnecessarySemicolonAfterOuterTypeDeclaration"/>
     <module name="UnnecessarySemicolonAfterTypeMemberDeclaration"/>

diff --git a/src/main/java/com/puppycrawl/tools/checkstyle/checks/coding/UnnecessaryParenthesesCheck.java b/src/main/java/com/puppycrawl/tools/checkstyle/checks/coding/UnnecessaryParenthesesCheck.java
@@ -182,7 +182,9 @@
  * <a href="https://checkstyle.org/apidocs/com/puppycrawl/tools/checkstyle/api/TokenTypes.html#POST_INC">
  * POST_INC</a>,
  * <a href="https://checkstyle.org/apidocs/com/puppycrawl/tools/checkstyle/api/TokenTypes.html#POST_DEC">
- * POST_DEC</a>.
+ * POST_DEC</a>,
+ * <a href="https://checkstyle.org/apidocs/com/puppycrawl/tools/checkstyle/api/TokenTypes.html#TYPECAST">
+ * TYPECAST</a>.
  * </li>
  * </ul>
  *
@@ -394,6 +396,7 @@ public int[] getDefaultTokens() {
             TokenTypes.BNOT,
             TokenTypes.POST_INC,
             TokenTypes.POST_DEC,
+            TokenTypes.TYPECAST,
         };
     }
 
@@ -445,6 +448,7 @@ public int[] getAcceptableTokens() {
             TokenTypes.BOR,
             TokenTypes.BAND,
             TokenTypes.QUESTION,
+            TokenTypes.TYPECAST,
         };
     }
 
@@ -467,42 +471,86 @@ else if (ast.getType() == TokenTypes.QUESTION) {
                 .forEach(unnecessaryChild -> log(unnecessaryChild, MSG_EXPR));
         }
         else if (parent.getType() != TokenTypes.ANNOTATION_MEMBER_VALUE_PAIR) {
-            final int type = ast.getType();
-            final boolean surrounded = isSurrounded(ast);
-            // An identifier surrounded by parentheses.
-            if (surrounded && type == TokenTypes.IDENT) {
-                parentToSkip = ast.getParent();
-                log(ast, MSG_IDENT, ast.getText());
-            }
-            // A literal (numeric or string) surrounded by parentheses.
-            else if (surrounded && TokenUtil.isOfType(type, LITERALS)) {
-                parentToSkip = ast.getParent();
-                if (type == TokenTypes.STRING_LITERAL) {
-                    log(ast, MSG_STRING,
-                        chopString(ast.getText()));
-                }
-                else if (type == TokenTypes.TEXT_BLOCK_LITERAL_BEGIN) {
-                    // Strip newline control characters to keep message as single-line, add
-                    // quotes to make string consistent with STRING_LITERAL
-                    final String logString = QUOTE
-                        + NEWLINE.matcher(
-                            ast.getFirstChild().getText()).replaceAll("\\\\n")
-                        + QUOTE;
-                    log(ast, MSG_STRING, chopString(logString));
-                }
-                else {
-                    log(ast, MSG_LITERAL, ast.getText());
-                }
-            }
-            // The rhs of an assignment surrounded by parentheses.
-            else if (TokenUtil.isOfType(type, ASSIGNMENTS)) {
-                assignDepth++;
-                final DetailAST last = ast.getLastChild();
-                if (last.getType() == TokenTypes.RPAREN) {
-                    log(ast, MSG_ASSIGN);
-                }
+            findUnnecessaryParenthesesInAst(ast);
+        }
+    }
+
+    /**
+     * Finds and logs if {@code LITERAL},{@code IDENT}, {@code ASSIGNMENT}
+     * and {@code TYPECAST} are surrounded by parentheses.
+     *
+     * @param ast the {@code DetailAST} to check.
+     */
+    private void findUnnecessaryParenthesesInAst(DetailAST ast) {
+        final int type = ast.getType();
+        final boolean surrounded = isSurrounded(ast);
+        // An identifier surrounded by parentheses.
+        if (surrounded && type == TokenTypes.IDENT) {
+            parentToSkip = ast.getParent();
+            log(ast, MSG_IDENT, ast.getText());
+        }
+        // A literal (numeric or string) surrounded by parentheses.
+        else if (surrounded && TokenUtil.isOfType(type, LITERALS)) {
+            findUnnecessaryParenthesesAroundLiterals(ast);
+        }
+        // The rhs of an assignment surrounded by parentheses.
+        else if (TokenUtil.isOfType(type, ASSIGNMENTS)) {
+            assignDepth++;
+            final DetailAST last = ast.getLastChild();
+            if (last.getType() == TokenTypes.RPAREN) {
+                log(ast, MSG_ASSIGN);
             }
         }
+        // A typecast surrounded by parentheses.
+        else if (surrounded && type == TokenTypes.TYPECAST
+                && isTypeCastSurrounded(ast)) {
+            log(ast, MSG_EXPR);
+        }
+    }
+
+    /**
+     * Checks and logs if the given {@code LITERAL} is surrounded by parentheses.
+     *
+     * @param ast the {@code DetailAST} to check.
+     */
+    private void findUnnecessaryParenthesesAroundLiterals(DetailAST ast) {
+        final int type = ast.getType();
+        parentToSkip = ast.getParent();
+        if (type == TokenTypes.STRING_LITERAL) {
+            log(ast, MSG_STRING,
+                    chopString(ast.getText()));
+        }
+        else if (type == TokenTypes.TEXT_BLOCK_LITERAL_BEGIN) {
+            // Strip newline control characters to keep message as single-line, add
+            // quotes to make string consistent with STRING_LITERAL
+            final String logString = QUOTE
+                    + NEWLINE.matcher(
+                    ast.getFirstChild().getText()).replaceAll("\\\\n")
+                    + QUOTE;
+            log(ast, MSG_STRING, chopString(logString));
+        }
+        else {
+            log(ast, MSG_LITERAL, ast.getText());
+        }
+    }
+
+    /**
+     * Checks if the given {@code TYPECAST} is surrounded by parentheses.
+     *
+     * @param ast the {@code DetailAST} to check if it is surrounded by
+     *        parentheses.
+     * @return {@code true} if is surrounded by
+     *         parentheses.
+     */
+    private static boolean isTypeCastSurrounded(DetailAST ast) {
+        final DetailAST parent = ast.getParent();
+        final int parentType = parent.getType();
+        return parentType != TokenTypes.DOT
+                && parentType != TokenTypes.EXPR
+                && parentType != TokenTypes.INDEX_OP
+                && parentType != TokenTypes.METHOD_REF
+                && parentType != TokenTypes.QUESTION
+                && !TokenUtil.isOfType(parentType, ASSIGNMENTS);
     }
 
     @Override

diff --git a/...ources/com/puppycrawl/tools/checkstyle/meta/checks/coding/UnnecessaryParenthesesCheck.xml b/...ources/com/puppycrawl/tools/checkstyle/meta/checks/coding/UnnecessaryParenthesesCheck.xml
@@ -68,7 +68,7 @@
  }
  &lt;/pre&gt;</description>
          <properties>
-            <property default-value="EXPR,IDENT,NUM_DOUBLE,NUM_FLOAT,NUM_INT,NUM_LONG,STRING_LITERAL,LITERAL_NULL,LITERAL_FALSE,LITERAL_TRUE,ASSIGN,BAND_ASSIGN,BOR_ASSIGN,BSR_ASSIGN,BXOR_ASSIGN,DIV_ASSIGN,MINUS_ASSIGN,MOD_ASSIGN,PLUS_ASSIGN,SL_ASSIGN,SR_ASSIGN,STAR_ASSIGN,LAMBDA,TEXT_BLOCK_LITERAL_BEGIN,LAND,LOR,LITERAL_INSTANCEOF,GT,LT,GE,LE,EQUAL,NOT_EQUAL,UNARY_MINUS,UNARY_PLUS,INC,DEC,LNOT,BNOT,POST_INC,POST_DEC"
+            <property default-value="EXPR,IDENT,NUM_DOUBLE,NUM_FLOAT,NUM_INT,NUM_LONG,STRING_LITERAL,LITERAL_NULL,LITERAL_FALSE,LITERAL_TRUE,ASSIGN,BAND_ASSIGN,BOR_ASSIGN,BSR_ASSIGN,BXOR_ASSIGN,DIV_ASSIGN,MINUS_ASSIGN,MOD_ASSIGN,PLUS_ASSIGN,SL_ASSIGN,SR_ASSIGN,STAR_ASSIGN,LAMBDA,TEXT_BLOCK_LITERAL_BEGIN,LAND,LOR,LITERAL_INSTANCEOF,GT,LT,GE,LE,EQUAL,NOT_EQUAL,UNARY_MINUS,UNARY_PLUS,INC,DEC,LNOT,BNOT,POST_INC,POST_DEC,TYPECAST"
                       name="tokens"
                       type="java.lang.String[]"
                       validation-type="tokenSet">

diff --git a/...t/java/com/puppycrawl/tools/checkstyle/checks/coding/UnnecessaryParenthesesCheckTest.java b/...t/java/com/puppycrawl/tools/checkstyle/checks/coding/UnnecessaryParenthesesCheckTest.java
@@ -100,6 +100,46 @@ public void testDefault() throws Exception {
                 getPath("InputUnnecessaryParenthesesOperatorsAndCasts.java"), expected);
     }
 
+    @Test
+    public void testCasts1() throws Exception {
+        final String[] expected = {
+            "20:18: " + getCheckMessage(MSG_EXPR),
+            "20:43: " + getCheckMessage(MSG_EXPR),
+            "30:11: " + getCheckMessage(MSG_ASSIGN),
+            "33:11: " + getCheckMessage(MSG_ASSIGN),
+            "33:22: " + getCheckMessage(MSG_EXPR),
+            "48:19: " + getCheckMessage(MSG_EXPR),
+            "65:15: " + getCheckMessage(MSG_EXPR),
+            "74:31: " + getCheckMessage(MSG_EXPR),
+            "83:40: " + getCheckMessage(MSG_EXPR),
+            "93:20: " + getCheckMessage(MSG_EXPR),
+            "96:22: " + getCheckMessage(MSG_EXPR),
+            "100:30: " + getCheckMessage(MSG_EXPR),
+            "104:38: " + getCheckMessage(MSG_EXPR),
+            "108:52: " + getCheckMessage(MSG_EXPR),
+            "114:18: " + getCheckMessage(MSG_EXPR),
+        };
+        verifyWithInlineConfigParser(
+                getPath("InputUnnecessaryParenthesesCasts1.java"), expected);
+    }
+
+    @Test
+    public void testCasts2() throws Exception {
+        final String[] expected = {
+            "31:28: " + getCheckMessage(MSG_EXPR),
+            "44:15: " + getCheckMessage(MSG_EXPR),
+            "54:32: " + getCheckMessage(MSG_EXPR),
+            "62:30: " + getCheckMessage(MSG_EXPR),
+            "72:14: " + getCheckMessage(MSG_EXPR),
+            "85:23: " + getCheckMessage(MSG_EXPR),
+            "95:23: " + getCheckMessage(MSG_EXPR),
+            "99:28: " + getCheckMessage(MSG_EXPR),
+            "103:38: " + getCheckMessage(MSG_EXPR),
+        };
+        verifyWithInlineConfigParser(
+                getPath("InputUnnecessaryParenthesesCasts2.java"), expected);
+    }
+
     @Test
     public void test15Extensions() throws Exception {
         final String[] expected = {

diff --git a/...ls/checkstyle/checks/coding/unnecessaryparentheses/InputUnnecessaryParenthesesCasts1.java b/...ls/checkstyle/checks/coding/unnecessaryparentheses/InputUnnecessaryParenthesesCasts1.java
@@ -0,0 +1,119 @@
+/*
+UnnecessaryParentheses
+tokens = (default)EXPR, IDENT, NUM_DOUBLE, NUM_FLOAT, NUM_INT, NUM_LONG, \
+         STRING_LITERAL, LITERAL_NULL, LITERAL_FALSE, LITERAL_TRUE, ASSIGN, \
+         BAND_ASSIGN, BOR_ASSIGN, BSR_ASSIGN, BXOR_ASSIGN, DIV_ASSIGN, \
+         MINUS_ASSIGN, MOD_ASSIGN, PLUS_ASSIGN, SL_ASSIGN, SR_ASSIGN, STAR_ASSIGN, \
+         LAMBDA, TEXT_BLOCK_LITERAL_BEGIN, LAND, LITERAL_INSTANCEOF, GT, LT, GE, \
+         LE, EQUAL, NOT_EQUAL, UNARY_MINUS, UNARY_PLUS, INC, DEC, LNOT, BNOT, \
+         POST_INC, POST_DEC, TYPECAST
+
+
+*/
+package com.puppycrawl.tools.checkstyle.checks.coding.unnecessaryparentheses;
+public class InputUnnecessaryParenthesesCasts1 {
+    public void valid1() {
+        int x = 23;
+        int y = 44;
+        float k = 12f;
+
+        int d = ((int) 100f) + 100 * 2 / ((int) 12.5) + (int) 90f;
+        // 2 violations above:
+        //  'Unnecessary parentheses around expression'
+        //  'Unnecessary parentheses around expression'
+        int p = (int) 110f + 10 * 2 / (int) 10f + (int) 32.2;
+
+        y = (int) (22.2 * 2) / ((int) 8f + 5);
+
+        double arg2 = 23.2;
+        int i = (int) arg2;
+        i = ((int) arg2); // violation 'Unnecessary parentheses around assignment right-hand side'
+        p = (int) arg2;
+
+        x = (2 * 2 /((int) k));
+        // 2 violations above:
+        //  'Unnecessary parentheses around assignment right-hand side'
+        //  'Unnecessary parentheses around expression'
+        x = 2 * 2 / (int) k;
+
+        int par = ((int)2f * 2) / 4;
+        y = ((Integer) x).hashCode();
+
+        int py = 12;
+        float xy = 40f;
+        int yp = 0;
+        boolean finished = true;
+        boolean result = false;
+
+        if(py >= ((int)xy) || (yp ==1 | py >=1)) {
+            // violation above 'Unnecessary parentheses around expression.'
+            xy--;
+        }
+        else if(yp >= (int)xy || (py ==1 | py >=1)) {
+            xy++;
+        }
+
+        if (!((int) xy > yp) && py < 20) {
+            py++;
+        }
+
+        if (35 + (int)'a' == 100) {
+            py++;
+        }
+
+        boolean checkone = true;
+        if (!((boolean) checkone)) {
+            // violation above 'Unnecessary parentheses around expression.'
+            checkone = false;
+        }
+        else if ((boolean) checkone) {
+            checkone = !checkone;
+        }
+
+        double limit = 3.2;
+        for (int j = 0; j >= ((int) limit); j++) {
+            // violation above 'Unnecessary parentheses around expression.'
+            yp +=1;
+        }
+        for (int j =0; j >= (int) limit; j++) {
+            py--;
+            break;
+        }
+
+        for(int j = 10; !finished && !((boolean) (j > 5)) ; j++){
+            // violation above 'Unnecessary parentheses around expression.'
+            break;
+        }
+        for(int jp = 9; !finished || !(boolean) (jp >5); jp++){
+            checkone = false;
+            break;
+        }
+
+        // violation below 'Unnecessary parentheses around expression.'
+        long p1 = ((long) ((20 >> 24 ) & 0xFF)) << 24;
+        long p2 = (long) ((20 >> 24 ) & 0xFF) << 24;
+
+        float f4 = -((float) 42); // violation 'Unnecessary parentheses around expression.'
+        float f5 = -(float) 90;
+
+        // violation below 'Unnecessary parentheses around expression.'
+        long shiftedbytwo = ((long)900) << 2;
+        long shiftedbythree = (long)899 << 3;
+
+        // violation below 'Unnecessary parentheses around expression.'
+        short complement = (short) ~((short) 87777);
+        short bcomplement = (short) ~(short) 90122;
+
+        // violation below 'Unnecessary parentheses around expression.'
+        int numSlices1 = (int) Math.max(Math.ceil(((double) 20) / 10), 1);
+        int numSlices2 = (int) Math.max(Math.ceil((double) 20 / 10), 1);
+    }
+
+    private long getLong1(int start, int end) {
+        // violation below 'Unnecessary parentheses around expression.'
+        return (((long) start) << 32) | 0xFFFFFFFFL & end;
+    }
+    private long getLong2(int start, int end) {
+        return ((long) start << 32) | 0xFFFFFFFFL & end;
+    }
+}