SONARJAVA-1227 Expose kind() in Tree interface

Author: mpaladin

java-checks/src/main/java/org/sonar/java/checks/AssignmentInSubExpressionCheck.java

@@ -119,12 +119,13 @@ private static AssignmentExpressionTree getInnerAssignmentExpression(ExpressionT
   }
 
   private static boolean isRelationalExpression(Tree tree) {
-    return tree.is(Kind.EQUAL_TO) ||
-      tree.is(Kind.NOT_EQUAL_TO) ||
-      tree.is(Kind.LESS_THAN) ||
-      tree.is(Kind.LESS_THAN_OR_EQUAL_TO) ||
-      tree.is(Kind.GREATER_THAN) ||
-      tree.is(Kind.GREATER_THAN_OR_EQUAL_TO);
+    return tree.is(
+      Kind.EQUAL_TO,
+      Kind.NOT_EQUAL_TO,
+      Kind.LESS_THAN,
+      Kind.LESS_THAN_OR_EQUAL_TO,
+      Kind.GREATER_THAN,
+      Kind.GREATER_THAN_OR_EQUAL_TO);
   }
 
   @Override

java-checks/src/main/java/org/sonar/java/checks/CastArithmeticOperandCheck.java

@@ -24,7 +24,6 @@
 import org.sonar.api.server.rule.RulesDefinition;
 import org.sonar.check.Priority;
 import org.sonar.check.Rule;
-import org.sonar.java.model.JavaTree;
 import org.sonar.java.model.declaration.MethodTreeImpl;
 import org.sonar.plugins.java.api.semantic.Symbol;
 import org.sonar.plugins.java.api.semantic.Type;
@@ -40,7 +39,6 @@
 import org.sonar.squidbridge.annotations.SqaleSubCharacteristic;
 
 import javax.annotation.Nullable;
-
 import java.util.List;
 import java.util.Map;
 
@@ -109,7 +107,7 @@ private void checkMethodInvocationArgument(MethodInvocationTree mit) {
 
   private void checkExpression(Type varType, @Nullable ExpressionTree expr) {
     if (isVarTypeErrorProne(varType) && expressionIsOperationToInt(expr)) {
-      addIssue(expr, "Cast one of the operands of this " + OPERATION_BY_KIND.get(((JavaTree) expr).getKind()) + " operation to a \"" + varType.name() + "\".");
+      addIssue(expr, "Cast one of the operands of this " + OPERATION_BY_KIND.get(expr.kind()) + " operation to a \"" + varType.name() + "\".");
     }
   }
 

java-checks/src/main/java/org/sonar/java/checks/ConstantsShouldBeStaticFinalCheck.java

@@ -36,6 +36,7 @@
 import org.sonar.squidbridge.annotations.SqaleConstantRemediation;
 import org.sonar.squidbridge.annotations.SqaleSubCharacteristic;
 
+import java.util.Arrays;
 import java.util.Iterator;
 import java.util.List;
 
@@ -110,10 +111,8 @@ private static boolean hasConstantInitializer(VariableTree variableTree) {
   }
 
   private static boolean containsChildrenOfKind(JavaTree tree, Tree.Kind... kinds) {
-    for (Tree.Kind kind : kinds) {
-      if (tree.is(kind)) {
-        return true;
-      }
+    if (Arrays.asList(kinds).contains(tree.kind())) {
+      return true;
     }
     if (!tree.isLeaf()) {
       Iterator<Tree> treeIterator = tree.childrenIterator();

java-checks/src/main/java/org/sonar/java/checks/FloatEqualityCheck.java

@@ -23,7 +23,6 @@
 import org.sonar.api.server.rule.RulesDefinition;
 import org.sonar.check.Priority;
 import org.sonar.check.Rule;
-import org.sonar.java.model.JavaTree;
 import org.sonar.java.model.SyntacticEquivalence;
 import org.sonar.plugins.java.api.semantic.Type;
 import org.sonar.plugins.java.api.tree.BinaryExpressionTree;
@@ -71,7 +70,7 @@ private static boolean isIndirectEquality(BinaryExpressionTree binaryExpressionT
       BinaryExpressionTree leftOp = (BinaryExpressionTree) binaryExpressionTree.leftOperand();
       if (binaryExpressionTree.rightOperand().is(comparator1, comparator2)) {
         BinaryExpressionTree rightOp = (BinaryExpressionTree) binaryExpressionTree.rightOperand();
-        if (((JavaTree) leftOp).getKind().equals(((JavaTree) rightOp).getKind())) {
+        if (leftOp.kind().equals(rightOp.kind())) {
           //same operator
           return SyntacticEquivalence.areEquivalent(leftOp.leftOperand(), rightOp.rightOperand())
               && SyntacticEquivalence.areEquivalent(leftOp.rightOperand(), rightOp.leftOperand());

java-checks/src/main/java/org/sonar/java/checks/ForLoopFalseConditionCheck.java

@@ -89,15 +89,22 @@ private static boolean isConditionFalseAtInitialization(ForStatementTree forStat
   }
 
   private static boolean evaluateCondition(ExpressionTree condition, int leftOperand, int rightOperand) {
-    boolean conditionValue = true;
-    if (condition.is(Tree.Kind.GREATER_THAN)) {
-      conditionValue = leftOperand > rightOperand;
-    } else if (condition.is(Tree.Kind.GREATER_THAN_OR_EQUAL_TO)) {
-      conditionValue = leftOperand >= rightOperand;
-    } else if (condition.is(Tree.Kind.LESS_THAN)) {
-      conditionValue = leftOperand < rightOperand;
-    } else if (condition.is(Tree.Kind.LESS_THAN_OR_EQUAL_TO)) {
-      conditionValue = leftOperand <= rightOperand;
+    boolean conditionValue;
+    switch (condition.kind()) {
+      case GREATER_THAN:
+        conditionValue = leftOperand > rightOperand;
+        break;
+      case GREATER_THAN_OR_EQUAL_TO:
+        conditionValue = leftOperand >= rightOperand;
+        break;
+      case LESS_THAN:
+        conditionValue = leftOperand < rightOperand;
+        break;
+      case LESS_THAN_OR_EQUAL_TO:
+        conditionValue = leftOperand <= rightOperand;
+        break;
+      default:
+        conditionValue = true;
     }
     return conditionValue;
   }

java-checks/src/main/java/org/sonar/java/checks/HiddenFieldCheck.java

@@ -185,11 +185,11 @@ private void visitChildren(Tree tree) {
     }
 
     private boolean isSubscribed(Tree tree) {
-      return visitNodes.contains(((JavaTree) tree).getKind());
+      return visitNodes.contains(tree.kind());
     }
 
     private boolean isExcluded(Tree tree) {
-      return excludedNodes.contains(((JavaTree) tree).getKind());
+      return excludedNodes.contains(tree.kind());
     }
   }
 

java-checks/src/main/java/org/sonar/java/checks/IdenticalOperandOnBinaryExpressionCheck.java

@@ -23,7 +23,6 @@
 import org.sonar.api.server.rule.RulesDefinition;
 import org.sonar.check.Priority;
 import org.sonar.check.Rule;
-import org.sonar.java.model.JavaTree;
 import org.sonar.java.model.SyntacticEquivalence;
 import org.sonar.plugins.java.api.semantic.Type;
 import org.sonar.plugins.java.api.tree.BinaryExpressionTree;
@@ -94,7 +93,7 @@ public static boolean hasEquivalentOperand(BinaryExpressionTree tree) {
     if (isNanTest(tree) || isLeftShiftOnOne(tree)) {
       return false;
     }
-    Tree.Kind binaryKind = ((JavaTree) tree).getKind();
+    Tree.Kind binaryKind = tree.kind();
     return areOperandEquivalent(tree.leftOperand(), tree.rightOperand(), binaryKind);
   }
 

java-checks/src/main/java/org/sonar/java/checks/MissingCurlyBraces_S00121_Check.java

@@ -23,7 +23,6 @@
 import org.sonar.api.server.rule.RulesDefinition;
 import org.sonar.check.Priority;
 import org.sonar.check.Rule;
-import org.sonar.java.model.JavaTree;
 import org.sonar.plugins.java.api.tree.DoWhileStatementTree;
 import org.sonar.plugins.java.api.tree.ForEachStatement;
 import org.sonar.plugins.java.api.tree.ForStatementTree;
@@ -52,7 +51,7 @@ public List<Tree.Kind> nodesToVisit() {
 
   @Override
   public void visitNode(Tree tree) {
-    switch (((JavaTree) tree).getKind()) {
+    switch (tree.kind()) {
       case WHILE_STATEMENT:
         checkStatement(((WhileStatementTree) tree).statement(), tree);
         break;

java-checks/src/main/java/org/sonar/java/checks/OperatorPrecedenceCheck.java

@@ -27,7 +27,6 @@
 import org.sonar.api.server.rule.RulesDefinition;
 import org.sonar.check.Priority;
 import org.sonar.check.Rule;
-import org.sonar.java.model.JavaTree;
 import org.sonar.java.syntaxtoken.FirstSyntaxTokenFinder;
 import org.sonar.plugins.java.api.JavaFileScanner;
 import org.sonar.plugins.java.api.JavaFileScannerContext;
@@ -148,7 +147,7 @@ public void visitArrayAccessExpression(ArrayAccessExpressionTree tree) {
   @Override
   public void visitBinaryExpression(BinaryExpressionTree tree) {
     Tree.Kind peek = stack.peek();
-    Tree.Kind kind = getKind(tree);
+    Tree.Kind kind = tree.kind();
     if (requiresParenthesis(peek, kind)) {
       raiseIssue(tree.operatorToken().line(), tree);
     }
@@ -165,7 +164,7 @@ private static boolean requiresParenthesis(Tree.Kind kind1, Tree.Kind kind2) {
   public void visitIfStatement(IfStatementTree tree) {
     super.visitIfStatement(tree);
     ExpressionTree condition = tree.condition();
-    if (condition.is(Tree.Kind.ASSIGNMENT) && EQUALITY_RELATIONAL_OPERATORS.contains(getKind(((AssignmentExpressionTree) condition).expression()))) {
+    if (condition.is(Tree.Kind.ASSIGNMENT) && EQUALITY_RELATIONAL_OPERATORS.contains(((AssignmentExpressionTree) condition).expression().kind())) {
       raiseIssue(((AssignmentExpressionTree) condition).operatorToken().line(), tree);
     }
   }
@@ -221,8 +220,4 @@ private void raiseIssue(int line, Tree tree) {
     }
   }
 
-  private static Tree.Kind getKind(Tree tree) {
-    return ((JavaTree) tree).getKind();
-  }
-
 }

java-squid/src/main/java/org/sonar/java/ast/parser/ArgumentListTreeImpl.java

@@ -75,7 +75,7 @@ public SyntaxToken closeParenToken() {
   }
 
   @Override
-  public Tree.Kind getKind() {
+  public Tree.Kind kind() {
     return Tree.Kind.ARGUMENTS;
   }