com.sun.source.tree.SynchronizedTree Java Examples

@Override
public Void visitSynchronized(SynchronizedTree node, Void unused) {
    sync(node);
    token("synchronized");
    builder.space();
    token("(");
    builder.open(plusFour);
    builder.breakOp();
    scan(skipParen(node.getExpression()), null);
    builder.close();
    token(")");
    builder.space();
    scan(node.getBlock(), null);
    return null;
}
 

@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;
}
 

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);
}
 

@Override
public Void visitSynchronized(SynchronizedTree tree, List<Node> d) {
    List<Node> below = new ArrayList<Node>();
    
    addCorrespondingType(below);
    addCorrespondingComments(below);
    super.visitSynchronized(tree, below);
    
    d.add(new TreeNode(info, getCurrentPath(), below));
    return null;
}
 

@TriggerTreeKind(Kind.SYNCHRONIZED)
public static ErrorDescription run(HintContext ctx) {
    ExpressionTree expression = ((SynchronizedTree) ctx.getPath().getLeaf()).getExpression();
    
    Element e = ctx.getInfo().getTrees().getElement(new TreePath(ctx.getPath(), expression));
    
    if (e == null || e.getKind() != ElementKind.FIELD || e.getModifiers().contains(Modifier.FINAL)) {
        return null;
    }
    
    String displayName = NbBundle.getMessage(SyncOnNonFinal.class, "ERR_SynchronizationOnNonFinalField");
    
    return ErrorDescriptionFactory.forTree(ctx, expression, displayName);
}
 

@Override
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 Void visitSynchronized(SynchronizedTree node, Void unused) {
    sync(node);
    token("synchronized");
    builder.space();
    token("(");
    builder.open(plusFour);
    builder.breakOp();
    scan(skipParen(node.getExpression()), null);
    builder.close();
    token(")");
    builder.space();
    scan(node.getBlock(), null);
    return null;
}
 

@Override
public Void visitSynchronized(SynchronizedTree node, Void unused) {
  sync(node);
  token("synchronized");
  builder.space();
  token("(");
  builder.open(plusFour);
  builder.breakOp();
  scan(skipParen(node.getExpression()), null);
  builder.close();
  token(")");
  builder.space();
  scan(node.getBlock(), null);
  return null;
}
 

private TreeNode convertSynchronized(SynchronizedTree node, TreePath parent) {
  TreePath path = getTreePath(parent, node);
  Expression expr = convertWithoutParens(node.getExpression(), path);
  expr.setPosition(getPosition(node));
  return new SynchronizedStatement()
      .setExpression(expr)
      .setBody((Block) convert(node.getBlock(), path));
}
 

@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;
}
 

public Boolean visitSynchronized(SynchronizedTree node, ConstructorData p) {
    super.visitSynchronized(node, p);
    return null;
}
 

@Override
public List<? extends TypeMirror> visitSynchronized(SynchronizedTree node, Object p) {
    return null;
}
 

@Override
public USynchronized visitSynchronized(SynchronizedTree tree, Void v) {
  return USynchronized.create(
      template(tree.getExpression()),
      visitBlock(tree.getBlock(), null));
}
 

@Override
public Void visitSynchronized(SynchronizedTree node, Context context) {
  scan(SKIP_PARENS.visit(node.getExpression(), null), context);
  scan(node.getBlock(), context);
  return null;
}
 

@Override
@Nullable
public Unifier visitSynchronized(SynchronizedTree synced, @Nullable Unifier unifier) {
  unifier = getExpression().unify(synced.getExpression(), unifier);
  return getBlock().unify(synced.getBlock(), unifier);
}