@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 symbol = ASTHelpers.getSymbol(stripParentheses(tree.getExpression())); if (!(symbol instanceof VarSymbol)) { return NO_MATCH; } // TODO(cushon): check that the receiver doesn't contain mutable state. // Currently 'this.locks[i].mu' is accepted if 'mu' is final but 'locks' is non-final. VarSymbol varSymbol = (VarSymbol) symbol; if (varSymbol.isLocal() || varSymbol.isStatic() || (varSymbol.flags() & Flags.FINAL) != 0) { return NO_MATCH; } if (ASTHelpers.hasAnnotation(varSymbol, LazyInit.class, state)) { return NO_MATCH; } Name ownerName = varSymbol.owner.enclClass().getQualifiedName(); if (Stream.of("java.io.Writer", "java.io.Reader").anyMatch(ownerName::contentEquals)) { // These classes contain a non-final 'lock' variable available to subclasses, and we can't // make these locks final. return NO_MATCH; } return describeMatch(tree.getExpression()); } }
@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<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 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 Boolean visitSynchronized(SynchronizedTree node, TreePath p) { if (p == null) { super.visitSynchronized(node, p); return false; } SynchronizedTree at = (SynchronizedTree) p.getLeaf(); if (!scan(node.getExpression(), at.getExpression(), p)) { return false; } return scan(node.getBlock(), at.getBlock(), p); }
public R visitSynchronized(SynchronizedTree node, P p) { R r = scan(node.getExpression(), p); r = scanAndReduce(node.getBlock(), p, r); return r; }
public R visitSynchronized(SynchronizedTree node, P p) { R r = scan(node.getExpression(), p); r = scanAndReduce(node.getBlock(), p, r); return r; }
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; }