import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Void visitInstanceOf(InstanceOfTree tree, EnumSet<UseTypes> d) {
    Tree expr = tree.getExpression();
    
    if (expr instanceof IdentifierTree) {
        handlePossibleIdentifier(new TreePath(getCurrentPath(), expr), EnumSet.of(UseTypes.READ));
    }
    
    TreePath tp = new TreePath(getCurrentPath(), tree.getType());
    handlePossibleIdentifier(tp, EnumSet.of(UseTypes.CLASS_USE));
    
    super.visitInstanceOf(tree, null);
    
    //TODO: should be considered
    return null;
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Mirror visitInstanceOf(InstanceOfTree arg0, EvaluationContext evaluationContext) {
    Mirror expr = arg0.getExpression().accept(this, evaluationContext);
    VirtualMachine vm = evaluationContext.getDebugger().getVirtualMachine();
    if (vm == null) {
        return null;
    }
    if (expr == null) {
        return mirrorOf(vm, false);
    }
    Assert.assertAssignable(expr, ObjectReference.class, arg0, "instanceOfLeftOperandNotAReference", expr);

    ReferenceType expressionType = ((ObjectReference) expr).referenceType();
    Type type = (Type) arg0.getType().accept(this, evaluationContext);

    return mirrorOf(vm, instanceOf(expressionType, type));
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public boolean matches(Tree tree, VisitorState state) {
  if (tree instanceof IfTree) {
    ExpressionTree conditionTree = ASTHelpers.stripParentheses(((IfTree) tree).getCondition());

    if (conditionTree instanceof InstanceOfTree) {
      InstanceOfTree instanceOfTree = (InstanceOfTree) conditionTree;

      Types types = state.getTypes();

      boolean isCastable =
          types.isCastable(
              types.erasure(ASTHelpers.getType(instanceOfTree.getType())),
              types.erasure(ASTHelpers.getType(typeTree)));

      boolean isSameExpression =
          instanceOfTree.getExpression().toString().equals(expressionTree.toString());

      return isSameExpression && !isCastable;
    }
  }
  return false;
}
 

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

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

    InstanceOfTree t = (InstanceOfTree) p.getLeaf();

    if (!scan(node.getExpression(), t.getExpression(), p))
        return false;

    return scan(node.getType(), t.getType(), p);
}
 

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

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Void visitInstanceOf(InstanceOfTree node, Void p) {
    Element e = info.getTrees().getElement(new TreePath(getCurrentPath(), node.getExpression()));
    
    if (parameter.equals(e)) {
        throw new Found();
    }
    
    return super.visitInstanceOf(node, p);
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
/**
 * Anything object-typed could be in the instance-of
 * 
 * @param node
 * @param p
 * @return 
 */
@Override
public List<? extends TypeMirror> visitInstanceOf(InstanceOfTree node, Object p) {
    if (theExpression == null) {
        initExpression(new TreePath(getCurrentPath(), node.getExpression()));
    }
    TypeElement tel = info.getElements().getTypeElement("java.lang.Object");
    if (tel == null) {
        return null;
    }
    return Collections.singletonList(tel.asType()); // NOI18N
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Void visitInstanceOf(InstanceOfTree node, Void unused) {
    sync(node);
    builder.open(plusFour);
    scan(node.getExpression(), null);
    builder.breakOp(" ");
    builder.open(ZERO);
    token("instanceof");
    builder.breakOp(" ");
    scan(node.getType(), null);
    builder.close();
    builder.close();
    return null;
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Void visitInstanceOf(InstanceOfTree node, Void p) {
  if (!done) {
    index++;
  }
  if (tree == node) {
    done = true;
  }
  return super.visitInstanceOf(node, p);
}
 

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

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
@Nullable
public Choice<Unifier> visitInstanceOf(InstanceOfTree instanceOf, @Nullable Unifier unifier) {
  return getExpression()
      .unify(instanceOf.getExpression(), unifier)
      .thenChoose(unifications(getType(), instanceOf.getType()));
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Choice<State<JCInstanceOf>> visitInstanceOf(final InstanceOfTree node, State<?> state) {
  return chooseSubtrees(
      state,
      s -> unifyExpression(node.getExpression(), s),
      expr -> maker().TypeTest(expr, (JCTree) node.getType()));
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Description matchIf(IfTree ifTree, VisitorState visitorState) {

  ExpressionTree expressionTree = stripParentheses(ifTree.getCondition());

  if (expressionTree instanceof InstanceOfTree) {
    InstanceOfTree instanceOfTree = (InstanceOfTree) expressionTree;

    if (!(instanceOfTree.getExpression() instanceof IdentifierTree)) {
      return Description.NO_MATCH;
    }

    Matcher<Tree> assignmentTreeMatcher =
        new AssignmentTreeMatcher(instanceOfTree.getExpression());
    Matcher<Tree> containsAssignmentTreeMatcher = contains(assignmentTreeMatcher);

    if (containsAssignmentTreeMatcher.matches(ifTree, visitorState)) {
      return Description.NO_MATCH;
    }

    // set expression and type to look for in matcher
    Matcher<Tree> nestedInstanceOfMatcher =
        new NestedInstanceOfMatcher(instanceOfTree.getExpression(), instanceOfTree.getType());

    Matcher<Tree> containsNestedInstanceOfMatcher = contains(nestedInstanceOfMatcher);

    if (containsNestedInstanceOfMatcher.matches(ifTree.getThenStatement(), visitorState)) {
      return describeMatch(ifTree);
    }
  }

  return Description.NO_MATCH;
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Nullable
InstanceOfTree getRelevantTree() {
  if (notApplicable) {
    return null;
  }
  return relevantTree;
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Void visitInstanceOf(InstanceOfTree tree, ExpressionTree expr) {
  if (expressionsEqual(tree.getExpression(), expr)) {
    relevantTree = tree;
  }
  return super.visitInstanceOf(tree, expr);
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Node visitInstanceOf(InstanceOfTree tree, Void p) {
    Node operand = scan(tree.getExpression(), p);
    TypeMirror refType = InternalUtils.typeOf(tree.getType());
    InstanceOfNode node = new InstanceOfNode(tree, operand, refType,
            types);
    extendWithNode(node);
    return node;
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Node visitInstanceOf(InstanceOfTree tree, Void p) {
    Node operand = scan(tree.getExpression(), p);
    TypeMirror refType = InternalUtils.typeOf(tree.getType());
    InstanceOfNode node = new InstanceOfNode(tree, operand, refType, types);
    extendWithNode(node);
    return node;
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
@Override
public Void visitInstanceOf(InstanceOfTree expected, Tree actual) {
  Optional<InstanceOfTree> other = checkTypeAndCast(expected, actual);
  if (!other.isPresent()) {
    addTypeMismatch(expected, actual);
    return null;
  }

  scan(expected.getExpression(), other.get().getExpression());
  scan(expected.getType(), other.get().getType());
  return null;
}
 

import com.sun.source.tree.InstanceOfTree; //导入依赖的package包/类
/**
 * instanceof adds dependency on the literal type
 */
@Override
public Object visitInstanceOf(InstanceOfTree node, Object p) {
    addDependency(node.getType());
    return super.visitInstanceOf(node, p);
}