import com.google.javascript.jscomp.deps.JsFileParser; //导入依赖的package包/类
private DependencyInfo getDependency(File file) {
	SourceFile sourceFile = SourceFile.fromFile(file.toString());

	JsFileParser parser = new JsFileParser(null);
	try {
		return parser.parseFile(sourceFile.getName(), null,
				sourceFile.getCode());
	} catch (IOException e) {
		e.printStackTrace();
		return null;
	}
}
 

import com.google.javascript.jscomp.deps.JsFileParser; //导入依赖的package包/类
/**
 * Regenerates the provides/requires if we need to do so.
 */
private void regenerateDependencyInfoIfNecessary() throws IOException {
  // If the code is NOT a JsAst, then it was not originally JS code.
  // Look at the Ast for dependency info.
  if (!(ast instanceof JsAst)) {
    Preconditions.checkNotNull(compiler,
        "Expected setCompiler to be called first");
    DepsFinder finder = new DepsFinder();
    Node root = getAstRoot(compiler);
    if (root == null) {
      return;
    }

    finder.visitTree(getAstRoot(compiler));

    // TODO(nicksantos|user): This caching behavior is a bit
    // odd, and only works if you assume the exact call flow that
    // clients are currently using.  In that flow, they call
    // getProvides(), then remove the goog.provide calls from the
    // AST, and then call getProvides() again.
    //
    // This won't work for any other call flow, or any sort of incremental
    // compilation scheme. The API needs to be fixed so callers aren't
    // doing weird things like this, and then we should get rid of the
    // multiple-scan strategy.

    provides.addAll(finder.provides);
    requires.addAll(finder.requires);
  } else {
    // Otherwise, look at the source code.
    if (!generatedDependencyInfoFromSource) {
      // Note: it's ok to use getName() instead of
      // getPathRelativeToClosureBase() here because we're not using
      // this to generate deps files. (We're only using it for
      // symbol dependencies.)
      DependencyInfo info = (new JsFileParser(errorManager)).parseFile(
          getName(), getName(), getCode());

      provides.addAll(info.getProvides());
      requires.addAll(info.getRequires());

      generatedDependencyInfoFromSource = true;
    }
  }
}
 

import com.google.javascript.jscomp.deps.JsFileParser; //导入依赖的package包/类
/**
 * Regenerates the provides/requires if we need to do so.
 */
private void regenerateDependencyInfoIfNecessary() throws IOException {
  // If the code is NOT a JsAst, then it was not originally JS code.
  // Look at the Ast for dependency info.
  if (!(ast instanceof JsAst)) {
    Preconditions.checkNotNull(compiler,
        "Expected setCompiler to be called first");
    DepsFinder finder = new DepsFinder();
    Node root = getAstRoot(compiler);
    if (root == null) {
      return;
    }

    finder.visitTree(getAstRoot(compiler));

    // TODO(nicksantos|user): This caching behavior is a bit
    // odd, and only works if you assume the exact call flow that
    // clients are currently using.  In that flow, they call
    // getProvides(), then remove the goog.provide calls from the
    // AST, and then call getProvides() again.
    //
    // This won't work for any other call flow, or any sort of incremental
    // compilation scheme. The API needs to be fixed so callers aren't
    // doing weird things like this, and then we should get rid of the
    // multiple-scan strategy.

    provides.addAll(finder.provides);
    requires.addAll(finder.requires);
  } else {
    // Otherwise, look at the source code.
    if (!generatedDependencyInfoFromSource) {
      // Note: it's OK to use getName() instead of
      // getPathRelativeToClosureBase() here because we're not using
      // this to generate deps files. (We're only using it for
      // symbol dependencies.)
      DependencyInfo info =
          (new JsFileParser(compiler.getErrorManager()))
          .setIncludeGoogBase(true)
          .parseFile(getName(), getName(), getCode());

      provides.addAll(info.getProvides());
      requires.addAll(info.getRequires());

      generatedDependencyInfoFromSource = true;
    }
  }
}
 

import com.google.javascript.jscomp.deps.JsFileParser; //导入依赖的package包/类
/**
 * Generates the DependencyInfo by scanning and/or parsing the file.
 * This is called lazily by getDependencyInfo, and does not take into
 * account any extra requires/provides added by {@link #addRequire}
 * or {@link #addProvide}.
 */
private DependencyInfo generateDependencyInfo() {
  Preconditions.checkNotNull(compiler, "Expected setCompiler to be called first: %s", this);
  Preconditions.checkNotNull(
      compiler.getErrorManager(), "Expected compiler to call an error manager: %s", this);

  // If the code is a JsAst, then it was originally JS code, and is compatible with the
  // regex-based parsing of JsFileParser.
  if (ast instanceof JsAst && JsFileParser.isSupported()) {
    // Look at the source code.
    // Note: it's OK to use getName() instead of
    // getPathRelativeToClosureBase() here because we're not using
    // this to generate deps files. (We're only using it for
    // symbol dependencies.)
    try {
      DependencyInfo info =
          (new JsFileParser(compiler.getErrorManager()))
          .setIncludeGoogBase(true)
          .parseFile(getName(), getName(), getCode());
      return new LazyParsedDependencyInfo(info, (JsAst) ast, compiler);
    } catch (IOException e) {
      compiler.getErrorManager().report(CheckLevel.ERROR,
          JSError.make(AbstractCompiler.READ_ERROR, getName(), e.getMessage()));
      return SimpleDependencyInfo.EMPTY;
    }
  } else {
    // Otherwise, just look at the AST.

    DepsFinder finder = new DepsFinder(getPath());
    Node root = getAstRoot(compiler);
    if (root == null) {
      return SimpleDependencyInfo.EMPTY;
    }

    finder.visitTree(root);

    // TODO(nicksantos|user): This caching behavior is a bit
    // odd, and only works if you assume the exact call flow that
    // clients are currently using.  In that flow, they call
    // getProvides(), then remove the goog.provide calls from the
    // AST, and then call getProvides() again.
    //
    // This won't work for any other call flow, or any sort of incremental
    // compilation scheme. The API needs to be fixed so callers aren't
    // doing weird things like this, and then we should get rid of the
    // multiple-scan strategy.
    return SimpleDependencyInfo.builder("", "")
        .setProvides(finder.provides)
        .setRequires(finder.requires)
        .setLoadFlags(finder.loadFlags)
        .build();
  }
}
 

import com.google.javascript.jscomp.deps.JsFileParser; //导入依赖的package包/类
public static void main(String[] args) throws Exception {
  Flags flags = new Flags();

  CmdLineParser parser = new CmdLineParser(flags);
  parser.setUsageWidth(79);
  parser.parseArgument(args);

  FileSystem fs = FileSystems.getDefault();
  final Path closure = fs.getPath(flags.closure).toAbsolutePath();

  ErrorManager errorManager = new PrintStreamErrorManager(System.err);
  JsFileParser jsFileParser = new JsFileParser(errorManager);

  List<DependencyInfo> info = new ArrayList<>(flags.inputs.size());
  for (String path : flags.inputs) {
    Path absPath = fs.getPath(path).toAbsolutePath();
    Path closureRelativePath = closure.relativize(absPath);
    info.add(
        jsFileParser.parseFile(
            absPath.toString(),
            closureRelativePath.toString(),
            new String(Files.readAllBytes(absPath), UTF_8)));
  }

  List<DependencyInfo> allDeps = new LinkedList<>(info);
  allDeps.addAll(
      new DepsFileParser(errorManager).parseFile(closure.resolve("deps.js").toString()));

  List<String> compilerFlags =
      new ClosureSortedDependencies<>(allDeps)
          .getSortedDependenciesOf(info)
          .stream()
          .map(input -> closure.resolve(input.getPathRelativeToClosureBase()))
          .map(Path::toAbsolutePath)
          .map(Path::normalize)
          .map(path -> "--js=" + path)
          .collect(toList());
  compilerFlags.add("--js=" + closure.resolve("base.js"));
  compilerFlags.addAll(flags.flags);

  CommandLineRunner.main(compilerFlags.toArray(new String[compilerFlags.size()]));
}