• Home
• com.vaadin
• vaadin-client-compiler
• 7.6.1
• source code
• LibraryGroup.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.google.gwt.dev.cfg.LibraryGroup Maven / Gradle / Ivy

/*
 * Copyright 2013 Google Inc.
 *
 * 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.gwt.dev.cfg;

import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.UnableToCompleteException;
import com.google.gwt.core.ext.linker.ArtifactSet;
import com.google.gwt.dev.cfg.Libraries.IncompatibleLibraryVersionException;
import com.google.gwt.dev.javac.CompilationErrorsIndex;
import com.google.gwt.dev.javac.CompilationErrorsIndexImpl;
import com.google.gwt.dev.javac.CompilationUnit;
import com.google.gwt.dev.jjs.InternalCompilerException;
import com.google.gwt.dev.jjs.PermutationResult;
import com.google.gwt.dev.resource.Resource;
import com.google.gwt.dev.util.PersistenceBackedObject;
import com.google.gwt.thirdparty.guava.common.annotations.VisibleForTesting;
import com.google.gwt.thirdparty.guava.common.base.Predicates;
import com.google.gwt.thirdparty.guava.common.collect.HashMultimap;
import com.google.gwt.thirdparty.guava.common.collect.LinkedHashMultimap;
import com.google.gwt.thirdparty.guava.common.collect.Lists;
import com.google.gwt.thirdparty.guava.common.collect.Maps;
import com.google.gwt.thirdparty.guava.common.collect.Multimap;
import com.google.gwt.thirdparty.guava.common.collect.SetMultimap;
import com.google.gwt.thirdparty.guava.common.collect.Sets;

import java.io.InputStream;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * A convenience wrapper around a set of libraries.

 *
 * Indexes library contents to enable single step retrieval of resources by name.

 *
 * Analyzes the library dependency tree to provide link ordering and property and rebound type
 * change analysis for partial generator execution.

 *
 * Combines library resource lists for easy iteration over the complete set.

 *
 * Is mostly immutable, its contained set of libraries can only be set at time of construction.
 */
public class LibraryGroup {

  /**
   * An exception that indicates that a single Compilation Unit is being provided by more than one
   * library.
   */
  public static class CollidingCompilationUnitException extends InternalCompilerException {

    public CollidingCompilationUnitException(String message) {
      super(message);
    }
  }

  /**
   * An exception that indicates that more than one library has the same name, thus making name
   * based references ambiguous.
   */
  public static class DuplicateLibraryNameException extends InternalCompilerException {

    public DuplicateLibraryNameException(String message) {
      super(message);
    }
  }

  /**
   * An exception that indicates that some library was referenced as a dependency but was not
   * provided to the compiler.
   */
  public static class UnresolvedLibraryException extends InternalCompilerException {

    public UnresolvedLibraryException(String message) {
      super(message);
    }
  }

  private static final Comparator LIBRARY_NAME_COMPARATOR = new Comparator() {
    @Override
    public int compare(Library thisLibrary, Library thatLibrary) {
      return thisLibrary.getLibraryName().compareTo(thatLibrary.getLibraryName());
    }
  };

  @VisibleForTesting
  public static String formatDuplicateCompilationUnitMessage(String compilationUnitTypeSourceName,
      String oldLibraryName, String newLibraryName) {
    return String.format("Compilation units must be unique but '%s' is being "
        + "provided by both the '%s' and '%s' library.", compilationUnitTypeSourceName,
        oldLibraryName, newLibraryName);
  }

  /**
   * Factory function that constructs and returns a library group from a list of libraries.
   */
  public static LibraryGroup fromLibraries(
      List libraries, boolean verifyLibraryReferences) {
    LibraryGroup libraryGroup = new LibraryGroup();
    for (Library library : libraries) {
      libraryGroup.libraries.add(library);
    }
    libraryGroup.buildLibraryIndexes(verifyLibraryReferences);
    return libraryGroup;
  }
  /**
   * Factory function that constructs and returns a library group from a list of zip library paths.
   */
  public static LibraryGroup fromZipPaths(List zipLibraryPaths)
      throws IncompatibleLibraryVersionException {
    List zipLibraries = Lists.newArrayList();
    for (String zipLibraryPath : zipLibraryPaths) {
      zipLibraries.add(new ZipLibrary(zipLibraryPath));
    }
    return fromLibraries(zipLibraries, true);
  }

  private SetMultimap compilationErrorsByTypeSourceName;
  private CompilationErrorsIndexImpl compilationErrorsIndex;
  private Set compilationUnitTypeSourceNames;
  private ArtifactSet generatedArtifacts;
  private List libraries = Lists.newArrayList();
  private Map librariesByBuildResourcePath;
  private Map librariesByClassFilePath;
  private Map librariesByCompilationUnitTypeBinaryName;
  private Map librariesByCompilationUnitTypeSourceName;
  private Map librariesByName;
  private Map librariesByPublicResourcePath;
  private List> permutationResultHandles;
  private SetMultimap processedReboundTypeSourceNamesByGenerator =
      HashMultimap.create();
  private Set reboundTypeSourceNames;
  private SetMultimap referencesByTypeSourceName;
  private List rootLibraries;
  private Set superSourceCompilationUnitTypeSourceNames;

  protected LibraryGroup() {
    // Private to force class construction via one of the public factory functions.
  }

  /**
   * Closes all read streams.
   */
  public void close() {
    for (Library library : libraries) {
      library.close();
    }
  }

  /**
   * Returns whether a build resource is is available at the given path.
   */
  public boolean containsBuildResource(String buildResourcePath) {
    return getLibrariesByBuildResourcePath().containsKey(buildResourcePath);
  }

  /**
   * Create and return a library group of just the given libraries referenced by name. Useful for
   * taking an overly broad library group of all libraries in a dependency tree and trimming it down
   * to a restricted set of strict top level dependencies.
   */
  public LibraryGroup createSubgroup(List libraryNames) {
    return fromLibraries(getLibraries(libraryNames), false);
  }

  /**
   * Returns the resource referenced by name if present or null;
   */
  public Resource getBuildResourceByPath(String buildResourcePath) {
    if (!getLibrariesByBuildResourcePath().containsKey(buildResourcePath)) {
      return null;
    }
    Library library = getLibrariesByBuildResourcePath().get(buildResourcePath);
    return library.getBuildResourceByPath(buildResourcePath);
  }

  /**
   * Returns the set of all build resource paths.
   */
  public Set getBuildResourcePaths() {
    return getLibrariesByBuildResourcePath().keySet();
  }

  /**
   * Opens and returns an input stream for the given class file path if present or null.
   */
  public InputStream getClassFileStream(String classFilePath) {
    if (!getLibrariesByClassFilePath().containsKey(Libraries.computeClassFileName(classFilePath))) {
      return null;
    }
    Library library =
        getLibrariesByClassFilePath().get(Libraries.computeClassFileName(classFilePath));
    return library.getClassFileStream(classFilePath);
  }

  public CompilationErrorsIndex getCompilationErrorsIndex() {
    if (compilationErrorsIndex == null) {
      compilationErrorsIndex = new CompilationErrorsIndexImpl();
      for (Library library : libraries) {
        compilationErrorsIndex.merge(library.getCompilationErrorsIndex());
      }
    }
    return compilationErrorsIndex;
  }

  /**
   * Returns the compilation unit for the given compilation unit type name if present or null.
   */
  public CompilationUnit getCompilationUnitByTypeBinaryName(String typeBinaryName) {
    if (!getLibrariesByCompilationUnitTypeBinaryName().containsKey(typeBinaryName)) {
      return null;
    }
    Library library = getLibrariesByCompilationUnitTypeBinaryName().get(typeBinaryName);
    return library.getCompilationUnitByTypeBinaryName(typeBinaryName);
  }

  /**
   * Returns the compilation unit for the given compilation unit type name if present or null.
   */
  public CompilationUnit getCompilationUnitByTypeSourceName(String typeSourceName) {
    if (!getLibrariesByCompilationUnitTypeSourceName().containsKey(typeSourceName)) {
      return null;
    }
    Library library = getLibrariesByCompilationUnitTypeSourceName().get(typeSourceName);
    return library.getCompilationUnitByTypeSourceName(typeSourceName);
  }

  /**
   * Returns the set of all compilation unit type source names (both regular and super sourced).
   * Useful to be able to force loading of all known types to make subtype queries accurate for
   * example when doing global generator execution.
   */
  public Set getCompilationUnitTypeSourceNames() {
    if (compilationUnitTypeSourceNames == null) {
      compilationUnitTypeSourceNames = Sets.newLinkedHashSet();
      for (Library library : libraries) {
        compilationUnitTypeSourceNames.addAll(library.getRegularCompilationUnitTypeSourceNames());
        compilationUnitTypeSourceNames.addAll(
            library.getSuperSourceCompilationUnitTypeSourceNames());
      }
      compilationUnitTypeSourceNames = Collections.unmodifiableSet(compilationUnitTypeSourceNames);
    }
    return compilationUnitTypeSourceNames;
  }

  public ArtifactSet getGeneratedArtifacts() {
    if (generatedArtifacts == null) {
      generatedArtifacts = new ArtifactSet();
      for (Library library : libraries) {
        generatedArtifacts.addAll(library.getGeneratedArtifacts());
      }
    }
    return generatedArtifacts;
  }

  /**
   * Returns the list of all permutation result handles (one per library) in library link order.
   */
  public List> getPermutationResultHandlesInLinkOrder() {
    if (permutationResultHandles == null) {
      permutationResultHandles = Lists.newArrayList();
      for (Library library : libraries) {
        permutationResultHandles.add(library.getPermutationResultHandle());
      }
      permutationResultHandles = Collections.unmodifiableList(permutationResultHandles);
    }
    return permutationResultHandles;
  }

  /**
   * Returns a list of source names of types which have already been rebound by the given generator.
   */
  public Set getProcessedReboundTypeSourceNames(String generatorName) {
    if (!processedReboundTypeSourceNamesByGenerator.containsKey(generatorName)) {
      Set processedReboundTypeSourceNames = Sets.newHashSet();
      for (Library library : libraries) {
        processedReboundTypeSourceNames.addAll(
            library.getProcessedReboundTypeSourceNamesByGenerator().get(generatorName));
      }
      processedReboundTypeSourceNamesByGenerator.putAll(generatorName,
          Collections.unmodifiableSet(processedReboundTypeSourceNames));
    }
    return processedReboundTypeSourceNamesByGenerator.get(generatorName);
  }

  /**
   * Returns the resource referenced by name if present or null.
   */
  public Resource getPublicResourceByPath(String path) {
    if (!getLibrariesByPublicResourcePath().containsKey(path)) {
      return null;
    }
    Library library = getLibrariesByPublicResourcePath().get(path);
    return library.getPublicResourceByPath(path);
  }

  /**
   * Returns the set of all public resource paths.
   */
  public Set getPublicResourcePaths() {
    return getLibrariesByPublicResourcePath().keySet();
  }

  /**
   * Returns the set of names of types which are the subject of GWT.create() calls in source code in
   * any of the contained libraries.
   */
  public Set getReboundTypeSourceNames() {
    if (reboundTypeSourceNames == null) {
      reboundTypeSourceNames = Sets.newLinkedHashSet();
      for (Library library : libraries) {
        reboundTypeSourceNames.addAll(library.getReboundTypeSourceNames());
      }
      reboundTypeSourceNames =
          Collections.unmodifiableSet(reboundTypeSourceNames);
    }
    return reboundTypeSourceNames;
  }

  /**
   * Returns the set of compilation unit type source names for all contained super source
   * compilation units.
   */
  public Set getSuperSourceCompilationUnitTypeSourceNames() {
    if (superSourceCompilationUnitTypeSourceNames == null) {
      superSourceCompilationUnitTypeSourceNames = Sets.newLinkedHashSet();
      for (Library library : libraries) {
        superSourceCompilationUnitTypeSourceNames.addAll(
            library.getSuperSourceCompilationUnitTypeSourceNames());
      }
      superSourceCompilationUnitTypeSourceNames =
          Collections.unmodifiableSet(superSourceCompilationUnitTypeSourceNames);
    }
    return superSourceCompilationUnitTypeSourceNames;
  }

  public void verify(TreeLogger logger) throws UnableToCompleteException {
    try {
      // Forces the building of the mapping from source names of compilation unit types to the
      // library that provides them, so that there is an opportunity to notice and reject duplicate
      // providing libraries.
      getLibrariesByCompilationUnitTypeSourceName();
    } catch (CollidingCompilationUnitException e) {
      logger.log(TreeLogger.ERROR, e.getMessage());
      throw new UnableToCompleteException();
    }
  }

  @VisibleForTesting
  List getLibraries() {
    return libraries;
  }

  @VisibleForTesting
  List getLibraries(Collection libraryNames) {
    return Lists.newArrayList(
        Maps.filterKeys(librariesByName, Predicates.in(libraryNames)).values());
  }

  /**
   * Throws an exception if the referenced compilation unit (which is being provided by the
   * referenced new library) is already being provided by some older library.
   */
  private void assertUniquelyProvided(Library newLibrary, String compilationUnitTypeSourceName) {
    if (librariesByCompilationUnitTypeSourceName.containsKey(compilationUnitTypeSourceName)) {
      Library oldLibrary =
          librariesByCompilationUnitTypeSourceName.get(compilationUnitTypeSourceName);
      throw new CollidingCompilationUnitException(formatDuplicateCompilationUnitMessage(
          compilationUnitTypeSourceName, oldLibrary.getLibraryName(), newLibrary.getLibraryName()));
    }
  }

  private void buildLibraryIndexes(boolean verifyLibraryReferences) {
    // Start processing with a consistent library order to ensure consistently ordered output.
    Collections.sort(libraries, LIBRARY_NAME_COMPARATOR);

    librariesByName = Maps.newLinkedHashMap();
    for (Library library : libraries) {
      if (librariesByName.containsKey(library.getLibraryName())) {
        throw new DuplicateLibraryNameException("More than one library is claiming the name \""
            + library.getLibraryName() + "\", thus making library references ambiguous. "
            + "Compilation can not proceed.");
      }
      librariesByName.put(library.getLibraryName(), library);
    }

    Multimap parentLibrariesByChildLibrary = LinkedHashMultimap.create();
    Multimap childLibrariesByParentLibrary = LinkedHashMultimap.create();
    for (Library parentLibrary : libraries) {
      for (String childLibraryName : parentLibrary.getDependencyLibraryNames()) {
        Library childLibrary = librariesByName.get(childLibraryName);
        boolean libraryIsMissing = childLibrary == null;
        if (libraryIsMissing && verifyLibraryReferences) {
          throw new UnresolvedLibraryException("Library " + parentLibrary.getLibraryName()
              + " references library " + childLibraryName + " but it is not available.");
        }
        parentLibrariesByChildLibrary.put(childLibrary, parentLibrary);
        childLibrariesByParentLibrary.put(parentLibrary, childLibrary);
      }
    }

    rootLibraries = Lists.newArrayList();
    for (Library library : libraries) {
      boolean libraryHasParents = parentLibrariesByChildLibrary.containsKey(library);
      if (libraryHasParents) {
        continue;
      }
      rootLibraries.add(library);
    }

    List librariesInLinkOrder = Lists.newArrayList();
    Set maybeLeafLibraries = Sets.newLinkedHashSet(libraries);
    while (!maybeLeafLibraries.isEmpty()) {
      List leafLibraries = Lists.newArrayList();
      for (Library maybeLeafLibrary : maybeLeafLibraries) {
        if (childLibrariesByParentLibrary.get(maybeLeafLibrary).isEmpty()) {
          leafLibraries.add(maybeLeafLibrary);
        }
      }
      librariesInLinkOrder.addAll(leafLibraries);

      maybeLeafLibraries.clear();
      for (Library leafLibrary : leafLibraries) {
        Collection parentLibraries = parentLibrariesByChildLibrary.removeAll(leafLibrary);
        maybeLeafLibraries.addAll(parentLibraries);
        for (Library parentLibrary : parentLibraries) {
          childLibrariesByParentLibrary.remove(parentLibrary, leafLibrary);
        }
      }
    }

    libraries = librariesInLinkOrder;
  }

  private Map getLibrariesByBuildResourcePath() {
    if (librariesByBuildResourcePath == null) {
      librariesByBuildResourcePath = Maps.newLinkedHashMap();
      for (Library library : libraries) {
        Set buildResourcePaths = library.getBuildResourcePaths();
        for (String buildResourcePath : buildResourcePaths) {
          librariesByBuildResourcePath.put(buildResourcePath, library);
        }
      }
      librariesByBuildResourcePath = Collections.unmodifiableMap(librariesByBuildResourcePath);
    }
    return librariesByBuildResourcePath;
  }

  // TODO(stalcup): throw an error if more than one version of a type is provided.
  private Map getLibrariesByClassFilePath() {
    if (librariesByClassFilePath == null) {
      librariesByClassFilePath = Maps.newLinkedHashMap();

      // Record regular class files first.
      for (Library library : libraries) {
        Set classFilePaths = library.getRegularClassFilePaths();
        for (String classFilePath : classFilePaths) {
          librariesByClassFilePath.put(classFilePath, library);
        }
      }

      // Overwrite with superSource class files, so they have higher priority.
      for (Library library : libraries) {
        Set superSourceClassFilePaths = library.getSuperSourceClassFilePaths();
        for (String superSourceClassFilePath : superSourceClassFilePaths) {
          librariesByClassFilePath.put(superSourceClassFilePath, library);
        }
      }

      librariesByClassFilePath = Collections.unmodifiableMap(librariesByClassFilePath);
    }
    return librariesByClassFilePath;
  }

  // TODO(stalcup): throw an error if more than one version of a type is provided.
  private Map getLibrariesByCompilationUnitTypeBinaryName() {
    if (librariesByCompilationUnitTypeBinaryName == null) {
      librariesByCompilationUnitTypeBinaryName = Maps.newLinkedHashMap();

      // Record regular compilation units first.
      for (Library library : libraries) {
        for (String compilationUnitTypeSourceName :
            library.getRegularCompilationUnitTypeSourceNames()) {
          librariesByCompilationUnitTypeSourceName.put(compilationUnitTypeSourceName, library);

          Collection nestedTypeBinaryNames = library
              .getNestedBinaryNamesByCompilationUnitName().get(compilationUnitTypeSourceName);
          for (String nestedTypeBinaryName : nestedTypeBinaryNames) {
            librariesByCompilationUnitTypeBinaryName.put(nestedTypeBinaryName, library);
          }
        }
      }

      // Overwrite with superSource compilation units, so they have higher priority.
      for (Library library : libraries) {
        for (String superSourceCompilationUnitTypeSourceName :
            library.getSuperSourceCompilationUnitTypeSourceNames()) {
          librariesByCompilationUnitTypeSourceName.put(superSourceCompilationUnitTypeSourceName,
              library);

          Collection nestedTypeBinaryNames = library
              .getNestedBinaryNamesByCompilationUnitName().get(
              superSourceCompilationUnitTypeSourceName);
          for (String nestedTypeBinaryName : nestedTypeBinaryNames) {
            librariesByCompilationUnitTypeBinaryName.put(nestedTypeBinaryName, library);
          }
        }
      }
    }
    return Collections.unmodifiableMap(librariesByCompilationUnitTypeBinaryName);
  }

  private Map getLibrariesByCompilationUnitTypeSourceName() {
    if (librariesByCompilationUnitTypeSourceName == null) {
      librariesByCompilationUnitTypeSourceName = Maps.newLinkedHashMap();

      // Record regular compilation units first.
      for (Library library : libraries) {
        for (String compilationUnitTypeSourceName :
            library.getRegularCompilationUnitTypeSourceNames()) {
          assertUniquelyProvided(library, compilationUnitTypeSourceName);
          librariesByCompilationUnitTypeSourceName.put(compilationUnitTypeSourceName, library);

          Collection nestedTypeSourceNames = library
              .getNestedSourceNamesByCompilationUnitName().get(compilationUnitTypeSourceName);
          for (String nestedTypeSourceName : nestedTypeSourceNames) {
            librariesByCompilationUnitTypeSourceName.put(nestedTypeSourceName, library);
          }
        }
      }

      // Overwrite with superSource compilation units, so they have higher priority.
      for (Library library : libraries) {
        for (String superSourceCompilationUnitTypeSourceName :
            library.getSuperSourceCompilationUnitTypeSourceNames()) {
          assertUniquelyProvided(library, superSourceCompilationUnitTypeSourceName);
          librariesByCompilationUnitTypeSourceName.put(superSourceCompilationUnitTypeSourceName,
              library);

          Collection nestedTypeSourceNames = library
              .getNestedSourceNamesByCompilationUnitName().get(
              superSourceCompilationUnitTypeSourceName);
          for (String nestedTypeSourceName : nestedTypeSourceNames) {
            librariesByCompilationUnitTypeSourceName.put(nestedTypeSourceName, library);
          }
        }
      }
    }
    return Collections.unmodifiableMap(librariesByCompilationUnitTypeSourceName);
  }

  private Map getLibrariesByPublicResourcePath() {
    if (librariesByPublicResourcePath == null) {
      librariesByPublicResourcePath = Maps.newLinkedHashMap();
      for (Library library : libraries) {
        Set publicResourcePaths = library.getPublicResourcePaths();
        for (String publicResourcePath : publicResourcePaths) {
          librariesByPublicResourcePath.put(publicResourcePath, library);
        }
      }

      librariesByPublicResourcePath = Collections.unmodifiableMap(librariesByPublicResourcePath);
    }
    return librariesByPublicResourcePath;
  }
}