private Tree.Kind getKind(Tree tree) { return ((JavaTree) tree).getKind(); }
private boolean isExcluded(Tree tree) { return excludedNodes.contains(((JavaTree) tree).getKind()); } }
protected boolean isSubscribed(Tree tree) { return nodesToVisit.contains(((JavaTree) tree).getKind()); }
private boolean isSubscribed(Tree tree) { return visitNodes.contains(((JavaTree) tree).getKind()); }
@Override public void visitLiteral(LiteralTree tree) { JavaType type = typesOfLiterals.get(((JavaTree) tree).getKind()); registerType(tree, type); }
private static boolean areEquivalent(@Nullable JavaTree leftNode, @Nullable JavaTree rightNode) { if (leftNode == rightNode) { return true; } if (leftNode == null || rightNode == null) { return false; } if (leftNode.getKind() != rightNode.getKind()) { return false; } else if (leftNode.isLeaf()) { return areLeafsEquivalent(leftNode, rightNode); } else if (leftNode.getKind() == Tree.Kind.OTHER) { return false; } Iterator<Tree> iteratorA = leftNode.childrenIterator(); Iterator<Tree> iteratorB = rightNode.childrenIterator(); while (iteratorA.hasNext() && iteratorB.hasNext()) { if (!areEquivalent(iteratorA.next(), iteratorB.next())) { return false; } } return !iteratorA.hasNext() && !iteratorB.hasNext(); }
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() + "\"."); } }
private JavaType resolveType(Resolve.Env env, Tree tree) { Preconditions.checkArgument(checkTypeOfTree(tree), "Kind of tree unexpected " + ((JavaTree) tree).getKind()); //FIXME(benzonico) as long as Variables share the same node type, (int i,j; or worse : int i[], j[];) check nullity to respect invariance. if (((AbstractTypedTree) tree).isTypeSet()) { return (JavaType) ((AbstractTypedTree) tree).symbolType(); } typeAndReferenceSolver.env = env; typeAndReferenceSolver.resolveAs(tree, JavaSymbol.TYP, env); typeAndReferenceSolver.env = null; return (JavaType) ((AbstractTypedTree) tree).symbolType(); }
Tree.Kind kind = ((JavaTree) tree).getKind(); String nodeName = ((JavaTree) tree).getClass().getSimpleName(); if (kind != null) {
public boolean hasEquivalentOperand(BinaryExpressionTree tree) { if (isNanTest(tree) || isLeftShiftOnOne(tree)) { return false; } Tree.Kind binaryKind = ((JavaTree) tree).getKind(); return areOperandEquivalent(tree.leftOperand(), tree.rightOperand(), binaryKind); }
@Override public void visitNode(Tree tree) { switch (((JavaTree) tree).getKind()) { case WHILE_STATEMENT: checkStatement(((WhileStatementTree) tree).statement(), tree); break; case DO_STATEMENT: checkStatement(((DoWhileStatementTree) tree).statement(), tree); break; case FOR_STATEMENT: checkStatement(((ForStatementTree) tree).statement(), tree); break; case FOR_EACH_STATEMENT: checkStatement(((ForEachStatement) tree).statement(), tree); break; case IF_STATEMENT: IfStatementTree ifStmt = (IfStatementTree) tree; checkIfStatement(ifStmt); break; default: break; } }
private boolean isIndirectEquality(BinaryExpressionTree binaryExpressionTree, Tree.Kind indirectOperator, Tree.Kind comparator1, Tree.Kind comparator2) { if (binaryExpressionTree.is(indirectOperator) && binaryExpressionTree.leftOperand().is(comparator1, comparator2)) { BinaryExpressionTree leftOp = (BinaryExpressionTree) binaryExpressionTree.leftOperand(); if (binaryExpressionTree.rightOperand().is(comparator1, comparator2)) { BinaryExpressionTree rightOp = (BinaryExpressionTree) binaryExpressionTree.rightOperand(); if (((JavaTree) leftOp).getKind().equals(((JavaTree) rightOp).getKind())) { //same operator return SyntacticEquivalence.areEquivalent(leftOp.leftOperand(), rightOp.rightOperand()) && SyntacticEquivalence.areEquivalent(leftOp.rightOperand(), rightOp.leftOperand()); } else { //different operator return SyntacticEquivalence.areEquivalent(leftOp.leftOperand(), rightOp.leftOperand()) && SyntacticEquivalence.areEquivalent(leftOp.rightOperand(), rightOp.rightOperand()); } } } return false; }