@Override public Result visitSynchronized(SynchronizedTree node, BreakContext cxt) { return node.getBlock().accept(this, cxt); }
@Override public Boolean visitSynchronized(SynchronizedTree tree, Void unused) { return scan(tree.getBlock()); }
@Override public Void visitSynchronized(SynchronizedTree tree, HeldLockSet locks) { // The synchronized expression is held in the body of the synchronized statement: Optional<GuardedByExpression> lockExpression = GuardedByBinder.bindExpression((JCExpression) tree.getExpression(), visitorState); scan(tree.getBlock(), lockExpression.isPresent() ? locks.plus(lockExpression.get()) : locks); return null; }
@Override public Void visitSynchronized(SynchronizedTree node, Context context) { scan(SKIP_PARENS.visit(node.getExpression(), null), context); scan(node.getBlock(), context); return null; }
@Override public USynchronized visitSynchronized(SynchronizedTree tree, Void v) { return USynchronized.create(template(tree.getExpression()), visitBlock(tree.getBlock(), null)); }
@Override public Description matchSynchronized(SynchronizedTree tree, VisitorState state) { Symbol lock = ASTHelpers.getSymbol(stripParentheses(tree.getExpression())); if (!(lock instanceof VarSymbol)) { return Description.NO_MATCH; } if (lock.isStatic()) { return Description.NO_MATCH; } Multimap<VarSymbol, Tree> writes = WriteVisitor.scan(tree.getBlock()); for (Entry<VarSymbol, Tree> write : writes.entries()) { if (!write.getKey().isStatic()) { continue; } state.reportMatch( buildDescription(write.getValue()).setMessage(String.format(MESSAGE, lock)).build()); } return Description.NO_MATCH; }
@Override public Choice<Unifier> visitSynchronized(SynchronizedTree synced, Unifier unifier) { return getExpression() .unify(synced.getExpression(), unifier) .thenChoose(unifications(getBlock(), synced.getBlock())); } }
@Override public Choice<State<JCSynchronized>> visitSynchronized( final SynchronizedTree node, State<?> state) { return chooseSubtrees( state, s -> unifyExpression(node.getExpression(), s), s -> unifyStatement(node.getBlock(), s), (expr, block) -> maker().Synchronized(expr, (JCBlock) block)); }
return null; IfTree innerIf = getChild(synchTree.getBlock(), IfTree.class); if (innerIf == null) { return null;
JCExpressionStatement expr = getChild(info.synchTree().getBlock(), JCExpressionStatement.class); if (expr == null) { return Description.NO_MATCH;
@Override public String visitSynchronized(SynchronizedTree node, Void v) { StringBuilder out = new StringBuilder(); ExpressionTree expr = node.getExpression(); BlockTree block = node.getBlock(); out.append("using "); Mode oldMode = mode; mode = Mode.USING_CAST; out.append(expr.accept(this, v)); mode = oldMode; out.append(block.accept(this, v)); return out.toString(); }
@Override public Void visitSynchronized(SynchronizedTree expected, Tree actual) { Optional<SynchronizedTree> other = checkTypeAndCast(expected, actual); if (!other.isPresent()) { addTypeMismatch(expected, actual); return null; } scan(expected.getExpression(), other.get().getExpression()); scan(expected.getBlock(), other.get().getBlock()); return null; }
@Override public Void visitSynchronized(SynchronizedTree expected, Tree actual) { Optional<SynchronizedTree> other = checkTypeAndCast(expected, actual); if (!other.isPresent()) { addTypeMismatch(expected, actual); return null; } scan(expected.getExpression(), other.get().getExpression()); scan(expected.getBlock(), other.get().getBlock()); return null; }
@Override public Void visitSynchronized(SynchronizedTree tree, HeldLockSet locks) { // The synchronized expression is held in the body of the synchronized statement: Optional<GuardedByExpression> lockExpression = GuardedByBinder.bindExpression((JCExpression) tree.getExpression(), visitorState); scan(tree.getBlock(), lockExpression.isPresent() ? locks.plus(lockExpression.get()) : locks); return null; }
public R visitSynchronized(SynchronizedTree node, P p) { R r = scan(node.getExpression(), p); r = scanAndReduce(node.getBlock(), p, r); return r; }
protected final SynchronizedTree rewriteChildren(SynchronizedTree tree) { ExpressionTree lock = (ExpressionTree)translate(tree.getExpression()); BlockTree body = (BlockTree)translate(tree.getBlock()); if (lock!=tree.getExpression() || body!=tree.getBlock()) { SynchronizedTree n = make.Synchronized(lock, body); model.setType(n, model.getType(tree)); copyCommentTo(tree,n); copyPosTo(tree,n); tree = n; } return tree; }
public List<Tree> visitSynchronized(SynchronizedTree node, ExpressionScanner.ExpressionsInfo p) { List<Tree> result = null; if (acceptsTree(node)) { result = scan(node.getExpression(), p); } return reduce(result, scan(node.getBlock(), p)); }
@Override public Choice<State<JCSynchronized>> visitSynchronized( final SynchronizedTree node, State<?> state) { return chooseSubtrees( state, s -> unifyExpression(node.getExpression(), s), s -> unifyStatement(node.getBlock(), s), (expr, block) -> maker().Synchronized(expr, (JCBlock) block)); }
@Override public Choice<Unifier> visitSynchronized(SynchronizedTree synced, Unifier unifier) { return getExpression() .unify(synced.getExpression(), unifier) .thenChoose(unifications(getBlock(), synced.getBlock())); } }
@Override public Tree visitSynchronized(SynchronizedTree tree, Void p) { SynchronizedTree n = make.Synchronized(tree.getExpression(), tree.getBlock()); model.setType(n, model.getType(tree)); comments.copyComments(tree, n); model.setPos(n, model.getPos(tree)); return n; }