New analyzer snapshot.

pkg/analyzer/lib/src/generated/engine.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import 'dart:collection';
@@ skipping 17 matching lines @@
  * Instances of the class `AnalysisCache` implement an LRU cache of information related to
  * analysis.
  */
 class AnalysisCache {
   /**
    * An array containing the partitions of which this cache is comprised.
    */
   final List<CachePartition> _partitions;
 
   /**
+   * A flag used to control whether trace information should be produced when the content of the
+   * cache is modified.
+   */
+  static bool _TRACE_CHANGES = false;
+
+  /**
    * Initialize a newly created cache to have the given partitions. The partitions will be searched
    * in the order in which they appear in the array, so the most specific partition (usually an
    * [SdkCachePartition]) should be first and the most general (usually a
    * [UniversalCachePartition]) last.
    *
    * @param partitions the partitions for the newly created cache
    */
   AnalysisCache(this._partitions);
 
   /**
@@ skipping 67 matching lines @@
    * Associate the given entry with the given source.
    *
    * @param source the source with which the entry is to be associated
    * @param entry the entry to be associated with the source
    */
   void put(Source source, SourceEntry entry) {
     (entry as SourceEntryImpl).fixExceptionState();
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(source)) {
+        if (_TRACE_CHANGES) {
+          try {
+            SourceEntry oldEntry = _partitions[i].get(source);
+            if (oldEntry == null) {
+              AnalysisEngine.instance.logger.logInformation("Added a cache entry for '${source.fullName}'.");
+            } else {
+              AnalysisEngine.instance.logger.logInformation("Modified the cache entry for ${source.fullName}'. Diff = ${(entry as SourceEntryImpl).getDiff(oldEntry)}");
+            }
+          } catch (exception) {
+            // Ignored
+            JavaSystem.currentTimeMillis();
+          }
+        }
         _partitions[i].put(source, entry);
         return;
       }
     }
   }
 
   /**
    * Remove all information related to the given source from this cache.
    *
    * @param source the source to be removed
    */
   void remove(Source source) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(source)) {
+        if (_TRACE_CHANGES) {
+          try {
+            AnalysisEngine.instance.logger.logInformation("Removed the cache entry for ${source.fullName}'.");
+          } catch (exception) {
+            // Ignored
+            JavaSystem.currentTimeMillis();
+          }
+        }
         _partitions[i].remove(source);
         return;
       }
     }
   }
 
   /**
    * Record that the AST associated with the given source was just removed from the cache.
    *
    * @param source the source whose AST was removed
@@ skipping 9750 matching lines @@
     _publicNamespace = other._publicNamespace;
     _clientServerState = other._clientServerState;
     _launchableState = other._launchableState;
     _angularErrors = other._angularErrors;
   }
 
   @override
   bool get hasErrorState => super.hasErrorState || _scanErrorsState == CacheState.ERROR || _tokenStreamState == CacheState.ERROR || _sourceKindState == CacheState.ERROR || _parsedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _importedLibrariesState == CacheState.ERROR || _exportedLibrariesState == CacheState.ERROR || _includedPartsState == CacheState.ERROR || _elementState == CacheState.ERROR || _publicNamespaceState == CacheState.ERROR || _clientServerState == CacheState.ERROR || _launchableState == CacheState.ERROR || _resolutionState.hasErrorState;
 
   @override
+  bool writeDiffOn(JavaStringBuilder builder, SourceEntry oldEntry) {
+    bool needsSeparator = super.writeDiffOn(builder, oldEntry);
+    if (oldEntry is! DartEntryImpl) {
+      if (needsSeparator) {
+        builder.append("; ");
+      }
+      builder.append("entry type changed; was ${oldEntry.runtimeType.toString()}");
+      return true;
+    }
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.TOKEN_STREAM, "tokenStream");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.SCAN_ERRORS, "scanErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.SOURCE_KIND, "sourceKind");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.PARSED_UNIT, "parsedUnit");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.PARSE_ERRORS, "parseErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.IMPORTED_LIBRARIES, "importedLibraries");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.EXPORTED_LIBRARIES, "exportedLibraries");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.INCLUDED_PARTS, "includedParts");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.ELEMENT, "element");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.PUBLIC_NAMESPACE, "publicNamespace");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.IS_CLIENT, "clientServer");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.IS_LAUNCHABLE, "launchable");
+    // TODO(brianwilkerson) Add better support for containingLibraries. It would be nice to be able
+    // to report on size-preserving changes.
+    int oldLibraryCount = (oldEntry as DartEntryImpl)._containingLibraries.length;
+    int libraryCount = _containingLibraries.length;
+    if (oldLibraryCount != libraryCount) {
+      if (needsSeparator) {
+        builder.append("; ");
+      }
+      builder.append("containingLibraryCount = ");
+      builder.append(oldLibraryCount);
+      builder.append(" -> ");
+      builder.append(libraryCount);
+      needsSeparator = true;
+    }
+    //
+    // Report change to the per-library state.
+    //
+    HashMap<Source, DartEntryImpl_ResolutionState> oldStateMap = new HashMap<Source, DartEntryImpl_ResolutionState>();
+    DartEntryImpl_ResolutionState state = (oldEntry as DartEntryImpl)._resolutionState;
+    while (state != null) {
+      Source librarySource = state._librarySource;
+      if (librarySource != null) {
+        oldStateMap[librarySource] = state;
+      }
+      state = state._nextState;
+    }
+    state = _resolutionState;
+    while (state != null) {
+      Source librarySource = state._librarySource;
+      if (librarySource != null) {
+        DartEntryImpl_ResolutionState oldState = oldStateMap.remove(librarySource);
+        if (oldState == null) {
+          if (needsSeparator) {
+            builder.append("; ");
+          }
+          builder.append("added resolution for ");
+          builder.append(librarySource.fullName);
+          needsSeparator = true;
+        } else {
+          needsSeparator = oldState.writeDiffOn(builder, needsSeparator, oldEntry as DartEntry);
+        }
+      }
+      state = state._nextState;
+    }
+    for (Source librarySource in oldStateMap.keys.toSet()) {
+      if (needsSeparator) {
+        builder.append("; ");
+      }
+      builder.append("removed resolution for ");
+      builder.append(librarySource.fullName);
+      needsSeparator = true;
+    }
+    return needsSeparator;
+  }
+
+  @override
   void writeOn(JavaStringBuilder builder) {
     builder.append("Dart: ");
     super.writeOn(builder);
     builder.append("; tokenStream = ");
     builder.append(_tokenStreamState);
     builder.append("; scanErrors = ");
     builder.append(_scanErrorsState);
     builder.append("; sourceKind = ");
     builder.append(_sourceKindState);
     builder.append("; parsedUnit = ");
@@ skipping 317 matching lines @@
    * represented by this entry. This will set the state of all verification information as being
    * in error.
    */
   void recordVerificationError() {
     _verificationErrors = AnalysisError.NO_ERRORS;
     _verificationErrorsState = CacheState.ERROR;
     recordHintError();
   }
 
   /**
+   * Write a textual representation of the difference between the old entry and this entry to the
+   * given string builder.
+   *
+   * @param builder the string builder to which the difference is to be written
+   * @param oldEntry the entry that was replaced by this entry
+   * @return `true` if some difference was written
+   */
+  bool writeDiffOn(JavaStringBuilder builder, bool needsSeparator, DartEntry oldEntry) {
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.BUILT_UNIT, _builtUnitState, "builtUnit");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.BUILD_ELEMENT_ERRORS, _buildElementErrorsState, "buildElementErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.RESOLVED_UNIT, _resolvedUnitState, "resolvedUnit");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.RESOLUTION_ERRORS, _resolutionErrorsState, "resolutionErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.VERIFICATION_ERRORS, _verificationErrorsState, "verificationErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.HINTS, _hintsState, "hints");
+    return needsSeparator;
+  }
+
+  /**
    * Write a textual representation of this state to the given builder. The result will only be
    * used for debugging purposes.
    *
    * @param builder the builder to which the text should be written
    */
   void writeOn(JavaStringBuilder builder) {
     if (_librarySource != null) {
       builder.append("; builtUnit = ");
       builder.append(_builtUnitState);
       builder.append("; buildElementErrors = ");
       builder.append(_buildElementErrorsState);
       builder.append("; resolvedUnit = ");
       builder.append(_resolvedUnitState);
       builder.append("; resolutionErrors = ");
       builder.append(_resolutionErrorsState);
       builder.append("; verificationErrors = ");
       builder.append(_verificationErrorsState);
       builder.append("; hints = ");
       builder.append(_hintsState);
       if (_nextState != null) {
         _nextState.writeOn(builder);
       }
     }
   }
+
+  /**
+   * Write a textual representation of the difference between the state of the specified data
+   * between the old entry and this entry to the given string builder.
+   *
+   * @param builder the string builder to which the difference is to be written
+   * @param needsSeparator `true` if any data that is written
+   * @param oldEntry the entry that was replaced by this entry
+   * @param descriptor the descriptor defining the data whose state is being compared
+   * @param label the label used to describe the state
+   * @return `true` if some difference was written
+   */
+  bool writeStateDiffOn(JavaStringBuilder builder, bool needsSeparator, SourceEntry oldEntry, DataDescriptor descriptor, CacheState newState, String label) {
+    CacheState oldState = (oldEntry as DartEntryImpl).getStateInLibrary(descriptor, _librarySource);
+    if (oldState != newState) {
+      if (needsSeparator) {
+        builder.append("; ");
+      }
+      builder.append(label);
+      builder.append(" = ");
+      builder.append(oldState);
+      builder.append(" -> ");
+      builder.append(newState);
+      return true;
+    }
+    return needsSeparator;
+  }
 }
 
 /**
  * Instances of the class `DataDescriptor` are immutable constants representing data that can
  * be stored in the cache.
  */
 class DataDescriptor<E> {
   /**
    * The name of the descriptor, used for debugging purposes.
    */
@@ skipping 362 matching lines @@
   @override
   String get taskDescription => "get contents of ${source.fullName}";
 
   @override
   void internalPerform() {
     _complete = true;
     try {
       TimestampedData<String> data = context.getContents(source);
       _content = data.data;
       _modificationTime = data.modificationTime;
-    } on JavaException catch (exception, stackTrace) {
+    } catch (exception, stackTrace) {
       throw new AnalysisException("Could not get contents of ${source}", new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * The interface `HtmlEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual HTML file.
  */
 abstract class HtmlEntry implements SourceEntry {
@@ skipping 579 matching lines @@
     _polymerBuildErrorsState = other._polymerBuildErrorsState;
     _polymerBuildErrors = other._polymerBuildErrors;
     _polymerResolutionErrorsState = other._polymerResolutionErrorsState;
     _polymerResolutionErrors = other._polymerResolutionErrors;
   }
 
   @override
   bool get hasErrorState => super.hasErrorState || _parsedUnitState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _referencedLibrariesState == CacheState.ERROR || _elementState == CacheState.ERROR || _angularErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || _polymerBuildErrorsState == CacheState.ERROR || _polymerResolutionErrorsState == CacheState.ERROR;
 
   @override
+  bool writeDiffOn(JavaStringBuilder builder, SourceEntry oldEntry) {
+    bool needsSeparator = super.writeDiffOn(builder, oldEntry);
+    if (oldEntry is! HtmlEntryImpl) {
+      if (needsSeparator) {
+        builder.append("; ");
+      }
+      builder.append("entry type changed; was ${oldEntry.runtimeType.toString()}");
+      return true;
+    }
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.PARSE_ERRORS, "parseErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.PARSED_UNIT, "parsedUnit");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.RESOLVED_UNIT, "resolvedUnit");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.RESOLUTION_ERRORS, "resolutionErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.REFERENCED_LIBRARIES, "referencedLibraries");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.ELEMENT, "element");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.ANGULAR_APPLICATION, "angularApplicationState");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.ANGULAR_COMPONENT, "angularComponent");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.ANGULAR_ENTRY, "angularEntry");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.ANGULAR_ERRORS, "angularErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.POLYMER_BUILD_ERRORS, "polymerBuildErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.POLYMER_RESOLUTION_ERRORS, "polymerResolutionErrors");
+    return needsSeparator;
+  }
+
+  @override
   void writeOn(JavaStringBuilder builder) {
     builder.append("Html: ");
     super.writeOn(builder);
     builder.append("; parseErrors = ");
     builder.append(_parseErrorsState);
     builder.append("; parsedUnit = ");
     builder.append(_parsedUnitState);
     builder.append("; resolvedUnit = ");
     builder.append(_resolvedUnitState);
     builder.append("; resolutionErrors = ");
@@ skipping 3606 matching lines @@
         // recorded when it should be.
         //
         _exception = new CaughtException(new AnalysisException("State set to ERROR without setting an exception"), null);
       }
     } else {
       _exception = null;
     }
   }
 
   /**
+   * Return a textual representation of the difference between the old entry and this entry. The
+   * difference is represented as a sequence of fields whose value would change if the old entry
+   * were converted into the new entry.
+   *
+   * @param oldEntry the entry being diff'd with this entry
+   * @return a textual representation of the difference
+   */
+  String getDiff(SourceEntry oldEntry) {
+    JavaStringBuilder builder = new JavaStringBuilder();
+    writeDiffOn(builder, oldEntry);
+    return builder.toString();
+  }
+
+  /**
    * Return the exception that caused one or more values to have a state of [CacheState#ERROR]
    * .
    *
    * @return the exception that caused one or more values to be uncomputable
    */
   @override
   CaughtException get exception => _exception;
 
   /**
    * Return `true` if the source was explicitly added to the context or `false` if the
@@ skipping 206 matching lines @@
     } else if (state == CacheState.IN_PROCESS) {
       //
       // We can leave the current value in the cache for any 'get' methods to access.
       //
       return currentValue;
     }
     return defaultValue;
   }
 
   /**
+   * Write a textual representation of the difference between the old entry and this entry to the
+   * given string builder.
+   *
+   * @param builder the string builder to which the difference is to be written
+   * @param oldEntry the entry that was replaced by this entry
+   * @return `true` if some difference was written
+   */
+  bool writeDiffOn(JavaStringBuilder builder, SourceEntry oldEntry) {
+    bool needsSeparator = false;
+    CaughtException oldException = oldEntry.exception;
+    if (!identical(oldException, _exception)) {
+      builder.append("exception = ");
+      builder.append(oldException.runtimeType);
+      builder.append(" -> ");
+      builder.append(_exception.runtimeType);
+      needsSeparator = true;
+    }
+    int oldModificationTime = oldEntry.modificationTime;
+    if (oldModificationTime != _modificationTime) {
+      if (needsSeparator) {
+        builder.append("; ");
+      }
+      builder.append("time = ");
+      builder.append(oldModificationTime);
+      builder.append(" -> ");
+      builder.append(_modificationTime);
+      needsSeparator = true;
+    }
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, SourceEntry.CONTENT, "content");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, SourceEntry.LINE_INFO, "lineInfo");
+    return needsSeparator;
+  }
+
+  /**
    * Write a textual representation of this entry to the given builder. The result will only be used
    * for debugging purposes.
    *
    * @param builder the builder to which the text should be written
    */
   void writeOn(JavaStringBuilder builder) {
     builder.append("time = ");
     builder.append(_modificationTime);
     builder.append("; content = ");
     builder.append(_contentState);
     builder.append("; lineInfo = ");
     builder.append(_lineInfoState);
   }
 
   /**
+   * Write a textual representation of the difference between the state of the specified data
+   * between the old entry and this entry to the given string builder.
+   *
+   * @param builder the string builder to which the difference is to be written
+   * @param needsSeparator `true` if any data that is written
+   * @param oldEntry the entry that was replaced by this entry
+   * @param descriptor the descriptor defining the data whose state is being compared
+   * @param label the label used to describe the state
+   * @return `true` if some difference was written
+   */
+  bool writeStateDiffOn(JavaStringBuilder builder, bool needsSeparator, SourceEntry oldEntry, DataDescriptor descriptor, String label) {
+    CacheState oldState = oldEntry.getState(descriptor);
+    CacheState newState = getState(descriptor);
+    if (oldState != newState) {
+      if (needsSeparator) {
+        builder.append("; ");
+      }
+      builder.append(label);
+      builder.append(" = ");
+      builder.append(oldState);
+      builder.append(" -> ");
+      builder.append(newState);
+      return true;
+    }
+    return needsSeparator;
+  }
+
+  /**
    * If the state is changing from ERROR to anything else, capture the information. This is an
    * attempt to discover the underlying cause of a long-standing bug.
    *
    * @param newState the new state of the content
    * @return the new state of the content
    */
   CacheState _checkContentState(CacheState newState) {
     if (_contentState == CacheState.ERROR) {
       InstrumentationBuilder builder = Instrumentation.builder2("SourceEntryImpl-checkContentState");
       builder.data3("message", "contentState changing from ${_contentState} to ${newState}");
@@ skipping 294 matching lines @@
     _index++;
     if (_index >= WorkManager_this._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < WorkManager_this._workQueues.length && WorkManager_this._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }