Java SynchronizedTree类代码示例

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
/** Matches if this Tree is enclosed by either a synchronized block or a synchronized method. */
public static final <T extends Tree> Matcher<T> inSynchronized() {
  return new Matcher<T>() {
    @Override
    public boolean matches(T tree, VisitorState state) {
      SynchronizedTree synchronizedTree =
          ASTHelpers.findEnclosingNode(state.getPath(), SynchronizedTree.class);
      if (synchronizedTree != null) {
        return true;
      }

      MethodTree methodTree = ASTHelpers.findEnclosingNode(state.getPath(), MethodTree.class);
      return methodTree != null
          && methodTree.getModifiers().getFlags().contains(Modifier.SYNCHRONIZED);
    }
  };
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@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;
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@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());
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
/**
 * Matches if this Tree is enclosed by either a synchronized block or a synchronized method.
 */
public static final <T extends Tree> Matcher<T> inSynchronized() {
  return new Matcher<T>() {
    @Override
    public boolean matches(T tree, VisitorState state) {
      SynchronizedTree synchronizedTree =
          ASTHelpers.findEnclosingNode(state.getPath(), SynchronizedTree.class);
      if (synchronizedTree != null) {
        return true;
      }

      MethodTree methodTree = ASTHelpers.findEnclosingNode(state.getPath(), MethodTree.class);
      if (methodTree != null
          && methodTree.getModifiers().getFlags().contains(Modifier.SYNCHRONIZED)) {
        return true;
      }

      return false;
    }
  };
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@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;
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
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);
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@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;
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@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);
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@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));
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@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;
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@Override
public Void visitSynchronized(SynchronizedTree tree, VisitorState visitorState) {
  VisitorState state = visitorState.withPath(getCurrentPath());
  for (SynchronizedTreeMatcher matcher : synchronizedMatchers) {
    if (!isSuppressed(matcher, state)) {
      try {
        reportMatch(matcher.matchSynchronized(tree, state), tree, state);
      } catch (Throwable t) {
        handleError(matcher, t);
      }
    }
  }
  return super.visitSynchronized(tree, state);
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@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));
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@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;
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
/**
 * Matches an instance of DCL. The canonical pattern is:
 *
 * <pre>{@code
 * if ($X == null) {
 *   synchronized (...) {
 *     if ($X == null) {
 *       ...
 *     }
 *     ...
 *   }
 * }
 * }</pre>
 *
 * Gaps before the synchronized or inner 'if' statement are ignored, and the operands in the
 * null-checks are accepted in either order.
 */
@Nullable
static DCLInfo findDCL(IfTree outerIf) {
  // TODO(cushon): Optional.ifPresent...
  ExpressionTree outerIfTest = getNullCheckedExpression(outerIf.getCondition());
  if (outerIfTest == null) {
    return null;
  }
  SynchronizedTree synchTree = getChild(outerIf.getThenStatement(), SynchronizedTree.class);
  if (synchTree == null) {
    return null;
  }
  IfTree innerIf = getChild(synchTree.getBlock(), IfTree.class);
  if (innerIf == null) {
    return null;
  }
  ExpressionTree innerIfTest = getNullCheckedExpression(innerIf.getCondition());
  if (innerIfTest == null) {
    return null;
  }
  Symbol outerSym = ASTHelpers.getSymbol(outerIfTest);
  if (!Objects.equals(outerSym, ASTHelpers.getSymbol(innerIfTest))) {
    return null;
  }
  if (!(outerSym instanceof VarSymbol)) {
    return null;
  }
  VarSymbol var = (VarSymbol) outerSym;
  return DCLInfo.create(outerIf, synchTree, innerIf, var);
}
 

import com.sun.source.tree.SynchronizedTree; //导入依赖的package包/类
@Override
public PurityResult visitSynchronized(SynchronizedTree node,
        PurityResult p) {
    PurityResult r = scan(node.getExpression(), p);
    r = scan(node.getBlock(), r);
    return r;
}