How to use

is

method

in

org.sonar.plugins.java.api.tree.StatementTree

 private static boolean hasBodySingleIfStatement(StatementTree thenStatement) {

  if (thenStatement.is(Tree.Kind.BLOCK)) {
   // thenStatement has curly braces. Let's see what's inside...
   BlockTree block = (BlockTree) thenStatement;
   return block.body().size() == 1 && block.body().get(0).is(Tree.Kind.IF_STATEMENT);
  } else if (thenStatement.is(Tree.Kind.IF_STATEMENT)) {
   // no curlys on thenStatement; it's a bare if statement
   return true;
  }

  return false;
 }
}

public void addVariables(List<StatementTree> statementTrees) {
 for (StatementTree statementTree : statementTrees) {
  if (statementTree.is(Tree.Kind.VARIABLE)) {
   addVariable((VariableTree) statementTree);
  }
 }
}

@CheckForNull
private static ExpressionTree expressionFromSingleStatementBlock(List<StatementTree> body) {
 if (body.size() == 1) {
  StatementTree singleStatement = body.get(0);
  if (singleStatement.is(Tree.Kind.EXPRESSION_STATEMENT)) {
   return ((ExpressionStatementTree) singleStatement).expression();
  }
 }
 return null;
}

 private void checkStatement(SyntaxToken reportToken, StatementTree statement) {
  if (!statement.is(Tree.Kind.BLOCK)) {
   reportIssue(reportToken, "Missing curly brace.");
  }
 }
}

private static boolean isLastStatement(@Nullable BlockTree blockTree, MethodInvocationTree lastStatementTree) {
 if (blockTree != null) {
  StatementTree last = Iterables.getLast(blockTree.body());
  if (last.is(Kind.EXPRESSION_STATEMENT)) {
   return lastStatementTree.equals(((ExpressionStatementTree) last).expression());
  } else if (last.is(Kind.TRY_STATEMENT)) {
   return isLastStatement(((TryStatementTree) last).finallyBlock(), lastStatementTree);
  }
 }
 return false;
}

private void checkBlock(BlockTree blockTree) {
 BlockTree innerBlock = blockTree;
 while (innerBlock.body().size() == 1 && innerBlock.body().get(0).is(Tree.Kind.BLOCK)) {
  innerBlock = (BlockTree) innerBlock.body().get(0);
 }
 List<StatementTree> statementTreeList = innerBlock.body().stream()
  .filter(statementTree -> !statementTree.is(Tree.Kind.EMPTY_STATEMENT))
  .collect(Collectors.toList());
 if (isReturnTrueStatement(statementTreeList)) {
  reportIssue(statementTreeList.get(0), ISSUE_MESSAGE);
 }
}

private static boolean isReturnBooleanLiteral(StatementTree statementTree) {
 if (statementTree.is(Kind.RETURN_STATEMENT)) {
  ExpressionTree expression = ((ReturnStatementTree) statementTree).expression();
  return expression != null && expression.is(Tree.Kind.BOOLEAN_LITERAL);
 }
 return false;
}

private void checkStatements(List<StatementTree> statements) {
 for (StatementTree statement : statements) {
  if (statement.is(Tree.Kind.BLOCK)) {
   context.reportIssue(this, ((BlockTree) statement).openBraceToken(), "Extract this nested code block into a method.");
  }
 }
}

private static boolean onlyReturnLiteralsOrThrowException(MethodTree methodTree) {
 BlockTree block = methodTree.block();
 if (block == null) {
  return false;
 }
 List<StatementTree> body = block.body();
 if (body.size() != 1) {
  return false;
 }
 StatementTree singleStatement = body.get(0);
 return singleStatement.is(Tree.Kind.THROW_STATEMENT) || returnStatementWithLiteral(singleStatement);
}

private static boolean hasOneReturnBoolean(@Nullable StatementTree statementTree) {
 if (statementTree == null) {
  return false;
 }
 if (statementTree.is(Kind.BLOCK)) {
  BlockTree block = (BlockTree) statementTree;
  return block.body().size() == 1 && isReturnBooleanLiteral(block.body().get(0));
 }
 return isReturnBooleanLiteral(statementTree);
}

 private static boolean onlyRethrows(CatchTree catchTree) {
  List<StatementTree> catchBody = catchTree.block().body();
  if (catchBody.size() == 1) {
   return catchBody.get(0).is(Tree.Kind.THROW_STATEMENT) && catchTree.parameter().symbol().usages().contains(((ThrowStatementTree) catchBody.get(0)).expression());
  }
  return false;
 }
}

private static boolean isLastStatement(MethodTree methodTree, MethodInvocationTree lastStatementTree) {
 BlockTree blockTree = methodTree.block();
 if (blockTree != null
  && blockTree.body().stream().anyMatch(statement -> statement.is(Kind.TRY_STATEMENT) && isLastStatement(((TryStatementTree) statement).finallyBlock(), lastStatementTree))) {
  return true;
 }
 return isLastStatement(blockTree, lastStatementTree);
}

private static boolean isUselessSuperCall(MethodTree methodTree) {
 ExpressionTree callToSuper = null;
 StatementTree statementTree = methodTree.block().body().get(0);
 if (returnsVoid(methodTree) && statementTree.is(Tree.Kind.EXPRESSION_STATEMENT)) {
  callToSuper = ((ExpressionStatementTree) statementTree).expression();
 } else if (statementTree.is(Tree.Kind.RETURN_STATEMENT)) {
  callToSuper = ((ReturnStatementTree) statementTree).expression();
 }
 return callToSuper != null && isCallToSuper(methodTree, callToSuper) && sameVisibility(methodTree.symbol(), ((MethodInvocationTree) callToSuper).symbol());
}

private static boolean isLoggingMethod(StatementTree statementTree, IdentifierTree exceptionIdentifier) {
 if (!statementTree.is(Tree.Kind.EXPRESSION_STATEMENT)) {
  return false;
 }
 ExpressionTree expression = ((ExpressionStatementTree) statementTree).expression();
 if (expression.is(Tree.Kind.METHOD_INVOCATION)) {
  MethodInvocationTree mit = (MethodInvocationTree) expression;
  return LOGGING_METHODS.anyMatch(mit) && isExceptionUsed(exceptionIdentifier, mit);
 }
 return false;
}

 @Override
 public void visitNode(Tree tree) {
  CaseGroupTree cgt = (CaseGroupTree) tree;
  for (StatementTree statementTree : cgt.body()) {
   if (statementTree.is(LABELED_STATEMENT)) {
    IdentifierTree label = ((LabeledStatementTree) statementTree).label();
    reportIssue(label, "Remove this misleading \"" + label.name() + "\" label.");
   }
  }
 }
}

 private void checkForReport(StatementTree statement, Tree startTree, Tree endTree, String name) {
  if (!(statement.is(Tree.Kind.BLOCK) || statement.firstToken().column() > startTree.firstToken().column())) {
   context.reportIssue(this, startTree, endTree,
    "Use indentation to denote the code conditionally executed by this \"" + name + "\".",
    Collections.singletonList(new JavaFileScannerContext.Location("", statement)), null);
  }
 }
}

private static boolean isUnsupportedCloneOverride(MethodTree methodTree) {
 if (isOneStatementMethod(methodTree)) {
  StatementTree statementTree = methodTree.block().body().get(0);
  return statementTree.is(Tree.Kind.THROW_STATEMENT) && ((ThrowStatementTree) statementTree).expression().symbolType().is("java.lang.CloneNotSupportedException");
 }
 return false;
}

 @Override
 public void visitNode(Tree tree) {
  IfStatementTree treeIfStmt = (IfStatementTree) tree;
  StatementTree elseStmt = treeIfStmt.elseStatement();
  if (elseStmt != null && elseStmt.is(Tree.Kind.IF_STATEMENT)) {
   IfStatementTree ifStmt = (IfStatementTree) elseStmt;
   if (ifStmt.elseStatement() == null) {
    reportIssue(treeIfStmt.elseKeyword(), ifStmt.ifKeyword(), "\"if ... else if\" constructs should end with \"else\" clauses.");
   }
  }
 }
}

private void addLineOfCloseBrace(SyntaxToken startToken, StatementTree tree) {
 if (tree.is(Tree.Kind.BLOCK)) {
  SyntaxToken closeBraceToken = ((BlockTree) tree).closeBraceToken();
  if (startToken.line() != closeBraceToken.line() && !statementsPerLine.contains(closeBraceToken.line())) {
   addLine(closeBraceToken);
  }
 }
}

private void visit(IfStatementTree tree) {
 scan(tree.condition());
 scan(tree.thenStatement());
 StatementTree elseStatementTree = tree.elseStatement();
 if (elseStatementTree != null && elseStatementTree.is(Tree.Kind.IF_STATEMENT)) {
  visit((IfStatementTree) elseStatementTree);
 } else {
  scan(elseStatementTree);
 }
}