private int line(Tree tree) { return ((JavaTree) tree).getLine(); } }
private static boolean areEquivalent(@Nullable JavaTree leftNode, @Nullable JavaTree rightNode) { if (leftNode == rightNode) { return true; } if (leftNode == null || rightNode == null) { return false; } if (leftNode.kind() != rightNode.kind() || leftNode.is(Tree.Kind.OTHER)) { return false; } else if (leftNode.isLeaf()) { return areLeafsEquivalent(leftNode, rightNode); } Iterator<Tree> iteratorA = leftNode.getChildren().iterator(); Iterator<Tree> iteratorB = rightNode.getChildren().iterator(); while (iteratorA.hasNext() && iteratorB.hasNext()) { if (!areEquivalent(iteratorA.next(), iteratorB.next())) { return false; } } return !iteratorA.hasNext() && !iteratorB.hasNext(); }
private static boolean areEquivalent(@Nullable JavaTree leftNode, @Nullable JavaTree rightNode) { if (leftNode == rightNode) { return true; } if (leftNode == null || rightNode == null) { return false; } if (leftNode.kind() != rightNode.kind() || leftNode.is(Tree.Kind.OTHER)) { return false; } else if (leftNode.isLeaf()) { return areLeafsEquivalent(leftNode, rightNode); } Iterator<Tree> iteratorA = leftNode.children().iterator(); Iterator<Tree> iteratorB = rightNode.children().iterator(); while (iteratorA.hasNext() && iteratorB.hasNext()) { if (!areEquivalent(iteratorA.next(), iteratorB.next())) { return false; } } return !iteratorA.hasNext() && !iteratorB.hasNext(); }
private void visitChildren(Tree tree) { JavaTree javaTree = (JavaTree) tree; if (!javaTree.isLeaf()) { for (Tree next : javaTree.getChildren()) { if (next != null) { visit(next); } } } }
private static boolean containsChildrenOfKind(JavaTree tree, Tree.Kind... kinds) { if (Arrays.asList(kinds).contains(tree.kind())) { return true; } if (!tree.isLeaf()) { for (Tree javaTree : tree.getChildren()) { if (javaTree != null && containsChildrenOfKind((JavaTree) javaTree, kinds)) { return true; } } } return false; }
private Tree createParentLink(JavaTree topParent) { parentList.push(topParent); while (!parentList.isEmpty()) { JavaTree parent = parentList.pop(); if (!parent.isLeaf()) { for (Tree nextTree : parent.getChildren()) { JavaTree next = (JavaTree) nextTree; if (next != null) { next.setParent(parent); parentList.push(next); } } } } return topParent; } }
private boolean containsChildrenOfKind(JavaTree tree, Tree.Kind... kinds) { for (Tree.Kind kind : kinds) { if (tree.is(kind)) { return true; } } if (!tree.isLeaf()) { Iterator<Tree> treeIterator = tree.childrenIterator(); while (treeIterator.hasNext()) { JavaTree javaTree = (JavaTree) treeIterator.next(); if (javaTree != null && containsChildrenOfKind(javaTree, kinds)) { return true; } } } return false; }
public JavaTree completeAnnotationTypeMember(ModifiersTreeImpl modifiers, JavaTree partial) { if (partial.getGrammarRuleKey().equals(JavaLexer.VARIABLE_DECLARATORS)) { for (VariableTreeImpl variable : (VariableDeclaratorListTreeImpl) partial) { variable.completeModifiers(modifiers); } } else if (partial.is(Kind.CLASS, Kind.INTERFACE, Kind.ENUM, Kind.ANNOTATION_TYPE)) { ((ClassTreeImpl) partial).completeModifiers(modifiers); } else if (partial.is(Kind.METHOD)) { ((MethodTreeImpl) partial).completeWithModifiers(modifiers); } else { throw new IllegalArgumentException("Unsupported type: " + partial); } return partial; }
private void visitChildren(Tree tree) { JavaTree javaTree = (JavaTree) tree; if (!javaTree.isLeaf()) { for (Iterator<Tree> iter = javaTree.childrenIterator(); iter.hasNext(); ) { Tree next = iter.next(); if (next != null) { visit(next); } } } }
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(); }
@Override @Nullable public SyntaxToken firstToken() { for (Tree child : getChildren()) { SyntaxToken first = child.firstToken(); if (first != null) { return first; } } return null; }
/** * Caller must guarantee that nodes of the same kind. */ private static boolean areLeafsEquivalent(JavaTree leftNode, JavaTree rightNode) { if (leftNode instanceof IdentifierTree) { return Objects.equal(((IdentifierTree) leftNode).name(), ((IdentifierTree) rightNode).name()); } else if (leftNode instanceof PrimitiveTypeTree) { return Objects.equal(((PrimitiveTypeTree) leftNode).keyword().text(), ((PrimitiveTypeTree) rightNode).keyword().text()); } else if (leftNode instanceof SyntaxToken) { return Objects.equal(((SyntaxToken) leftNode).text(), ((SyntaxToken) rightNode).text()); } else if (leftNode.is(Tree.Kind.INFERED_TYPE)) { return rightNode.is(Tree.Kind.INFERED_TYPE); } else { throw new IllegalArgumentException(); } }
private void prependChild(AstNode astNode) { Preconditions.checkState(getAstNode() == this, "Legacy strongly typed node"); List<AstNode> children = getChildren(); if (children.isEmpty()) { // addChild() will take care of everything addChild(astNode); } else { AstNodeReflector.setParent(astNode, this); children.add(0, astNode); // Reset the childIndex field of all children for (int i = 0; i < children.size(); i++) { AstNodeReflector.setChildIndex(children.get(i), i); } } }
Tree.Kind kind = ((JavaTree) tree).getKind(); String nodeName = ((JavaTree) tree).getClass().getSimpleName(); if (kind != null) { AstNode node = ((JavaTree) tree).getAstNode(); if (node != null && node.hasToken()) { line = node.getTokenLine(); sb.append(" ").append(sym.getName()); int refLine = ((JavaTree) sym.declaration()).getTokenLine(); if (refLine != line) { sb.append(" ref#").append(refLine);
public AstNode completeAnnotationTypeMember(ModifiersTreeImpl modifiers, AstNode partialAstNode) { JavaTree partial = (JavaTree) partialAstNode; partial.prependChildren(modifiers); if (partial.is(JavaLexer.VARIABLE_DECLARATORS)) { for (VariableTreeImpl variable : (VariableDeclaratorListTreeImpl) partial) { variable.completeModifiers(modifiers); } } else if (partial.is(Kind.CLASS) || partial.is(Kind.INTERFACE) || partial.is(Kind.ENUM) || partial.is(Kind.ANNOTATION_TYPE)) { ((ClassTreeImpl) partial).completeModifiers(modifiers); } else if (partial.is(Kind.METHOD)) { ((MethodTreeImpl) partial).completeWithModifiers(modifiers); } else { throw new IllegalArgumentException("Unsupported type: " + partial); } return partial; }
@Override public final boolean is(Kind... kinds) { Kind treeKind = kind(); for (Kind kindIter : kinds) { if (treeKind == kindIter) { return true; } } return false; }
private static boolean containsComment(BlockTree tree) { AstNode blockAstNode = ((JavaTree) tree).getAstNode(); return blockAstNode.getLastToken().hasTrivia(); }
public List<Tree> getChildren() { if(children == null) { children = new ArrayList<>(); children().forEach(child -> { // null children are ignored if (child != null) { children.add(child); } }); } return children; }