import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
protected CompilerPass create(AbstractCompiler compiler) {
  return new CombinedCompilerPass(
      compiler,
      ImmutableList.<Callback>of(
          new CheckDuplicateCase(compiler),
          new CheckEmptyStatements(compiler),
          new CheckEnums(compiler),
          new CheckJSDocStyle(compiler),
          new CheckJSDoc(compiler),
          new CheckMissingSemicolon(compiler),
          new CheckMissingSuper(compiler),
          new CheckPrimitiveAsObject(compiler),
          new CheckRequiresAndProvidesSorted(compiler),
          new CheckMissingAndExtraRequires(
              compiler, CheckMissingAndExtraRequires.Mode.SINGLE_FILE),
          new CheckUnusedLabels(compiler),
          new CheckUselessBlocks(compiler),
          new ClosureCheckModule(compiler),
          new Es6SuperCheck(compiler),
          new CheckSetTestOnly(state, compiler),
          new CheckStrictDeps.FirstPass(state, compiler)));
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
protected HotSwapCompilerPass create(final AbstractCompiler compiler) {
  List<Callback> sharedCallbacks = Lists.newArrayList();
  if (options.checkSuspiciousCode) {
    sharedCallbacks.add(new CheckSuspiciousCode());
  }

  if (options.enables(DiagnosticGroups.GLOBAL_THIS)) {
    sharedCallbacks.add(new CheckGlobalThis(compiler));
  }

  if (options.enables(DiagnosticGroups.DEBUGGER_STATEMENT_PRESENT)) {
    sharedCallbacks.add(new CheckDebuggerStatement(compiler));
  }

  return combineChecks(compiler, sharedCallbacks);
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
/**
 * Process transpilations if the input language needs transpilation from certain features, on any
 * JS file that has ES6 features.
 *
 * @param compiler An AbstractCompiler
 * @param combinedRoot The combined root for all JS files.
 * @param featureSet The features which this pass helps transpile.
 * @param callbacks The callbacks that should be invoked if a file has ES6 features.
 */
static void processTranspile(
    AbstractCompiler compiler, Node combinedRoot, FeatureSet featureSet, Callback... callbacks) {
  if (compiler.getOptions().needsTranspilationFrom(featureSet)) {
    for (Node singleRoot : combinedRoot.children()) {
      // TODO(lharker): Only run callbacks if the script has features from the given featureSet,
      // instead of whenever the script has any ES6+ features. We can't do this until ensuring
      // that all passes correctly update the script's associated FeatureSet.
      // The same applies in hotSwapTranspile, hotSwapCheck, and processCheck.
      if (isScriptEs6OrHigher(singleRoot)) {
        for (Callback callback : callbacks) {
          singleRoot.putBooleanProp(Node.TRANSPILED, true);
          NodeTraversal.traverseEs6(compiler, singleRoot, callback);
        }
      }
    }
  }
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
protected HotSwapCompilerPass create(final AbstractCompiler compiler) {
  List<Callback> sharedCallbacks = new ArrayList<>();
  if (options.checkSuspiciousCode) {
    sharedCallbacks.add(new CheckSuspiciousCode());
    sharedCallbacks.add(new CheckDuplicateCase(compiler));
  }

  if (options.enables(DiagnosticGroups.GLOBAL_THIS)) {
    sharedCallbacks.add(new CheckGlobalThis(compiler));
  }

  if (options.enables(DiagnosticGroups.DEBUGGER_STATEMENT_PRESENT)) {
    sharedCallbacks.add(new CheckDebuggerStatement(compiler));
  }

  return combineChecks(compiler, sharedCallbacks);
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
protected CompilerPass create(AbstractCompiler compiler) {
  return new CombinedCompilerPass(
      compiler,
      ImmutableList.<Callback>of(
          new CheckDuplicateCase(compiler),
          new CheckEmptyStatements(compiler),
          new CheckEnums(compiler),
          new CheckJSDocStyle(compiler),
          new CheckJSDoc(compiler),
          new CheckMissingSemicolon(compiler),
          new CheckMissingSuper(compiler),
          new CheckPrimitiveAsObject(compiler),
          new ClosureCheckModule(compiler),
          new CheckRequiresAndProvidesSorted(compiler),
          new CheckSideEffects(
              compiler, /* report */ true, /* protectSideEffectFreeCode */ false),
          new CheckUnusedLabels(compiler),
          new CheckUselessBlocks(compiler),
          new Es6SuperCheck(compiler)));
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
/**
 * Creates a combined compiler pass.
 * @param compiler the compiler
 */
CombinedCompilerPass(
    AbstractCompiler compiler, Callback... callbacks) {
  this.compiler = compiler;
  this.callbacks = new CallbackWrapper[callbacks.length];
  for (int i = 0; i < callbacks.length; i++) {
    this.callbacks[i] = new CallbackWrapper(callbacks[i]);
  }
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
private CallbackWrapper(Callback callback) {
  this.callback = callback;
  if (callback instanceof ScopedCallback) {
    scopedCallback = (ScopedCallback) callback;
  } else {
    scopedCallback = null;
  }
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
protected CompilerPass createInternal(final AbstractCompiler compiler) {
  List<Callback> sharedCallbacks = Lists.newArrayList();
  sharedCallbacks.add(new CheckAccidentalSemicolon(CheckLevel.WARNING));
  sharedCallbacks.add(new CheckSideEffects(CheckLevel.WARNING));
  if (options.checkGlobalThisLevel.isOn()) {
    sharedCallbacks.add(
        new CheckGlobalThis(compiler, options.checkGlobalThisLevel));
  }
  return combineChecks(compiler, sharedCallbacks);
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
/** Executes the given callbacks with a {@link CombinedCompilerPass}. */
private static CompilerPass combineChecks(AbstractCompiler compiler,
    List<Callback> callbacks) {
  Preconditions.checkArgument(callbacks.size() > 0);
  Callback[] array = callbacks.toArray(new Callback[callbacks.size()]);
  return new CombinedCompilerPass(compiler, array);
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
/**
 * Remove duplicate VAR declarations.
 */
private void removeDuplicateDeclarations(Node root) {
  Callback tickler = new ScopeTicklingCallback();
  ScopeCreator scopeCreator =  new SyntacticScopeCreator(
      compiler, new DuplicateDeclarationHandler());
  NodeTraversal t = new NodeTraversal(compiler, tickler, scopeCreator);
  t.traverse(root);
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
CombinedCompilerPass(
    AbstractCompiler compiler, List<Callback> callbacks) {
  this.compiler = compiler;
  this.callbacks = new CallbackWrapper[callbacks.size()];
  for (int i = 0; i < callbacks.size(); i++) {
    this.callbacks[i] = new CallbackWrapper(callbacks.get(i));
  }
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
static void traverse(AbstractCompiler compiler, Node root,
    List<Callback> callbacks) {
  if (callbacks.size() == 1) {
    NodeTraversal.traverse(compiler, root, callbacks.get(0));
  } else {
    (new CombinedCompilerPass(compiler, callbacks)).process(null, root);
  }
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
protected CompilerPass createInternal(final AbstractCompiler compiler) {
  List<Callback> sharedCallbacks = Lists.newArrayList();
  if (options.checkSuspiciousCode) {
    sharedCallbacks.add(new CheckAccidentalSemicolon(CheckLevel.WARNING));
    sharedCallbacks.add(new CheckSideEffects(CheckLevel.WARNING));
  }

  CheckLevel checkGlobalThisLevel = options.checkGlobalThisLevel;
  if (checkGlobalThisLevel.isOn()) {
    sharedCallbacks.add(
        new CheckGlobalThis(compiler, checkGlobalThisLevel));
  }
  return combineChecks(compiler, sharedCallbacks);
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
public void process(Node externs, Node root) {
  List<Callback> passes = Lists.newArrayList();
  if (removeAbstractMethods) {
    passes.add(new FindAbstractMethods());
  }
  if (removeAssertionCalls) {
    passes.add(new FindAssertionCalls());
  }
  CombinedCompilerPass.traverse(compiler, root, passes);

  for (RemovableAssignment assignment : abstractMethodAssignmentNodes) {
    assignment.remove();
  }

  for (Node call : assertionCalls) {
    // If the assertion is an expression, just strip the whole thing.
    Node parent = call.getParent();
    if (NodeUtil.isExpressionNode(parent)) {
      parent.getParent().removeChild(parent);
    } else {
      // Otherwise, replace the assertion with its first argument,
      // which is the return value of the assertion.
      Node firstArg = call.getFirstChild().getNext();
      if (firstArg == null) {
        parent.replaceChild(call, NodeUtil.newUndefinedNode(call));
      } else {
        parent.replaceChild(call, firstArg.detachFromParent());
      }
    }
    compiler.reportCodeChange();
  }
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
/** Executes the given callbacks with a {@link CombinedCompilerPass}. */
private static HotSwapCompilerPass combineChecks(AbstractCompiler compiler,
    List<Callback> callbacks) {
  Preconditions.checkArgument(callbacks.size() > 0);
  Callback[] array = callbacks.toArray(new Callback[callbacks.size()]);
  return new CombinedCompilerPass(compiler, array);
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
public void process(Node externs, Node root) {
  List<Callback> passes = Lists.newArrayList();
  if (removeAbstractMethods) {
    passes.add(new FindAbstractMethods());
  }
  if (removeAssertionCalls) {
    passes.add(new FindAssertionCalls());
  }
  CombinedCompilerPass.traverse(compiler, root, passes);

  for (RemovableAssignment assignment : abstractMethodAssignmentNodes) {
    assignment.remove();
  }

  for (Node call : assertionCalls) {
    // If the assertion is an expression, just strip the whole thing.
    Node parent = call.getParent();
    if (parent.isExprResult()) {
      parent.getParent().removeChild(parent);
    } else {
      // Otherwise, replace the assertion with its first argument,
      // which is the return value of the assertion.
      Node firstArg = call.getFirstChild().getNext();
      if (firstArg == null) {
        parent.replaceChild(call, NodeUtil.newUndefinedNode(call));
      } else {
        parent.replaceChild(call, firstArg.detachFromParent());
      }
    }
    compiler.reportCodeChange();
  }
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
public void hotSwapScript(Node scriptRoot, Node originalRoot) {
  String srcName = originalRoot.getSourceFileName();
  Callback cb =
      new QualifiedNameSearchTraversal(compiler.getTypeRegistry(), srcName);
  new NodeTraversal(compiler, cb).traverse(originalRoot);
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
/**
 * Remove duplicate VAR declarations.
 */
private void removeDuplicateDeclarations(Node externs, Node root) {
  Callback tickler = new ScopeTicklingCallback();
  ScopeCreator scopeCreator =  new SyntacticScopeCreator(
      compiler, new DuplicateDeclarationHandler());
  NodeTraversal t = new NodeTraversal(compiler, tickler, scopeCreator);
  t.traverseRoots(externs, root);
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
@Override
public void process(Node externs, Node root) {
  // Collect variables in externs; they can be shadowed by the same names in global scope.
  this.externNames = NodeUtil.collectExternVariableNames(this.compiler, externs);

  // Make the name of the globalSymbolNamespace an extern.
  if (addExtern) {
    addExternForGlobalSymbolNamespace();
  }

  // Rewrite all references to global symbols to properties of a single symbol:

  // Turn global named function statements into var assignments.
  NodeTraversal.traverseEs6(
      compiler, root, new RewriteGlobalClassFunctionDeclarationsToVarAssignmentsCallback());

  // Find global names that are used in more than one module. Those that
  // are have to be rewritten.
  List<Callback> nonMutatingPasses = new ArrayList<>();
  nonMutatingPasses.add(new FindCrossModuleNamesCallback());

  // And find names that may refer to functions that reference this.
  nonMutatingPasses.add(new FindNamesReferencingThis());
  CombinedCompilerPass.traverse(compiler, root, nonMutatingPasses);

  // Rewrite all references to be property accesses of the single symbol.
  RewriteScopeCallback rewriteScope = new RewriteScopeCallback();
  NodeTraversal.traverseEs6(compiler, root, rewriteScope);

  // Remove the var from statements in global scope if the declared names have been rewritten
  // in the previous pass.
  NodeTraversal.traverseEs6(compiler, root, new RemoveGlobalVarCallback());
  rewriteScope.declareModuleGlobals();
}
 

import com.google.javascript.jscomp.NodeTraversal.Callback; //导入依赖的package包/类
static void traverse(AbstractCompiler compiler, Node root,
    List<Callback> callbacks) {
  if (callbacks.size() == 1) {
    NodeTraversal.traverseEs6(compiler, root, callbacks.get(0));
  } else {
    (new CombinedCompilerPass(compiler, callbacks)).process(null, root);
  }
}