import com.google.javascript.jscomp.NodeUtil.Visitor; //导入依赖的package包/类
private Node replaceTypeVariablesWithUnknown(JSDocInfo functionJsdoc, Node typeAst) {
  final List<String> typeVars = functionJsdoc.getTemplateTypeNames();
  if (typeVars.isEmpty()) {
    return typeAst;
  }
  NodeUtil.visitPreOrder(typeAst, new Visitor(){
    @Override
    public void visit(Node n) {
      if (n.isString() && n.getParent() != null && typeVars.contains(n.getString())) {
        n.replaceWith(new Node(Token.QMARK));
      }
    }
  });
  return typeAst;
}
 

import com.google.javascript.jscomp.NodeUtil.Visitor; //导入依赖的package包/类
private void maybeAddUsage(
    final NodeTraversal t,
    final Node n,
    Node rootTypeNode,
    final boolean markStrongUsages,
    Predicate<Node> pred) {
  Visitor visitor =
      new Visitor() {
        @Override
        public void visit(Node typeNode) {
          if (typeNode.isString()) {
            String typeString = typeNode.getString();
            if (mode == Mode.SINGLE_FILE && !typeString.contains(".")) {
              // If using a single-name type, it's probably something like Error, which we
              // don't have externs for.
              weakUsages.add(typeString);
              return;
            }
            String rootName = Splitter.on('.').split(typeString).iterator().next();
            Var var = t.getScope().getVar(rootName);
            if (var == null || (var.isGlobal() && !var.isExtern())) {
              if (markStrongUsages) {
                usages.put(typeString, n);
              } else {
                // If we're not adding strong usages here, add weak usages for the prefixes of the
                // namespace, like we do for GETPROP nodes. Otherwise we get an extra require
                // warning for cases like:
                //
                //     goog.require('foo.bar.SomeService');
                //
                //     /** @constructor @extends {foo.bar.SomeService.Handler} */
                //     var MyHandler = function() {};
                addWeakUsagesOfAllPrefixes(typeString);
              }
            } else {
              // Even if the root namespace is in externs, add weak usages because the full
              // namespace may still be goog.provided.
              addWeakUsagesOfAllPrefixes(typeString);
            }
          }
        }
      };

  NodeUtil.visitPreOrder(rootTypeNode, visitor, pred);
}
 

import com.google.javascript.jscomp.NodeUtil.Visitor; //导入依赖的package包/类
/** Checks that the scope roots marked as changed have indeed changed */
private void verifyScopeChangesHaveBeenRecorded(String passName, Node root) {
  final String passNameMsg = passName.isEmpty() ? "" : passName + ": ";

  // Gather all the scope nodes that existed when the snapshot was taken.
  final Set<Node> snapshotScopeNodes = new HashSet<>();
  NodeUtil.visitPreOrder(
      clonesByCurrent.get(root),
      new Visitor() {
        @Override
        public void visit(Node oldNode) {
          if (NodeUtil.isChangeScopeRoot(oldNode)) {
            snapshotScopeNodes.add(oldNode);
          }
        }
      },
      Predicates.<Node>alwaysTrue());

  NodeUtil.visitPreOrder(
      root,
      new Visitor() {
        @Override
        public void visit(Node n) {
          if (n.isRoot()) {
            verifyRoot(n);
          } else if (NodeUtil.isChangeScopeRoot(n)) {
            Node clone = clonesByCurrent.get(n);
            // Remove any scope nodes that still exist.
            snapshotScopeNodes.remove(clone);
            verifyNode(passNameMsg, n);
            if (clone == null) {
              verifyNewNode(passNameMsg, n);
            } else {
              verifyNodeChange(passNameMsg, n, clone);
            }
          }
        }
      },
      Predicates.<Node>alwaysTrue());

  // Only actually deleted snapshot scope nodes should remain.
  verifyDeletedScopeNodes(passNameMsg, snapshotScopeNodes);
}