import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
/**
 * The compiler isn't aware of the React* symbols that are exported from
 * React, inform it via an extern.
 *
 * TODO(mihai): figure out a way to do this without externs, so that the
 * symbols can get renamed.
 */
private void addExterns() {
  CompilerInput externsInput =
      CompilerAccessor.getSynthesizedExternsInputAtEnd(compiler);
  externsRoot = externsInput.getAstRoot(compiler);
  for (Map.Entry<String, String> entry : React.REACT_MODULES.entrySet()) {
    String moduleName = entry.getKey();
    String moduleType = entry.getValue();
    addExternModule(moduleName, moduleType, externsRoot);
  }
  if (!options.renameReactApi) {
    Node typesNode = createTypesNode();
    typesNode.useSourceInfoFromForTree(externsRoot);
    Node typesChildren = typesNode.getFirstChild();
    typesNode.removeChildren();
    externsRoot.addChildrenToBack(typesChildren);
  }
  compiler.reportChangeToEnclosingScope(externsRoot);
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
public void compile(JsonML source) {
  if (report != null) {
    throw new IllegalStateException(COMPILATION_ALREADY_COMPLETED_MSG);
  }

  sourceAst = new JsonMLAst(source);

  CompilerInput input = new CompilerInput(
      sourceAst, "[[jsonmlsource]]", false);

  JSModule module = new JSModule("[[jsonmlmodule]]");
  module.add(input);

  Result result = compiler.compileModules(
      ImmutableList.<SourceFile>of(),
      ImmutableList.of(module),
      options);

  report = generateReport(result);
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
/** Loop over all the inputs and clone their ASTs into this.parsedInputs. */
private void cloneParsedInputs() {
  for (CompilerInput ci : getInputsById().values()) {
    Node n = ci.getAstRoot(this);
    parsedInputs.add(n.cloneTree());
  }
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
public void testLocateNodeModuleBrowser() throws Exception {
  ImmutableList<CompilerInput> compilerInputs =
      inputs(
          "/A/index.js",
          "/A/index.json",
          "/node_modules/A/index.js",
          "/node_modules/A/foo.js",
          "/node_modules/A/node_modules/A/index.json",
          "/B/package.json",
          "/B/lib/b.js",
          "/node_modules/B/package.json",
          "/node_modules/B/lib/b.js");

  ModuleLoader loader =
      new ModuleLoader(
          null,
          (new ImmutableList.Builder<String>()).build(),
          compilerInputs,
          ModuleLoader.ResolutionMode.BROWSER);

  assertNull(loader.resolve("/foo.js").resolveJsModule("/A"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("/A/index.js"));
  assertNull(loader.resolve("/foo.js").resolveJsModule("./A"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("./A/index.js"));
  assertNull(loader.resolve("/foo.js").resolveJsModule("/A"));
  assertNull(loader.resolve("/foo.js").resolveJsModule("/A/index"));
  assertUri("/A/index.json", loader.resolve("/foo.js").resolveJsModule("/A/index.json"));

  assertNull(loader.resolve("/foo.js").resolveJsModule("A"));
  assertNull(loader.resolve("/node_modules/A/foo.js").resolveJsModule("A"));
  assertNull(loader.resolve("/node_modules/A/index.js").resolveJsModule("./foo"));
  assertUri(
      "/node_modules/A/foo.js",
      loader.resolve("/node_modules/A/index.js").resolveJsModule("./foo.js"));

  assertNull(loader.resolve("/app.js").resolveJsModule("/B"));

  assertNull(loader.resolve("/app.js").resolveJsModule("B"));
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
ImmutableList<CompilerInput> inputs(String... names) {
  ImmutableList.Builder<CompilerInput> builder = ImmutableList.builder();
  for (String name : names) {
    builder.add(input(name));
  }
  return builder.build();
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
public Result compile(Node script) throws IOException {
  CompilerInput input = new CompilerInput(new SyntheticAst(script));
  JSModule jsModule = new JSModule("fuzzedModule");
  jsModule.add(input);

  Compiler.setLoggingLevel(level.getLevel());
  Compiler compiler = new Compiler();
  compiler.setTimeout(30);
  compiler.disableThreads();
  return compiler.compileModules(
      CommandLineRunner.getDefaultExterns(),
      Arrays.asList(jsModule), getOptions());
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
public Result compile(Node script) throws IOException {
  CompilerInput input = new CompilerInput(new SyntheticAst(script));
  JSModule jsModule = new JSModule("fuzzedModule");
  jsModule.add(input);

  Compiler compiler = new Compiler();
  compiler.setTimeout(30);
  return compiler.compileModules(
      CommandLineRunner.getDefaultExterns(),
      Arrays.asList(jsModule), getOptions());
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
@VisibleForTesting
static ImmutableMap<Source, Metadata<DepInfo>> computeDepInfo(
    Log log,
    ImmutableMap<Source, Metadata<DepInfo>> oldDepInfoMap,
    JsOptions options,
    Function<Source, ByteSource> loader,
    Iterable<? extends Source> sources)
throws IOException {
  final Compiler parsingCompiler = new Compiler(
      new MavenLogJSErrorManager(log));
  parsingCompiler.initOptions(options.toCompilerOptions());

  return SourceMetadataMapBuilder.updateFromSources(
      oldDepInfoMap,
      loader,
      new Extractor<DepInfo>() {
        @Override
        public DepInfo extractMetadata(Source source, byte[] content)
        throws IOException {
          String code = new String(content, Charsets.UTF_8);

          SourceFile sourceFile = new SourceFile.Builder()
              .withCharset(Charsets.UTF_8)
              .withOriginalPath(source.relativePath.getPath())
              .buildFromCode(source.canonicalPath.getPath(), code);

          CompilerInput inp = new CompilerInput(sourceFile);
          inp.setCompiler(parsingCompiler);

          Collection<String> provides = inp.getProvides();
          Collection<String> requires = inp.getRequires();

          if (provides.isEmpty() && requires.isEmpty()) {
            // closure/goog/base.js provides basic definitions for things like
            // goog.require and goog.provide.
            // Anything that calls a goog.* method implicitly requires goog.

            // closure/goog/base.js gets around this by using the special
            // "@provideGoog" annotation.

            // That seems to be specially handled by JSCompiler but not via
            // the CompilerInput API.
            CStyleLexer lexer = new CStyleLexer(
                sourceFile.getCode(),
                true /* Need doc comments. */);
            for (CStyleLexer.Token headerToken : lexer) {
              if (headerToken.type != CStyleLexer.TokenType.DOC_COMMENT) {
                break;
              }
              if (headerToken.containsText("@provideGoog")) {
                provides = ImmutableSet.of("goog");
                break;
              }
            }
          }

          return new DepInfo(
              inp.isModule(),
              inp.getName(),
              googNamespaces(provides),
              googNamespaces(requires));
        }
      },
      sources);
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
/**
 * Closure does not require all types to be explicitly provided, if they are only used in type
 * positions. However, our emit phases only emits goog.provided symbols and namespaces, so this
 * extra pass is required, in order to have valid output.
 */
private void processUnprovidedTypes(Set<String> provides, Set<String> transitiveProvides) {
  /**
   * A new set of types can be discovered while visiting unprovided types. To prevent an infinite
   * loop in a pathological case, limit to a number of passes.
   *
   * <p>TODO(rado): investigate https://github.com/angular/clutz/pull/246 and removing this pass
   * altogether.
   */
  int maxTypeUsedDepth = 5;
  Set<String> typesEmitted = new LinkedHashSet<>();
  while (maxTypeUsedDepth > 0) {
    int typesUsedCount = typesUsed.size();
    // AFAICT, there is no api for going from type to symbol, so iterate all symbols first.
    for (TypedVar symbol : compiler.getTopScope().getAllSymbols()) {
      String name = symbol.getName();
      String namespace = getNamespace(name);
      // skip unused symbols, symbols already emitted or symbols whose namespace is emitted
      // (unless the symbols have their own provide).
      if (!typesUsed.contains(name)
          || typesEmitted.contains(name)
          || (!transitiveProvides.contains(name) && typesEmitted.contains(namespace))) {
        continue;
      }

      // skip provided symbols (as default or in an namespace).
      if (provides.contains(name)
          || (!transitiveProvides.contains(name) && provides.contains(namespace))) {
        continue;
      }

      // skip extern symbols (they have a separate pass).
      CompilerInput symbolInput = this.compiler.getInput(new InputId(symbol.getInputName()));
      if (symbolInput != null && symbolInput.isExtern()) continue;

      if (shouldSkipVar(symbol)) {
        continue;
      }

      // Symbols in partial_goog_base.js are just stand ins for the real symbols, so don't emit
      if (symbol.getInputName().endsWith("partial_goog_base.js")) {
        continue;
      }

      declareNamespace(
          namespace,
          symbol,
          name,
          /* isDefault */ true,
          Collections.<String>emptySet(),
          /* isExtern */ false);
      typesEmitted.add(name);
    }
    // if no new types seen, safely break out.
    if (typesUsed.size() == typesUsedCount) break;
    maxTypeUsedDepth--;
  }
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
public void testLocateNodeModuleNode() throws Exception {
  ImmutableList<CompilerInput> compilerInputs =
      inputs(
          "/A/index.js",
          "/A/index.json",
          "/node_modules/A/index.js",
          "/node_modules/A/foo.js",
          "/node_modules/A/node_modules/A/index.json",
          "/B/package.json",
          "/B/lib/b.js",
          "/node_modules/B/package.json",
          "/node_modules/B/lib/b.js");

  ModuleLoader loader =
      new ModuleLoader(
          null,
          (new ImmutableList.Builder<String>()).build(),
          compilerInputs,
          ModuleLoader.PathResolver.RELATIVE,
          ModuleLoader.ResolutionMode.NODE,
          packageJsonMainEntries);

  assertUri("/A/index.js", loader.resolve(" /foo.js").resolveJsModule("/A"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("/A/index.js"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("./A"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("./A/index.js"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("/A"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("/A/index"));
  assertUri("/A/index.json", loader.resolve("/foo.js").resolveJsModule("/A/index.json"));

  assertUri("/node_modules/A/index.js", loader.resolve("/foo.js").resolveJsModule("A"));
  assertUri(
      "/node_modules/A/node_modules/A/index.json",
      loader.resolve("/node_modules/A/foo.js").resolveJsModule("A"));
  assertUri(
      "/node_modules/A/foo.js",
      loader.resolve("/node_modules/A/index.js").resolveJsModule("./foo"));

  assertUri("/B/lib/b.js", loader.resolve("/app.js").resolveJsModule("/B"));
  assertUri("/B/lib/b.js", loader.resolve("/app.js").resolveJsModule("/B/"));

  assertUri("/node_modules/B/lib/b.js", loader.resolve("/app.js").resolveJsModule("B"));
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
public void testLocateNodeModulesNoLeadingSlash() throws Exception {
  ImmutableList<CompilerInput> compilerInputs =
      inputs(
          "/A/index.js",
          "/A/index.json",
          "node_modules/A/index.js",
          "node_modules/A/foo.js",
          "node_modules/A/node_modules/A/index.json",
          "/B/package.json",
          "/B/lib/b.js",
          "node_modules/B/package.json",
          "node_modules/B/lib/b.js");

  ModuleLoader loader =
      new ModuleLoader(
          null,
          (new ImmutableList.Builder<String>()).build(),
          compilerInputs,
          ModuleLoader.PathResolver.RELATIVE,
          ModuleLoader.ResolutionMode.NODE,
          packageJsonMainEntries);

  assertUri("/A/index.js", loader.resolve(" /foo.js").resolveJsModule("/A"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("/A/index.js"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("./A"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("./A/index.js"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("/A"));
  assertUri("/A/index.js", loader.resolve("/foo.js").resolveJsModule("/A/index"));
  assertUri("/A/index.json", loader.resolve("/foo.js").resolveJsModule("/A/index.json"));

  assertUri("/node_modules/A/index.js", loader.resolve("/foo.js").resolveJsModule("A"));
  assertUri(
      "/node_modules/A/node_modules/A/index.json",
      loader.resolve("node_modules/A/foo.js").resolveJsModule("A"));
  assertUri(
      "node_modules/A/foo.js",
      loader.resolve("node_modules/A/index.js").resolveJsModule("./foo"));

  assertUri("/B/lib/b.js", loader.resolve("/app.js").resolveJsModule("/B"));

  assertUri("/node_modules/B/lib/b.js", loader.resolve("/app.js").resolveJsModule("B"));
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
public void testLocateNodeModulesBrowserFieldAdvancedUsage() throws Exception {
  // case where the package.json looks like the following:
  //   {"main": "server.js",
  //    "browser": {"server.js": "client.js",
  //                "exclude/this.js": false,
  //                "replace/other.js": "with/alternative.js"}}
  ImmutableMap<String, String> packageJsonMainEntries =
      ImmutableMap.of(
          "/node_modules/mymodule/package.json", "/node_modules/mymodule/server.js",
          "/node_modules/mymodule/server.js", "/node_modules/mymodule/client.js",
          "/node_modules/mymodule/override/relative.js", "/node_modules/mymodule/./with/this.js",
          "/node_modules/mymodule/exclude/this.js",
              ModuleLoader.JSC_BROWSER_BLACKLISTED_MARKER,
          "/node_modules/mymodule/replace/other.js",
          "/node_modules/mymodule/with/alternative.js");

  ImmutableList<CompilerInput> compilerInputs =
      inputs(
          "/node_modules/mymodule/package.json",
          "/node_modules/mymodule/client.js",
          "/node_modules/mymodule/with/alternative.js",
          "/node_modules/mymodule/with/this.js",
          "/foo.js");

  ModuleLoader loader =
      new ModuleLoader(
          null,
          (new ImmutableList.Builder<String>()).build(),
          compilerInputs,
          ModuleLoader.PathResolver.RELATIVE,
          ModuleLoader.ResolutionMode.NODE,
          packageJsonMainEntries);

  assertUri(
      "/node_modules/mymodule/client.js", loader.resolve("/foo.js").resolveJsModule("mymodule"));
  assertUri(
      "/node_modules/mymodule/with/alternative.js",
      loader.resolve("/foo.js").resolveJsModule("mymodule/replace/other.js"));
  assertUri(
      "/node_modules/mymodule/with/alternative.js",
      loader.resolve("/node_modules/mymodule/client.js").resolveJsModule("./replace/other.js"));
  assertUri(
      "/node_modules/mymodule/with/this.js",
      loader.resolve("/foo.js").resolveJsModule("mymodule/override/relative.js"));
  assertUri(
      "/node_modules/mymodule/with/this.js",
      loader.resolve("/node_modules/mymodule/client.js").resolveJsModule("./override/relative.js"));
  assertNull(
      loader.resolve("/node_modules/mymodule/client.js").resolveJsModule("./exclude/this.js"));
}
 

import com.google.javascript.jscomp.CompilerInput; //导入依赖的package包/类
CompilerInput input(String name) {
  return new CompilerInput(SourceFile.fromCode(name, ""), false);
}