com.google.javascript.jscomp.deps.SortedDependencies Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of closure-compiler-linter Show documentation

Closure Compiler is a JavaScript optimizing compiler. It parses your JavaScript, analyzes it, removes dead code and rewrites and minimizes what's left. It also checks syntax, variable references, and types, and warns about common JavaScript pitfalls. It is used in many of Google's JavaScript apps, including Gmail, Google Web Search, Google Maps, and Google Docs. This binary checks for style issues such as incorrect or missing JSDoc usage, and missing goog.require() statements. It does not do more advanced checks such as typechecking.

There is a newer version: v20200830

Show newest version

/*
 * Copyright 2010 The Closure Compiler Authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.javascript.jscomp.deps;

import java.util.List;

/**
 * A sorted list of inputs with dependency information.
 * 
 * Performs a sort to make sure that an input always comes after its
 * dependencies.
 * 

 * Also exposes other information about the inputs, like which inputs
 * do not provide symbols.
 *
 * TODO(tbreisacher): Consider removing this interface, since it now
 * has only one class implementing it.
 */
public interface SortedDependencies {

  /**
   * Return the input that gives us the given symbol.
   * @throws MissingProvideException An exception if there is no
   *     input for this symbol.
   */
  public INPUT getInputProviding(String symbol) throws MissingProvideException;

  /**
   * Return the input that gives us the given symbol, or null.
   */
  public INPUT maybeGetInputProviding(String symbol);

  public List getSortedList();

  /**
   * Gets all the strong dependencies of the given roots. The inputs must be returned in a stable
   * order. In other words, if A comes before B, and A does not transitively depend on B, then A
   * must also come before B in the returned list.
   */
  public List getSortedStrongDependenciesOf(List roots);

  /**
   * Gets all the weak dependencies of the given roots. The inputs must be returned in stable order.
   * In other words, if A comes before B, and A does not * transitively depend on B, then A must
   * also come before B in the returned * list.
   *
   * 
The weak dependencies are those that are only reachable via type requires from the roots.
   * Note that if a root weakly requires another input, then all of its transitive dependencies
   * (strong or weak) that are not strongly reachable from the roots will be included. e.g. if A
   * weakly requires B, and B strongly requires C, and A is the sole root, then this will return B
   * and C. However, if we add D as a root, and D strongly requires C, then this will only return B.
   *
   * Root inputs will never be in the returned list as they are all considered strong.
   */
  public List getSortedWeakDependenciesOf(List roots);

  /**
   * Gets all the strong dependencies of the given roots. The inputs must be returned in a stable
   * order. In other words, if A comes before B, and A does not transitively depend on B, then A
   * must also come before B in the returned list.
   *
   * @param sorted If true, get them in topologically sorted order. If false, get them in the
   *     original order they were passed to the compiler.
   */
  public List getStrongDependenciesOf(List roots, boolean sorted);

  public List getInputsWithoutProvides();

  public static class MissingProvideException extends Exception {
    public MissingProvideException(String provide) {
      super(provide);
    }

    public MissingProvideException(String provide, Exception e) {
      super(provide, e);
    }
  }
}