import com.sun.source.tree.AssertTree; //导入依赖的package包/类
private static List<? extends TypeMirror> computeAssert(Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    AssertTree at = (AssertTree) parent.getLeaf();
    
    types.add(ElementKind.PARAMETER);
    types.add(ElementKind.LOCAL_VARIABLE);
    types.add(ElementKind.FIELD);
    
    if (at.getCondition() == error) {
        return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.BOOLEAN));
    }
    
    if (at.getDetail() == error) {
        return Collections.singletonList(info.getElements().getTypeElement("java.lang.Object").asType());
    }
    
    
    return null;
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@TriggerTreeKind(Tree.Kind.ASSERT)
public static ErrorDescription run(HintContext ctx) {
    CompilationInfo ci = ctx.getInfo();
    AssertTree at = (AssertTree)ctx.getPath().getLeaf();
    TreePath condPath = new TreePath(ctx.getPath(), at.getCondition());
    if (ci.getTreeUtilities().isCompileTimeConstantExpression(condPath)) {
        return null;
    }
    
    SideEffectVisitor visitor = new SideEffectVisitor(ctx);
    Tree culprit;
    try {
        visitor.scan(new TreePath(ctx.getPath(), at.getCondition()), null);
        return null;
    } catch (StopProcessing stop) {
        culprit = stop.getValue();
    }
    return ErrorDescriptionFactory.forTree(ctx, culprit, TEXT_AssertWithSideEffects());
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
private static List<? extends TypeMirror> computeAssert(Set<ElementKind> types, CompilationInfo info, TreePath parent, Tree error, int offset) {
    AssertTree at = (AssertTree) parent.getLeaf();
    
    types.add(ElementKind.PARAMETER);
    types.add(ElementKind.LOCAL_VARIABLE);
    types.add(ElementKind.FIELD);
    
    if (at.getCondition() == error) {
        return Collections.singletonList(info.getTypes().getPrimitiveType(TypeKind.BOOLEAN));
    }
    
    if (at.getDetail() == error) {
        return typeMirrorCollection(info, "java.lang.Object");
    }
    
    
    return null;
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public Void visitAssert(AssertTree node, Void unused) {
    sync(node);
    builder.open(ZERO);
    token("assert");
    builder.space();
    builder.open(node.getDetail() == null ? ZERO : plusFour);
    scan(node.getCondition(), null);
    if (node.getDetail() != null) {
        builder.breakOp(" ");
        token(":");
        builder.space();
        scan(node.getDetail(), null);
    }
    builder.close();
    builder.close();
    token(";");
    return null;
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public TreePath visitAssert(AssertTree node, Context context) {
	JavacExpressionRecorder expressionRecorder = new JavacExpressionRecorder();

	JCTree.JCAssert assertStatement = (JCTree.JCAssert) node;
	JCTree.JCExpression assertCondition = assertStatement.getCondition();

	JCTree.JCExpressionStatement instrumented = treeMaker.Exec(
			treeMaker.Apply(
					List.<JCTree.JCExpression>nil(),
					qualifiedName(RECORDER_RUNTIME, "powerAssert"),
					List.of(
							treeMaker.Literal(source(assertCondition)),
							expressionRecorder.record(assertCondition),
							treeMaker.Literal(assertCondition.getStartPosition())
					)
			)
	);

	// so that we don't disrupt IDE debugging, give the instrumented expression the same position as the original
	instrumented.setPos(assertCondition.pos);

	return replaceWithInstrumented(assertStatement, instrumented);
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public Description matchMethod(MethodTree methodTree, VisitorState state) {
  if (methodTree.getBody() == null) {
    // Method is not implemented (i.e. it's abstract).
    return Description.NO_MATCH;
  }

  if (ASTHelpers.isJUnitTestCode(state)
      && JUnitMatchers.wouldRunInJUnit4.matches(methodTree, state)
      && CONTAINS_ASSERT.matches(methodTree.getBody(), state)) {

    SuggestedFix.Builder fix = SuggestedFix.builder();

    for (AssertTree foundAssert : scanAsserts(methodTree)) {
      replaceAssert(fix, foundAssert, state);
    }

    return buildDescription(methodTree).addFix(fix.build()).build();
  }
  return Description.NO_MATCH;
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
private static void addFix(
    SuggestedFix.Builder fix,
    JCExpression expr,
    AssertTree foundAssert,
    VisitorState state,
    String isMethod) {

  String assertToUse;

  if (foundAssert.getDetail() == null) {
    fix.addImport(STATIC_ASSERT_THAT_IMPORT);
    assertToUse = String.format(ASSERT_THAT, normalizedSourceForExpression(expr, state));
  } else {
    fix.addImport(STATIC_ASSERT_WITH_MESSAGE_IMPORT);
    assertToUse =
        String.format(
            ASSERT_WITH_MESSAGE,
            convertToString(foundAssert.getDetail(), state),
            normalizedSourceForExpression(expr, state));
  }

  fix.replace(foundAssert, assertToUse + isMethod);
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
/** Handles the case "expr1 == expr2" */
private static void suggestFixForSameReference(
    SuggestedFix.Builder fix, AssertTree foundAssert, VisitorState state, boolean isEqual) {

  BinaryTree equalityTree = (BinaryTree) TreeInfo.skipParens((JCTree) foundAssert.getCondition());
  ExpressionTree expr1 = equalityTree.getLeftOperand();
  ExpressionTree expr2 = equalityTree.getRightOperand();

  if (expr1.getKind() == NULL_LITERAL) {
    // case: "assert null [op] expr"
    addFix(fix, (JCExpression) expr2, foundAssert, state, isEqual ? IS_NULL : IS_NOT_NULL);
  } else if (expr2.getKind() == NULL_LITERAL) {
    // case: "assert expr [op] null"
    addFix(fix, (JCExpression) expr1, foundAssert, state, isEqual ? IS_NULL : IS_NOT_NULL);
  } else {
    // case: "assert expr1 [op] expr2"
    addFix(
        fix,
        (JCExpression) expr1,
        foundAssert,
        state,
        String.format(isEqual ? IS_SAME_AS : IS_NOT_SAME_AS, expr2));
  }
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public Tree visitAssert(AssertTree tree, Void p) {
    AssertTree n = make.Assert(tree.getCondition(), tree.getDetail());
    model.setType(n, model.getType(tree));
    comments.copyComments(tree, n);
    model.setPos(n, model.getPos(tree));
    return n;
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
public Boolean visitAssert(AssertTree node, TreePath p) {
    if (p == null) {
        super.visitAssert(node, p);
        return false;
    }

    AssertTree at = (AssertTree) p.getLeaf();

    if (!scan(node.getCondition(), at.getCondition(), p)) {
        return false;
    }

    return scan(node.getDetail(), at.getDetail(), p);
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public Void visitAssert(AssertTree tree, EnumSet<UseTypes> p) {
    if (tree.getCondition().getKind() == Kind.IDENTIFIER)
        handlePossibleIdentifier(new TreePath(getCurrentPath(), tree.getCondition()), EnumSet.of(UseTypes.READ));
    if (tree.getDetail() != null && tree.getDetail().getKind() == Kind.IDENTIFIER)
        handlePossibleIdentifier(new TreePath(getCurrentPath(), tree.getDetail()), EnumSet.of(UseTypes.READ));
    
    return super.visitAssert(tree, EnumSet.of(UseTypes.READ));
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public Object visitAssert(AssertTree node, Object p) {
    int saveCount = negationsCount;
    Object o = super.visitAssert(node, p);
    if (ignoreAsserts) {
        this.negationsCount = saveCount;
    }
    return o;
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public Void visitAssert(AssertTree tree, List<Node> d) {
    List<Node> below = new ArrayList<Node>();
    
    addCorrespondingType(below);
    addCorrespondingComments(below);
    super.visitAssert(tree, below);
    
    d.add(new TreeNode(info, getCurrentPath(), below));
    return null;
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public List<? extends TypeMirror> visitAssert(AssertTree node, Object p) {
    if (theExpression == null) {
        initExpression(node.getCondition());
    }
    return booleanType();
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public List<Tree> visitAssert(AssertTree node, ExpressionScanner.ExpressionsInfo p) {
    if (acceptsTree(node)) {
        List<Tree> result = scan(node.getCondition(), p);
        result = reduce(result, scan(node.getDetail(), p));
        return result;
    } else {
        return null;
    }
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
@Override
public boolean matches(StatementTree statementTree, VisitorState state) {
  if (!(statementTree instanceof AssertTree)) {
    return false;
  }

  return expressionMatcher.matches(((AssertTree) statementTree).getCondition(), state);
}
 

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
/**
 * Matches an assertion AST node if the given matcher matches its condition.
 *
 * @param conditionMatcher The matcher to apply to the condition in the assertion, e.g. in "assert
 *     false", the "false" part of the statement
 */
public static Matcher<AssertTree> assertionWithCondition(
    final Matcher<ExpressionTree> conditionMatcher) {
  return new Matcher<AssertTree>() {
    @Override
    public boolean matches(AssertTree tree, VisitorState state) {
      return conditionMatcher.matches(tree.getCondition(), state);
    }
  };
}
 

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

import com.sun.source.tree.AssertTree; //导入依赖的package包/类
private static void replaceAssert(
    SuggestedFix.Builder fix, AssertTree foundAssert, VisitorState state) {

  ExpressionTree expr = foundAssert.getCondition();
  expr = (ExpressionTree) TreeInfo.skipParens((JCTree) expr);

  // case: "assert !expr"
  if (expr.getKind().equals(LOGICAL_COMPLEMENT)) {
    addFix(fix, ((JCUnary) expr).getExpression(), foundAssert, state, IS_FALSE);
    return;
  }

  // case: "assert expr1.equals(expr2)"
  if (instanceMethod().onClass(Any.INSTANCE).named("equals").matches(expr, state)) {
    JCMethodInvocation equalsCall = ((JCMethodInvocation) expr);
    JCExpression expr1 = ((JCFieldAccess) ((JCMethodInvocation) expr).meth).selected;
    JCExpression expr2 = equalsCall.getArguments().get(0);

    addFix(
        fix,
        expr1,
        foundAssert,
        state,
        String.format(IS_EQUAL_TO, normalizedSourceForExpression(expr2, state)));
    return;
  }

  // case: "assert expr1 == expr2" or "assert expr1 != expr2"
  if (expr.getKind().equals(Kind.EQUAL_TO) || expr.getKind().equals(Kind.NOT_EQUAL_TO)) {
    suggestFixForSameReference(fix, foundAssert, state, expr.getKind().equals(Kind.EQUAL_TO));
    return;
  }

  // case: "assert expr", which didn't match any of the previous cases.
  addFix(fix, (JCExpression) expr, foundAssert, state, IS_TRUE);
}
 

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