com.google.gwt.dev.MinimalRebuildCache Maven / Gradle / Ivy
/*
* Copyright 2014 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;
import com.google.gwt.core.ext.TreeLogger;
import com.google.gwt.core.ext.linker.ArtifactSet;
import com.google.gwt.core.ext.linker.StatementRanges;
import com.google.gwt.dev.cfg.ModuleDef;
import com.google.gwt.dev.javac.CompilationUnit;
import com.google.gwt.dev.javac.CompiledClass;
import com.google.gwt.dev.javac.GeneratedUnit;
import com.google.gwt.dev.javac.Shared;
import com.google.gwt.dev.jjs.JsSourceMap;
import com.google.gwt.dev.jjs.ast.JProgram;
import com.google.gwt.dev.jjs.ast.JTypeOracle;
import com.google.gwt.dev.jjs.ast.JTypeOracle.ImmediateTypeRelations;
import com.google.gwt.dev.jjs.impl.ResolveRuntimeTypeReferences.IntTypeMapper;
import com.google.gwt.dev.js.JsPersistentPrettyNamer.PersistentPrettyNamerState;
import com.google.gwt.dev.resource.Resource;
import com.google.gwt.dev.util.Name.InternalName;
import com.google.gwt.thirdparty.guava.common.annotations.VisibleForTesting;
import com.google.gwt.thirdparty.guava.common.base.Objects;
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.ImmutableList;
import com.google.gwt.thirdparty.guava.common.collect.ImmutableSet;
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.Multimaps;
import com.google.gwt.thirdparty.guava.common.collect.Sets;
import java.io.Serializable;
import java.util.Collection;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
/**
* MinimalRebuildCache contains compiler information that can be persisted between compiles to
* decrease compilation time.
*
* Cached information is specific to a single permutation and it is the responsibility of the
* framework driving the Compiler to supply the right Cache instance for the right Module
* configuration and to make sure that the Compiler is only processing one permutation at a time.
*
* All type names referenced here are assumed to be binary names.
*
* A "typeName" here might be a root type or nested type but a "compilationUnitName" here will
* always be the name of just the root type in a compilation unit.
*/
public class MinimalRebuildCache implements Serializable {
private static void appendSubTypes(Set accumulatedTypeNames, Set parentTypeNames,
JTypeOracle typeOracle) {
for (String parentTypeName : parentTypeNames) {
Set subTypeNames = typeOracle.getSubTypeNames(parentTypeName);
if (subTypeNames == null) {
// It must be a new type, thus there are no subtypes to invalidate.
continue;
}
accumulatedTypeNames.addAll(subTypeNames);
}
}
@SuppressWarnings({"rawtypes", "unchecked"})
private static void copyCollection(Collection fromCollection, Collection toCollection) {
toCollection.clear();
toCollection.addAll(fromCollection);
}
@SuppressWarnings({"rawtypes", "unchecked"})
private static void copyMap(Map fromMap, Map toMap) {
toMap.clear();
toMap.putAll(fromMap);
}
@SuppressWarnings({"rawtypes", "unchecked"})
private static void copyMultimap(Multimap fromMap, Multimap toMap) {
toMap.clear();
toMap.putAll(fromMap);
}
/**
* Diffs lastModifiedByResourcePath from the previous compile against currentResources from the
* current compile. modifiedResourcePaths is wiped and recreated to be a list of just the modified
* or deleted resources, deletedResourcePaths is wiped and recreated to be a list of just the
* deleted resources and modifiedResourcePaths is updated in place with new lastModified dates.
*/
private static void recordModifiedResources(Map currentModifiedByResourcePath,
Map lastModifiedByResourcePath, Set modifiedResourcePaths,
Set deletedResourcePaths) {
deletedResourcePaths.clear();
modifiedResourcePaths.clear();
Set currentResourcePaths = Sets.newHashSet();
for (Entry entry : currentModifiedByResourcePath.entrySet()) {
String currentResourcePath = entry.getKey();
Long currentResourceModified = entry.getValue();
currentResourcePaths.add(currentResourcePath);
Long lastKnownModified =
lastModifiedByResourcePath.put(currentResourcePath, currentResourceModified);
if (!Objects.equal(lastKnownModified, currentResourceModified)) {
// Added or Modified resource.
modifiedResourcePaths.add(currentResourcePath);
}
}
// Removed resources.
{
// Figure out which resources were removed.
Set removedResourcePaths = Sets.newHashSet(
Sets.difference(lastModifiedByResourcePath.keySet(), currentResourcePaths));
// Log them as "modified".
deletedResourcePaths.addAll(removedResourcePaths);
modifiedResourcePaths.addAll(removedResourcePaths);
// Remove any path to modified date entries for them.
for (String removedResourcePath : removedResourcePaths) {
lastModifiedByResourcePath.remove(removedResourcePath);
}
}
}
private static Set resourcePathsToCompilationUnitNames(Set resourcePaths) {
Set compilationUnitNames = Sets.newHashSet();
for (String resourcePath : resourcePaths) {
compilationUnitNames.add(Shared.toTypeName(resourcePath));
}
return compilationUnitNames;
}
private static Map resourcesToModifiedByPath(Collection resources) {
Map modifiedByPath = Maps.newHashMap();
for (Resource resource : resources) {
modifiedByPath.put(resource.getPath(), resource.getLastModified());
}
return modifiedByPath;
}
/*
* Update copyFrom() whenever adding more fields.
*/
protected final ImmediateTypeRelations immediateTypeRelations = new ImmediateTypeRelations();
private final Map compilationUnitTypeNameByNestedTypeName = Maps.newHashMap();
private final Map contentHashByGeneratedTypeName = Maps.newHashMap();
private final Set deletedCompilationUnitNames = Sets.newHashSet();
private final Set deletedDiskSourcePaths = Sets.newHashSet();
private final Set deletedResourcePaths = Sets.newHashSet();
private final Set dualJsoImplInterfaceNames = Sets.newHashSet();
private final ArtifactSet generatedArtifacts = new ArtifactSet();
private final Multimap generatedCompilationUnitNamesByReboundTypeNames =
HashMultimap.create();
private final IntTypeMapper intTypeMapper = new IntTypeMapper();
private final Map jsByTypeName = Maps.newHashMap();
private final Set jsoStatusChangedTypeNames = Sets.newHashSet();
private final Set jsoTypeNames = Sets.newHashSet();
private Integer lastLinkedJsBytes;
private final Map lastModifiedByDiskSourcePath = Maps.newHashMap();
private final Map lastModifiedByResourcePath = Maps.newHashMap();
private final Set lastReachableTypeNames = Sets.newHashSet();
private final Set modifiedCompilationUnitNames = Sets.newHashSet();
private final Set modifiedDiskSourcePaths = Sets.newHashSet();
private final Set modifiedResourcePaths = Sets.newHashSet();
private final Multimap nestedTypeNamesByUnitTypeName = HashMultimap.create();
private final PersistentPrettyNamerState persistentPrettyNamerState =
new PersistentPrettyNamerState();
private final Set preambleTypeNames = Sets.newHashSet();
private transient ImmutableSet processedStaleTypeNames = ImmutableSet. of();
private final Multimap rebinderTypeNamesByReboundTypeName = HashMultimap.create();
private final Multimap reboundTypeNamesByGeneratedCompilationUnitNames =
HashMultimap.create();
private final Multimap reboundTypeNamesByInputResource = HashMultimap.create();
private final Multimap referencedTypeNamesByTypeName = HashMultimap.create();
private final Set rootTypeNames = Sets.newHashSet();
private final Set singleJsoImplInterfaceNames = Sets.newHashSet();
private final Set sourceCompilationUnitNames = Sets.newHashSet();
private final Map sourceMapsByTypeName = Maps.newHashMap();
private final Set staleTypeNames = Sets.newHashSet();
private final Map statementRangesByTypeName = Maps.newHashMap();
private final Multimap typeNamesByReferencingTypeName = HashMultimap.create();
/**
* Accumulates generated artifacts so that they can be output on recompiles even if no generators
* are run.
*/
public void addGeneratedArtifacts(ArtifactSet generatedArtifacts) {
this.generatedArtifacts.addAll(generatedArtifacts);
}
public void addModifiedCompilationUnitNames(TreeLogger logger,
Set modifiedCompilationUnitNames) {
logger.log(TreeLogger.DEBUG, "adding to cached list of known modified compilation units "
+ modifiedCompilationUnitNames);
this.modifiedCompilationUnitNames.addAll(modifiedCompilationUnitNames);
}
public void addSourceCompilationUnitName(String sourceCompilationUnitName) {
// sourceCompilationUnitNames contains all compilation unit type names seen so far even
// across recompiles. There is a need to know whether a unit is available in source form (
// either compiled from source in this iteration or its AST available from cache) so that
// we insert the correct type of reference when we see a BinaryTypeReference in the JDT
// AST. {@see GwtAstBuilder}.
// NOTE: DO NOT RESET OR CLEAR THIS SET.
this.sourceCompilationUnitNames.add(sourceCompilationUnitName);
}
public void addTypeReference(String fromTypeName, String toTypeName) {
referencedTypeNamesByTypeName.put(fromTypeName, toTypeName);
typeNamesByReferencingTypeName.put(toTypeName, fromTypeName);
}
public void associateReboundTypeWithGeneratedCompilationUnitName(String reboundTypeName,
String generatedCompilationUnitName) {
reboundTypeNamesByGeneratedCompilationUnitNames.put(generatedCompilationUnitName,
reboundTypeName);
}
/**
* Record that a Generator that was ran as a result of a GWT.create(ReboundType.class) call read a
* particular resource.
*/
public void associateReboundTypeWithInputResource(String reboundTypeName,
String inputResourcePath) {
reboundTypeNamesByInputResource.put(inputResourcePath, reboundTypeName);
}
public void clearPerTypeJsCache() {
rootTypeNames.clear();
preambleTypeNames.clear();
deletedResourcePaths.clear();
modifiedResourcePaths.clear();
deletedDiskSourcePaths.clear();
modifiedDiskSourcePaths.clear();
contentHashByGeneratedTypeName.clear();
jsByTypeName.clear();
referencedTypeNamesByTypeName.clear();
sourceMapsByTypeName.clear();
statementRangesByTypeName.clear();
typeNamesByReferencingTypeName.clear();
}
public void clearRebinderTypeAssociations(String rebinderTypeName) {
rebinderTypeNamesByReboundTypeName.values().remove(rebinderTypeName);
}
public void clearReboundTypeAssociations(String reboundTypeName) {
reboundTypeNamesByInputResource.values().remove(reboundTypeName);
reboundTypeNamesByGeneratedCompilationUnitNames.values().remove(reboundTypeName);
}
/**
* Calculates the set of stale types and clears their cached Js, StatementRanges and SourceMaps.
*
* The calculation of stale types starts with the list of known modified types and expands that
* set using various patterns intended to find any types whose output JS would be affected by the
* changes in the modified types. For example if the parent of class Foo was changed then the
* castmaps in all children of Foo need to be recreated.
*
* In some ways this process is similar to that performed by the CompilationUnitInvalidator but it
* differs both in what type of cached objects are being cleared (JS versus CompilationUnits) and
* in what invalidation rules must be applied. CompilationUnitInvalidator is concerned only with
* changes in interface while the invalidation here must also look at JSO promotion/demotion and
* cast references because of the peculiarities of output JS format.
*/
public Set computeAndClearStaleTypesCache(TreeLogger logger, JTypeOracle typeOracle) {
if (!isPopulated()) {
return Sets.newHashSet();
}
// Cache the ReboundTypeNames -> GeneratedCompilationUnitNames reverse map as it will be needed
// several times.
generatedCompilationUnitNamesByReboundTypeNames.clear();
Multimaps.invertFrom(reboundTypeNamesByGeneratedCompilationUnitNames,
generatedCompilationUnitNamesByReboundTypeNames);
// Store stale type names in a persisted field so that tests can inspect behavior.
staleTypeNames.clear();
Set modifiedTypeNames = computeModifiedTypeNames();
// Accumulate the names of stale types resulting from some known type or resource modifications,
// using various patterns (sub types, referencing types, etc).
{
staleTypeNames.addAll(modifiedTypeNames);
appendSubTypes(staleTypeNames, modifiedTypeNames, typeOracle);
// Marks stale any type that references either a modified type or any subtype of a modified
// type. The references of subtypes can be done away with once we revamp Array castmap
// generation.
ImmutableList modifiedTypeAndSubTypeNames = ImmutableList.copyOf(staleTypeNames);
appendReferencingTypes(staleTypeNames, modifiedTypeAndSubTypeNames);
appendReferencingTypes(staleTypeNames, jsoStatusChangedTypeNames);
staleTypeNames.addAll(
computeTypesThatRebindTypes(computeReboundTypesAffectedByModifiedResources()));
appendTypesToRegenerateStaleGeneratedTypes(staleTypeNames);
// Generator output is affected by types queried from the TypeOracle but changes in these
// types are not being directly supported at this time since some of them are already handled
// because they are referenced by the Generator output and since changes in subtype queries
// probably make GWTRPC output incompatible with a server anyway (and thus already forces a
// restart).
staleTypeNames.removeAll(JProgram.SYNTHETIC_TYPE_NAMES);
}
/*
* Filter for just those stale types that are actually reachable. Since if they're not
* reachable we don't want to artificially traverse them and unnecessarily reveal dependency
* problems. And if they have become reachable, since they're missing JS, they will already be
* fully traversed when seen in Unify.
*/
copyCollection(filterUnreachableTypeNames(staleTypeNames), staleTypeNames);
// These log lines can be expensive.
if (logger.isLoggable(TreeLogger.DEBUG)) {
logger.log(TreeLogger.DEBUG, "known modified types = " + modifiedTypeNames);
logger.log(TreeLogger.DEBUG, "known modified resources = " + modifiedResourcePaths);
logger.log(TreeLogger.DEBUG,
"clearing cached output for resulting stale types = " + staleTypeNames);
}
for (String staleTypeName : staleTypeNames) {
clearCachedTypeOutput(staleTypeName);
}
return Sets.newHashSet(staleTypeNames);
}
/**
* Computes and returns the set of names of deleted types.
*
* Deleted types are all those types that are nested within compilation units that are known to
* have been deleted.
*/
public Set computeDeletedTypeNames() {
return computeNestedTypeNames(deletedCompilationUnitNames);
}
/**
* Computes and returns the set of names of modified types.
*
* Modified types are all those types that are nested within compilation units that are known to
* have been modified.
*/
public Set computeModifiedTypeNames() {
// Accumulate the names of types that are nested within known modified compilation units.
return computeNestedTypeNames(modifiedCompilationUnitNames);
}
/**
* Computes and returns the names of the set of types that are transitively referenceable starting
* from the set of root types.
*
* Should only be called once per compile, so that the "lastReachableTypeNames" list accurately
* reflects the reachable types of the immediately previous compile.
*/
public Set computeReachableTypeNames() {
Set openTypeNames = Sets.newHashSet(rootTypeNames);
Set reachableTypeNames = Sets.newHashSet();
while (!openTypeNames.isEmpty()) {
Iterator iterator = openTypeNames.iterator();
String toProcessTypeName = iterator.next();
iterator.remove();
reachableTypeNames.add(toProcessTypeName);
Collection referencedTypes = referencedTypeNamesByTypeName.get(toProcessTypeName);
for (String referencedType : referencedTypes) {
if (reachableTypeNames.contains(referencedType)) {
continue;
}
openTypeNames.add(referencedType);
}
}
copyCollection(reachableTypeNames, lastReachableTypeNames);
return reachableTypeNames;
}
/**
* Replaces the contents of this cache with the contents of the given cache.
*
* This operation should be kept fast as it will be called once per compile. At the moment it
* takes about 2.5% of the time in an incremental recompile. If wanting to recover this time in
* the future consider parallelizing the copy or grouping the values from hash tables with similar
* keys into a single data object and hashtable so that fewer references need to be replicated.
*/
public void copyFrom(MinimalRebuildCache that) {
this.lastLinkedJsBytes = that.lastLinkedJsBytes;
this.intTypeMapper.copyFrom(that.intTypeMapper);
this.persistentPrettyNamerState.copyFrom(that.persistentPrettyNamerState);
this.immediateTypeRelations.copyFrom(that.immediateTypeRelations);
copyMap(that.compilationUnitTypeNameByNestedTypeName,
this.compilationUnitTypeNameByNestedTypeName);
copyMap(that.contentHashByGeneratedTypeName, this.contentHashByGeneratedTypeName);
copyMap(that.jsByTypeName, this.jsByTypeName);
copyMap(that.lastModifiedByDiskSourcePath, this.lastModifiedByDiskSourcePath);
copyMap(that.lastModifiedByResourcePath, this.lastModifiedByResourcePath);
copyMap(that.sourceMapsByTypeName, this.sourceMapsByTypeName);
copyMap(that.statementRangesByTypeName, this.statementRangesByTypeName);
copyMultimap(that.generatedCompilationUnitNamesByReboundTypeNames,
this.generatedCompilationUnitNamesByReboundTypeNames);
copyMultimap(that.nestedTypeNamesByUnitTypeName, this.nestedTypeNamesByUnitTypeName);
copyMultimap(that.rebinderTypeNamesByReboundTypeName, this.rebinderTypeNamesByReboundTypeName);
copyMultimap(that.reboundTypeNamesByGeneratedCompilationUnitNames,
this.reboundTypeNamesByGeneratedCompilationUnitNames);
copyMultimap(that.reboundTypeNamesByInputResource, this.reboundTypeNamesByInputResource);
copyMultimap(that.referencedTypeNamesByTypeName, this.referencedTypeNamesByTypeName);
copyMultimap(that.typeNamesByReferencingTypeName, this.typeNamesByReferencingTypeName);
copyCollection(that.deletedCompilationUnitNames, this.deletedCompilationUnitNames);
copyCollection(that.deletedDiskSourcePaths, this.deletedDiskSourcePaths);
copyCollection(that.deletedResourcePaths, this.deletedResourcePaths);
copyCollection(that.dualJsoImplInterfaceNames, this.dualJsoImplInterfaceNames);
copyCollection(that.generatedArtifacts, this.generatedArtifacts);
copyCollection(that.jsoStatusChangedTypeNames, this.jsoStatusChangedTypeNames);
copyCollection(that.jsoTypeNames, this.jsoTypeNames);
copyCollection(that.lastReachableTypeNames, this.lastReachableTypeNames);
copyCollection(that.modifiedCompilationUnitNames, this.modifiedCompilationUnitNames);
copyCollection(that.modifiedDiskSourcePaths, this.modifiedDiskSourcePaths);
copyCollection(that.modifiedResourcePaths, this.modifiedResourcePaths);
copyCollection(that.preambleTypeNames, this.preambleTypeNames);
copyCollection(that.rootTypeNames, this.rootTypeNames);
copyCollection(that.singleJsoImplInterfaceNames, this.singleJsoImplInterfaceNames);
copyCollection(that.sourceCompilationUnitNames, this.sourceCompilationUnitNames);
copyCollection(that.staleTypeNames, this.staleTypeNames);
}
/**
* Return the set of provided typeNames with unreachable types filtered out.
*/
public Set filterUnreachableTypeNames(Set typeNames) {
return Sets.newHashSet(Sets.filter(typeNames, Predicates.in(lastReachableTypeNames)));
}
public ArtifactSet getGeneratedArtifacts() {
return generatedArtifacts;
}
public ImmediateTypeRelations getImmediateTypeRelations() {
return immediateTypeRelations;
}
public IntTypeMapper getTypeMapper() {
return intTypeMapper;
}
public String getJs(String typeName) {
return jsByTypeName.get(typeName);
}
public int getLastLinkedJsBytes() {
return lastLinkedJsBytes;
}
@VisibleForTesting
public Set getModifiedCompilationUnitNames() {
return modifiedCompilationUnitNames;
}
public PersistentPrettyNamerState getPersistentPrettyNamerState() {
return persistentPrettyNamerState;
}
public Set getPreambleTypeNames() {
return preambleTypeNames;
}
/**
* Returns the set of the names of types that were processed as stale. This list can be larger
* than the calculated list of stale types for example when a new reference is created to a type
* that had not been processed in a previous compile.
*/
public Set getProcessedStaleTypeNames() {
return processedStaleTypeNames;
}
public JsSourceMap getSourceMap(String typeName) {
return sourceMapsByTypeName.get(typeName);
}
@VisibleForTesting
public Set getStaleTypeNames() {
return staleTypeNames;
}
public StatementRanges getStatementRanges(String typeName) {
return statementRangesByTypeName.get(typeName);
}
public boolean hasJs(String typeName) {
return jsByTypeName.containsKey(typeName);
}
public boolean hasPreambleTypeNames() {
return !preambleTypeNames.isEmpty();
}
/**
* Returns true if there is cached data to reuse in the next recompile.
*/
public boolean isPopulated() {
return !immediateTypeRelations.isEmpty();
}
public boolean isSourceCompilationUnit(String compilationUnitName) {
return sourceCompilationUnitNames.contains(compilationUnitName);
}
public boolean knowsLastLinkedJsBytes() {
return lastLinkedJsBytes != null;
}
@VisibleForTesting
public void markSourceFileStale(String typeName) {
lastModifiedByDiskSourcePath.remove(typeName);
}
/**
* Records the resource paths and modification dates of build resources in the current compile and
* builds a list of known modified resource paths by comparing the resource paths and modification
* dates of build resources in the previous compile with those of the current compile.
*/
public void recordBuildResources(ModuleDef module) {
Map currentModifiedByResourcePath =
resourcesToModifiedByPath(module.getBuildResourceOracle().getResources());
recordModifiedResources(currentModifiedByResourcePath, lastModifiedByResourcePath,
modifiedResourcePaths, deletedResourcePaths);
}
/**
* Records the paths and modification dates of source resources in the current compile and builds
* a list of known modified paths by comparing the paths and modification dates of source
* resources in the previous compile with those of the current compile.
*/
@VisibleForTesting
public void recordDiskSourceResources(Map currentModifiedByDiskSourcePath) {
recordModifiedResources(currentModifiedByDiskSourcePath, lastModifiedByDiskSourcePath,
modifiedDiskSourcePaths, deletedDiskSourcePaths);
deletedCompilationUnitNames.clear();
deletedCompilationUnitNames.addAll(resourcePathsToCompilationUnitNames(deletedDiskSourcePaths));
modifiedCompilationUnitNames.clear();
modifiedCompilationUnitNames.addAll(
resourcePathsToCompilationUnitNames(modifiedDiskSourcePaths));
}
/**
* Records the paths and modification dates of source resources in the current compile and builds
* a list of known modified paths by comparing the paths and modification dates of source
* resources in the previous compile with those of the current compile.
*/
public void recordDiskSourceResources(ModuleDef module) {
Map currentModifiedByDiskSourcePath =
resourcesToModifiedByPath(module.getSourceResourceOracle().getResources());
recordDiskSourceResources(currentModifiedByDiskSourcePath);
}
/**
* Records the paths and content ids of generated source resources in the current compile and
* updates a list of known modified paths by comparing the paths and content ids of generated
* source resources in the previous compile with those of the current compile.
*/
public void recordGeneratedUnits(Collection generatedUnits) {
// Not all Generators are run on each compile so it is not possible to compare previous and
// current generated units to detect deletions. As a result only modifications are tracked.
for (GeneratedUnit generatedUnit : generatedUnits) {
String currentStrongHash = generatedUnit.getStrongHash();
String lastKnownStrongHash =
contentHashByGeneratedTypeName.put(generatedUnit.getTypeName(), currentStrongHash);
if (!Objects.equal(lastKnownStrongHash, currentStrongHash)) {
// Added or Modified resource.
modifiedCompilationUnitNames.add(generatedUnit.getTypeName());
}
}
}
@VisibleForTesting
public void recordNestedTypeName(String compilationUnitTypeName, String nestedTypeName) {
nestedTypeNamesByUnitTypeName.put(compilationUnitTypeName, nestedTypeName);
compilationUnitTypeNameByNestedTypeName.put(nestedTypeName, compilationUnitTypeName);
}
public void recordNestedTypeNamesPerType(CompilationUnit compilationUnit) {
// For the root type in the compilation unit the source name and binary name are the same.
String compilationUnitTypeName = compilationUnit.getTypeName();
nestedTypeNamesByUnitTypeName.removeAll(compilationUnitTypeName);
for (CompiledClass compiledClass : compilationUnit.getCompiledClasses()) {
String nestedTypeName = InternalName.toBinaryName(compiledClass.getInternalName());
recordNestedTypeName(compilationUnitTypeName, nestedTypeName);
}
}
/**
* Records that rebinder type Foo contains a GWT.create(ReboundTypeBar.class) call.
*/
public void recordRebinderTypeForReboundType(String reboundTypeName, String rebinderType) {
rebinderTypeNamesByReboundTypeName.put(reboundTypeName, rebinderType);
}
public void removeReferencesFrom(String fromTypeName) {
Collection toTypeNames = referencedTypeNamesByTypeName.get(fromTypeName);
for (String toTypeName : toTypeNames) {
typeNamesByReferencingTypeName.remove(toTypeName, fromTypeName);
}
referencedTypeNamesByTypeName.removeAll(fromTypeName);
}
public void setJsForType(TreeLogger logger, String typeName, String typeJs) {
logger.log(TreeLogger.SPAM, "caching JS for type " + typeName);
jsByTypeName.put(typeName, typeJs);
}
/**
* Records the names of JSO subtypes, single impl interfaces and dual impl interfaces as well as
* keeps track of types that entered or left one of the lists in the most recent iteration.
*/
public void setJsoTypeNames(Set jsoTypeNames, Set singleJsoImplInterfaceNames,
Set dualJsoImplInterfaceNames) {
this.jsoStatusChangedTypeNames.clear();
this.jsoStatusChangedTypeNames.addAll(
Sets.symmetricDifference(this.jsoTypeNames, jsoTypeNames));
this.jsoStatusChangedTypeNames.addAll(
Sets.symmetricDifference(this.singleJsoImplInterfaceNames, singleJsoImplInterfaceNames));
this.jsoStatusChangedTypeNames.addAll(
Sets.symmetricDifference(this.dualJsoImplInterfaceNames, dualJsoImplInterfaceNames));
this.jsoTypeNames.clear();
this.jsoTypeNames.addAll(jsoTypeNames);
this.singleJsoImplInterfaceNames.clear();
this.singleJsoImplInterfaceNames.addAll(singleJsoImplInterfaceNames);
this.dualJsoImplInterfaceNames.clear();
this.dualJsoImplInterfaceNames.addAll(dualJsoImplInterfaceNames);
}
public void setLastLinkedJsBytes(int lastLinkedJsBytes) {
this.lastLinkedJsBytes = lastLinkedJsBytes;
}
public void setPreambleTypeNames(TreeLogger logger, Set preambleTypeNames) {
logger.log(TreeLogger.DEBUG, "caching list of known preamble types " + preambleTypeNames);
this.preambleTypeNames.addAll(preambleTypeNames);
}
public void setProcessedStaleTypeNames(Set processedStaleTypeNames) {
// If this is the first compile.
if (!isPopulated()) {
// Don't record processed stale types, since the list is huge and not useful for test
// assertions.
return;
}
this.processedStaleTypeNames = ImmutableSet.copyOf(processedStaleTypeNames);
}
public void setRootTypeNames(Collection rootTypeNames) {
this.rootTypeNames.clear();
this.rootTypeNames.addAll(rootTypeNames);
}
public void setSourceMapForType(String typeName, JsSourceMap sourceMap) {
sourceMapsByTypeName.put(typeName, sourceMap);
}
public void setStatementRangesForType(String typeName, StatementRanges statementRanges) {
statementRangesByTypeName.put(typeName, statementRanges);
}
private void appendReferencingTypes(Set accumulatedTypeNames,
Collection referencedTypeNames) {
for (String referencedTypeName : referencedTypeNames) {
Collection referencingTypeNames =
typeNamesByReferencingTypeName.get(referencedTypeName);
accumulatedTypeNames.addAll(referencingTypeNames);
}
}
/**
* If type Foo is a generated type and is stale this pass will append type Bar that triggers
* Generator Baz that regenerates type Foo.
*
* This is necessary since just clearing the cache for type Foo would not be adequate to cause the
* recreation of its cached JS without also rerunning the Generator that creates type Foo.
*/
private void appendTypesToRegenerateStaleGeneratedTypes(Set staleTypeNames) {
Set generatedCompilationUnitNames =
reboundTypeNamesByGeneratedCompilationUnitNames.keySet();
// Filter the current stale types list for any compilation units that are known to be generated.
Set staleGeneratedCompilationUnitNames = Sets.intersection(
computeCompilationUnitNames(staleTypeNames), generatedCompilationUnitNames);
boolean discoveredMoreStaleTypes;
do {
// Accumulate staleGeneratedCompilationUnits -> generators ->
// generatorTriggeringCompilationUnits.
Set reboundTypesThatGenerateTheStaleCompilationUnits =
computeReboundTypesThatGenerateTypes(staleGeneratedCompilationUnitNames);
Set generatorTriggeringTypes =
computeTypesThatRebindTypes(reboundTypesThatGenerateTheStaleCompilationUnits);
// Mark these generator triggering types stale and keep track of whether any of them were not
// previously known to be stale.
discoveredMoreStaleTypes = staleTypeNames.addAll(generatorTriggeringTypes);
// It's possible that a generator triggering type was itself also created by a Generator.
// Repeat the backwards trace process till none of the newly stale types are generated types.
staleGeneratedCompilationUnitNames = Sets.intersection(
computeCompilationUnitNames(generatorTriggeringTypes), generatedCompilationUnitNames);
} while (discoveredMoreStaleTypes);
}
private void clearCachedTypeOutput(String staleTypeName) {
jsByTypeName.remove(staleTypeName);
statementRangesByTypeName.remove(staleTypeName);
sourceMapsByTypeName.remove(staleTypeName);
}
/**
* Returns the set of names of CompilationUnits that contain all of the given type names.
*/
private Set computeCompilationUnitNames(Set typeNames) {
Set compilationUnitNames = Sets.newHashSet();
for (String typeName : typeNames) {
compilationUnitNames.add(compilationUnitTypeNameByNestedTypeName.get(typeName));
}
return compilationUnitNames;
}
/**
* Returns the set of type names contained within the given compilation units.
*/
private Set computeNestedTypeNames(Set compilationUnitNames) {
Set nestedTypeNames = Sets.newHashSet();
nestedTypeNames.addAll(compilationUnitNames);
for (String compilationUnitName : compilationUnitNames) {
nestedTypeNames.addAll(nestedTypeNamesByUnitTypeName.get(compilationUnitName));
}
return nestedTypeNames;
}
/**
* Returns the set of names of types that when rebound trigger Generators that access resources
* which are known to have been modified.
*/
private Set computeReboundTypesAffectedByModifiedResources() {
Set affectedRebindTypeNames = Sets.newHashSet();
for (String modifiedResourcePath : modifiedResourcePaths) {
affectedRebindTypeNames.addAll(reboundTypeNamesByInputResource.get(modifiedResourcePath));
}
return affectedRebindTypeNames;
}
private Set computeReboundTypesThatGenerateTypes(
Set staleGeneratedCompilationUnitNames) {
Set reboundTypesThatGenerateTypes = Sets.newHashSet();
for (String staleGeneratedCompilationUnitName : staleGeneratedCompilationUnitNames) {
reboundTypesThatGenerateTypes.addAll(
reboundTypeNamesByGeneratedCompilationUnitNames.get(staleGeneratedCompilationUnitName));
}
return reboundTypesThatGenerateTypes;
}
/**
* Returns the set of names of types that contain GWT.create(ReboundType.class) calls that rebind
* the given set of type names.
*/
private Set computeTypesThatRebindTypes(Set reboundTypeNames) {
Set typesThatRebindTypes = Sets.newHashSet();
for (String reboundTypeName : reboundTypeNames) {
typesThatRebindTypes.addAll(rebinderTypeNamesByReboundTypeName.get(reboundTypeName));
}
return typesThatRebindTypes;
}
}