private T visit(List<? extends Tree> tx) { for (Tree t : tx) { T r = t.accept(this, null); if (r != null) { return r; } } return null; } },
private static Tree getTypeTree(Tree tree) { return tree.accept(GET_TYPE_TREE_VISITOR, null /* unused */); }
public Tree template(Tree tree) { return tree.accept(this, null); }
private boolean scan(Tree tree) { return tree.accept(this, null); }
private static Tree getTypeTree(Tree tree) { return tree.accept(GET_TYPE_TREE_VISITOR, null /* unused */); }
private static boolean providesFix(Tree tree, VisitorState state) { return tree.accept( new TreeScanner<Boolean, Void>() { @Override public Boolean visitMethodInvocation(MethodInvocationTree callTree, Void unused) { return super.visitMethodInvocation(callTree, unused) || DESCRIPTION_WITH_FIX.matches(callTree, state); } @Override public Boolean visitNewClass(NewClassTree constructorTree, Void unused) { return super.visitNewClass(constructorTree, unused) || DESCRIPTION_CONSTRUCTOR.matches(constructorTree, state); } @Override public Boolean reduce(Boolean m1, Boolean m2) { return firstNonNull(m1, false) || firstNonNull(m2, false); } }, null); } }
@Override protected Void defaultAction(Tree node, VisitorState state) { seenResults.add(node.accept(CONSTANT_VISITOR, state)); return null; }
/** Returns all the "assert" expressions in the tree. */ private static ImmutableList<AssertTree> scanAsserts(Tree tree) { ImmutableList.Builder<AssertTree> assertTrees = ImmutableList.builder(); tree.accept( new TreeScanner<Void, VisitorState>() { @Override public Void visitAssert(AssertTree assertTree, VisitorState visitorState) { assertTrees.add(assertTree); return null; } }, null); return assertTrees.build(); } }
/** Returns true if the tree contains a method invocation that looks like a test assertion. */ public static boolean containsTestMethod(Tree tree) { return firstNonNull( tree.accept( new TreeScanner<Boolean, Void>() { @Override public Boolean visitMethodInvocation(MethodInvocationTree node, Void unused) { String name = getSymbol(node).getSimpleName().toString(); return name.contains("assert") || name.contains("verify") || name.contains("check") || name.contains("fail") || name.contains("expect") || firstNonNull(super.visitMethodInvocation(node, null), false); } @Override public Boolean reduce(Boolean a, Boolean b) { return firstNonNull(a, false) || firstNonNull(b, false); } }, null), false); } }
static ImmutableSet<Symbol.VarSymbol> scan(Tree tree) { ImmutableSet.Builder<Symbol.VarSymbol> conditionVars = ImmutableSet.builder(); if (!firstNonNull(tree.accept(new LoopConditionVisitor(conditionVars), null), false)) { return ImmutableSet.of(); } return conditionVars.build(); }
public static boolean scan(Tree tree, ImmutableSet<Symbol.VarSymbol> variables) { UpdateScanner scanner = new UpdateScanner(variables); tree.accept(scanner, null); return scanner.modified; }
@Override public Choice<Unifier> unify(@Nullable Tree target, Unifier unifier) { return (target != null) ? target.accept(this, unifier) : Choice.<Unifier>none(); }
static boolean scan(Tree tree, VisitorState state, Symbol searchedBufferSymbol) { ValidByteBufferArrayScanner visitor = new ValidByteBufferArrayScanner(searchedBufferSymbol); tree.accept(visitor, state); return visitor.valid; }
static Collection<GuardedByExpression> find( Tree tree, VisitorState state, Matcher<ExpressionTree> lockOperationMatcher) { if (tree == null) { return Collections.emptyList(); } LockOperationFinder finder = new LockOperationFinder(state, lockOperationMatcher); tree.accept(finder, null); return finder.locks; }
@Override public boolean matches(Tree tree, VisitorState state) { FirstMatchingScanner scanner = new FirstMatchingScanner(state); Boolean matchFound = tree.accept(scanner, /* data= */ false); return matchFound != null && matchFound; }
@Override public Boolean scan(Tree t, Unifier unifier) { if (t != null) { Boolean forbidden = t.accept(PlaceholderUnificationVisitor.FORBIDDEN_REFERENCE_VISITOR, unifier); return firstNonNull(forbidden, false) || firstNonNull(super.scan(t, unifier), false); } return false; } };
static Multimap<VarSymbol, Tree> scan(Tree tree) { WriteVisitor visitor = new WriteVisitor(); tree.accept(visitor, null); return visitor.writes; }
static boolean scan(Tree tree, VisitorState state, Set<VarSymbol> badMocks) { return firstNonNull(tree.accept(new MockAnswerStrategyScanner(state, badMocks), null), false); }
public Choice<? extends State<? extends JCTree>> unify(@Nullable Tree node, State<?> state) { if (node instanceof ExpressionTree) { return unifyExpression((ExpressionTree) node, state); } else if (node == null) { return Choice.of(state.<JCTree>withResult(null)); } else { return node.accept(this, state); } }
@Override public Void visitClass(ClassTree node, Context context) { Symbol sym = ASTHelpers.getSymbol(node); if (sym == null || !sym.getQualifiedName().contentEquals(rule().qualifiedTemplateClass())) { ListBuffer<JCStatement> statements = new ListBuffer<>(); for (Tree tree : node.getMembers()) { if (tree instanceof JCStatement) { statements.append((JCStatement) tree); } else { tree.accept(this, context); } } scan(TreeMaker.instance(context).Block(0, statements.toList()), context); } return null; }