import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
/**
 * Puts the JS files into a topologically sorted order by their dependencies.
 */
public void sortInputsByDeps(Compiler compiler) {
  // Set the compiler, so that we can parse requires/provides and report
  // errors properly.
  for (CompilerInput input : inputs) {
    input.setCompiler(compiler);
  }

  // Sort the JSModule in this order.
  try {
    List<CompilerInput> sortedList =
        (new SortedDependencies<CompilerInput>(
            Collections.<CompilerInput>unmodifiableList(inputs)))
        .getSortedList();
    inputs.clear();
    inputs.addAll(sortedList);
  } catch (CircularDependencyException e) {
    compiler.report(
        JSError.make(CIRCULAR_DEPENDENCY_ERROR, e.getMessage()));
  }
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
public void testSort3() {
  SimpleDependencyInfo a = new SimpleDependencyInfo(
      "a", "a", provides("a"), requires("c"));
  SimpleDependencyInfo b = new SimpleDependencyInfo(
      "b", "b", provides("b"), requires("a"));
  SimpleDependencyInfo c = new SimpleDependencyInfo(
      "c", "c", provides("c"), requires("b"));

  try {
    new SortedDependencies<SimpleDependencyInfo>(
        Lists.newArrayList(a, b, c));
    fail("expected exception");
  } catch (CircularDependencyException e) {
    assertEquals("a -> a", e.getMessage());
  }
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
/**
 * Puts the JS files into a topologically sorted order by their dependencies.
 */
public void sortInputsByDeps(Compiler compiler) {
  // Set the compiler, so that we can parse requires/provides and report
  // errors properly.
  for (CompilerInput input : inputs) {
    input.setCompiler(compiler);
  }

  // Sort the JSModule in this order.
  try {
    List<CompilerInput> sortedList =
        (new SortedDependencies<>(
            Collections.unmodifiableList(inputs)))
        .getSortedList();
    inputs.clear();
    inputs.addAll(sortedList);
  } catch (CircularDependencyException e) {
    compiler.report(
        JSError.make(CIRCULAR_DEPENDENCY_ERROR, e.getMessage()));
  }
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
public void testSort3() {
  SimpleDependencyInfo a = new SimpleDependencyInfo(
      "a", "a", provides("a"), requires("c"));
  SimpleDependencyInfo b = new SimpleDependencyInfo(
      "b", "b", provides("b"), requires("a"));
  SimpleDependencyInfo c = new SimpleDependencyInfo(
      "c", "c", provides("c"), requires("b"));

  try {
    new SortedDependencies<SimpleDependencyInfo>(
        Lists.newArrayList(a, b, c));
    fail("expected exception");
  } catch (CircularDependencyException e) {}
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
public void testSort4() {
  SimpleDependencyInfo a = new SimpleDependencyInfo(
      "a", "a", provides("a"), requires("a"));

  try {
    new SortedDependencies<SimpleDependencyInfo>(
        Lists.newArrayList(a));
    fail("expected exception");
  } catch (CircularDependencyException e){
    assertEquals("a -> a", e.getMessage());
  }
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
private void runGSS(Closure closure, JobDescriptionBuilder options) {
	GSSPrintStreamErrorManager manager = new GSSPrintStreamErrorManager(
			System.err, System.out,new ClosureStatusFormatter());

	if (ClosureModelManager.canBuild(closure.getClosureJs())) {
		try {
			BasicValidator validator = new BasicValidator(bundle,
					pathResolver);
			closure.getClosureJs().accept(validator, null);
			if (!validator.isValid()) {
				manager.reportMessage(new Status(StatusType.ERROR, bundle
						.getString(IConstants.SOYConsole_Invalid), null));
				reportConfErrors(validator, manager);
			} else {
				GSSBuildpathContainerResolver resolver = new GSSBuildpathContainerResolver(
						closure.getClosureGss().getBuildpath(),
						pathResolver);
				resolver.resolve();
				GSSCompilerCli.compile(closure.getClosureGss(), options,
						manager, resolver.getSources(),
						resolver.getExterns(), bundle, pathResolver);
			}
		} catch (CircularDependencyException e) {
			manager.reportMessage(new Status(StatusType.ERROR, bundle
					.getString(IConstants.JSConsole_CicleDeps), e));
		} catch (Exception e1) {
			manager.reportMessage(new Status(StatusType.ERROR, "", e1));
		}
	} else {
		manager.reportMessage(new Status(StatusType.ERROR, bundle
				.getString(IConstants.Console_NoResources), null));
	}
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
private void runSOY(Closure closure, SoyJsSrcOptions options) {
	SOYPrintStreamErrorManager manager = new SOYPrintStreamErrorManager(
			System.err, System.out,new ClosureStatusFormatter());

	if (ClosureModelManager.canBuild(closure.getClosureJs())) {
		try {
			BasicValidator validator = new BasicValidator(bundle,
					pathResolver);
			closure.getClosureJs().accept(validator, null);
			if (!validator.isValid()) {
				manager.reportMessage(new Status(StatusType.ERROR, bundle
						.getString(IConstants.SOYConsole_Invalid), null));
				reportConfErrors(validator, manager);
			} else {
				SOYBuildpathContainerResolver resolver = new SOYBuildpathContainerResolver(
						closure.getClosureSoy().getBuildpath(),
						pathResolver);
				resolver.resolve();
				SOYCompilerCli compiler = new SOYCompilerCli(
						closure.getClosureSoy(), options,
						resolver.getSources(), resolver.getExterns(),
						pathResolver);
				compiler.setErrorManager(manager);
				compiler.setResourceBundle(bundle);
				compiler.compile();
			}
		} catch (CircularDependencyException e) {
			manager.reportMessage(new Status(StatusType.ERROR, bundle
					.getString(IConstants.JSConsole_CicleDeps), e));
		} catch (Exception e1) {
			manager.reportMessage(new Status(StatusType.ERROR, "", e1));
		}
	} else {
		manager.reportMessage(new Status(StatusType.ERROR, bundle
				.getString(IConstants.Console_NoResources), null));
	}
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
private void runJS(Closure closure, CompilerOptions options) {
	JSCPrintStreamErrorManager manager = new JSCPrintStreamErrorManager(
			System.err, System.out,new ClosureStatusFormatter());

	if (ClosureModelManager.canBuild(closure.getClosureJs())) {
		try {
			BasicValidator validator = new BasicValidator(bundle,
					pathResolver);
			closure.getClosureJs().accept(validator, null);
			if (!validator.isValid()) {
				manager.reportMessage(new Status(StatusType.ERROR, bundle
						.getString(IConstants.JSConsole_Invalid), null));
				reportConfErrors(validator, manager);
			} else {
				JSBuildpathContainerResolver resolver = new JSBuildpathContainerResolver(
						closure.getClosureJs().getBuildpath(), pathResolver);
				resolver.getDependencies();
				resolver.resolve();
				JSCCompilerCli compiler = new JSCCompilerCli(
						closure.getClosureJs(), options,
						resolver.getSources(), resolver.getExterns(),
						pathResolver);

				compiler.setErrorManager(manager);
				compiler.setResourceBundle(bundle);
				com.google.javascript.jscomp.Compiler
						.setLoggingLevel(Level.SEVERE);
				compiler.build();
			}
		} catch (CircularDependencyException e) {
			manager.reportMessage(new Status(StatusType.ERROR, bundle
					.getString(IConstants.JSConsole_CicleDeps), e));
		} catch (Exception e1) {
			manager.reportMessage(new Status(StatusType.ERROR, "", e1));
		}
	} else {
		manager.reportMessage(new Status(StatusType.ERROR, bundle
				.getString(IConstants.Console_NoResources), null));
	}
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
@Override
protected Task<Closure> createTask() {
	Task<Closure> task = new Task<Closure>() {
		protected Closure call() throws IOException, MalformedURLException {

			consoleManager.reportMessage(new Status(StatusType.INFO, bundle
					.getString(IConstants.Console_Start), null));

			if (isCancelled()) {
				return null;
			}

			if (ClosureModelManager.canBuild(closure.getClosureJs())) {
				try {
					BasicValidator validator = new BasicValidator(bundle,
							pathResolver);
					closure.getClosureJs().accept(validator, null);
					if (!validator.isValid()) {
						consoleManager
								.reportMessage(new Status(
										StatusType.ERROR,
										bundle.getString(IConstants.JSConsole_Invalid),
										null));
					} else {
						CompilerOptions options = buildpathManager
								.getJSCOptions(closure, pathResolver);
						// options.setIdeMode(true);
						JSBuildpathContainerResolver resolver = new JSBuildpathContainerResolver(
								closure.getClosureJs().getBuildpath(),
								pathResolver);
						resolver.getDependencies();
						resolver.resolve();
						JSCCompiler compiler = new JSCCompiler(
								closure.getClosureJs(), options,
								resolver.getSources(),
								resolver.getExterns(), pathResolver);
						JSCErrorManager manager = new JSCErrorManager(consoleManager);
						compiler.setErrorManager(manager);
						compiler.setResourceBundle(bundle);
						com.google.javascript.jscomp.Compiler
								.setLoggingLevel(Level.SEVERE);
						compiler.build();
						//final error reporting
						consoleManager.reportErrors(manager
								.getErrorStatuses());
						manager.clear();
					}
				} catch (CircularDependencyException e) {
					consoleManager
							.reportMessage(new Status(
									StatusType.ERROR,
									MessageFormat.format(
											bundle.getString(IConstants.JSConsole_CicleDeps),
											e.getLocalizedMessage()), null));
				} catch (Exception e1) {
					consoleManager
							.reportMessage(new Status(StatusType.ERROR, e1
									.getLocalizedMessage(), e1));
				}
			} else {
				consoleManager.reportMessage(new Status(StatusType.WARNING,
						bundle.getString(IConstants.Console_NoResources),
						null));
			}

			updateProgress(1, 1);

			consoleManager.reportMessage(new Status(StatusType.INFO, bundle
					.getString(IConstants.Console_Finish), null));

			return getClosure();
		}
	};
	progressBar.progressProperty().bind(task.progressProperty());
	return task;
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
public void getDependencies() throws CircularDependencyException {
	readEntries();
	deps = new SortedDependencies<DependencyInfo>(
			new ArrayList<DependencyInfo>(closureDeps));
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
/**
 * Returns the given collection of modules in topological order.
 *
 * Note that this will return the modules in the same order if they are
 * already sorted, and in general, will only change the order as necessary to
 * satisfy the ordering dependencies.  This can be important for cases where
 * the modules do not properly specify all dependencies.
 */
public static JSModule[] sortJsModules(Collection<JSModule> modules)
    throws CircularDependencyException {
  // Sort the JSModule in this order.
  List<JSModule> sortedList = (new SortedDependencies<JSModule>(
          Lists.newArrayList(modules))).getSortedList();
  return sortedList.toArray(new JSModule[sortedList.size()]);
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
/**
 * Applies a DependencyOptions in "dependency sorting" and "dependency pruning"
 * mode to the given list of inputs. Returns a new list with the files sorted
 * and removed. This module graph will be updated to reflect the new list.
 *
 * If you need more fine-grained dependency management, you should create your
 * own DependencyOptions and call
 * {@code manageDependencies(DependencyOptions, List<CompilerInput>)}.
 *
 * @param entryPoints The entry points into the program.
 *     Expressed as JS symbols.
 * @param inputs The original list of sources. Used to ensure that the sort
 *     is stable.
 * @throws CircularDependencyException if there is a circular dependency
 *     between the provides and requires.
 * @throws MissingProvideException if an entry point was not provided
 *     by any of the inputs.
 * @see DependencyOptions for more info on how this works.
 */
public List<CompilerInput> manageDependencies(
    List<String> entryPoints,
    List<CompilerInput> inputs)
    throws CircularDependencyException, MissingProvideException {
  DependencyOptions depOptions = new DependencyOptions();
  depOptions.setDependencySorting(true);
  depOptions.setDependencyPruning(true);
  depOptions.setEntryPoints(entryPoints);
  return manageDependencies(depOptions, inputs);
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
/**
 * Returns the given collection of modules in topological order.
 *
 * Note that this will return the modules in the same order if they are
 * already sorted, and in general, will only change the order as necessary to
 * satisfy the ordering dependencies.  This can be important for cases where
 * the modules do not properly specify all dependencies.
 */
public static JSModule[] sortJsModules(Collection<JSModule> modules)
    throws CircularDependencyException {
  // Sort the JSModule in this order.
  List<JSModule> sortedList = (new SortedDependencies<>(
          Lists.newArrayList(modules))).getSortedList();
  return sortedList.toArray(new JSModule[sortedList.size()]);
}
 

import com.google.javascript.jscomp.deps.SortedDependencies.CircularDependencyException; //导入依赖的package包/类
/**
 * Applies a DependencyOptions in "dependency sorting" and "dependency pruning"
 * mode to the given list of inputs. Returns a new list with the files sorted
 * and removed. This module graph will be updated to reflect the new list.
 *
 * If you need more fine-grained dependency management, you should create your
 * own DependencyOptions and call
 * {@code manageDependencies(DependencyOptions, List<CompilerInput>)}.
 *
 * @param entryPoints The entry points into the program.
 *     Expressed as JS symbols.
 * @param inputs The original list of sources. Used to ensure that the sort
 *     is stable.
 * @throws CircularDependencyException if there is a circular dependency
 *     between the provides and requires.
 * @throws MissingProvideException if an entry point was not provided
 *     by any of the inputs.
 * @see DependencyOptions for more info on how this works.
 */
public List<CompilerInput> manageDependencies(
    List<String> entryPoints,
    List<CompilerInput> inputs)
    throws CircularDependencyException,
        MissingModuleException,
        MissingProvideException {
  DependencyOptions depOptions = new DependencyOptions();
  depOptions.setDependencySorting(true);
  depOptions.setDependencyPruning(true);
  depOptions.setEntryPoints(entryPoints);
  return manageDependencies(depOptions, inputs);
}