Remove unused time stamps

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 1194 matching lines @@
       } else if (sourceEntry is DartEntry) {
         return _getDartScanData2(source, SourceEntry.LINE_INFO, null);
       }
     } on ObsoleteSourceAnalysisException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Could not compute ${SourceEntry.LINE_INFO.toString()}", exception);
     }
     return null;
   }
 
   @override
-  ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
+  CompilationUnit computeResolvableCompilationUnit(Source source) {
     DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       throw new AnalysisException("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
     }
     dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
     CompilationUnit unit = dartEntry.resolvableCompilationUnit;
     if (unit == null) {
       throw new AnalysisException("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", new CaughtException(dartEntry.exception, null));
     }
-    return new ResolvableCompilationUnit.con1(dartEntry.modificationTime, unit);
+    return unit;
   }
 
   @override
   void dispose() {
     _disposed = true;
   }
 
   @override
   bool exists(Source source) {
     if (source == null) {
@@ skipping 892 matching lines @@
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       if (container.contains(source)) {
         sources.add(source);
       }
     }
   }
 
   /**
-   * Return `true` if the modification times of the sources used by the given library resolver
-   * to resolve one or more libraries are consistent with the modification times in the cache.
-   *
-   * @param resolver the library resolver used to resolve one or more libraries
-   * @return `true` if we should record the results of the resolution
-   * @throws AnalysisException if any of the modification times could not be determined (this should
-   *           not happen)
-   */
-  bool _allModificationTimesMatch(List<ResolvableLibrary> resolvedLibraries) {
-    bool allTimesMatch = true;
-    for (ResolvableLibrary library in resolvedLibraries) {
-      for (Source source in library.compilationUnitSources) {
-        DartEntry dartEntry = _getReadableDartEntry(source);
-        if (dartEntry == null) {
-          // This shouldn't be possible because we should never have performed the task if the
-          // source didn't represent a Dart file, but check to be safe.
-          throw new AnalysisException("Internal error: attempting to resolve non-Dart file as a Dart file: ${source.fullName}");
-        }
-        int sourceTime = getModificationStamp(source);
-        int resultTime = library.getModificationTime(source);
-        if (sourceTime != resultTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          _sourceChanged(source);
-          allTimesMatch = false;
-        }
-      }
-    }
-    return allTimesMatch;
-  }
-
-  /**
-   * Return `true` if the modification times of the sources used by the given library resolver
-   * to resolve one or more libraries are consistent with the modification times in the cache.
-   *
-   * @param resolver the library resolver used to resolve one or more libraries
-   * @return `true` if we should record the results of the resolution
-   * @throws AnalysisException if any of the modification times could not be determined (this should
-   *           not happen)
-   */
-  bool _allModificationTimesMatch2(Set<Library> resolvedLibraries) {
-    bool allTimesMatch = true;
-    for (Library library in resolvedLibraries) {
-      for (Source source in library.compilationUnitSources) {
-        DartEntry dartEntry = _getReadableDartEntry(source);
-        if (dartEntry == null) {
-          // This shouldn't be possible because we should never have performed the task if the
-          // source didn't represent a Dart file, but check to be safe.
-          throw new AnalysisException("Internal error: attempting to resolve non-Dart file as a Dart file: ${source.fullName}");
-        }
-        int sourceTime = getModificationStamp(source);
-        int resultTime = library.getModificationTime(source);
-        if (sourceTime != resultTime) {
-          // The source has changed without the context being notified. Simulate notification.
-          _sourceChanged(source);
-          allTimesMatch = false;
-        }
-      }
-    }
-    return allTimesMatch;
-  }
-
-  /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState.VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by generating hints
    * for the library if the data is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
@@ skipping 57 matching lines @@
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       dartEntry = _cacheDartScanData(source, dartEntry, DartEntry.TOKEN_STREAM);
-      dartEntry = new ParseDartTask(this, source, dartEntry.modificationTime, dartEntry.getValue(DartEntry.TOKEN_STREAM), dartEntry.getValue(SourceEntry.LINE_INFO)).perform(_resultRecorder) as DartEntry;
+      dartEntry = new ParseDartTask(this, source, dartEntry.getValue(DartEntry.TOKEN_STREAM), dartEntry.getValue(SourceEntry.LINE_INFO)).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState.VALID] or
    * [CacheState.ERROR]. This method assumes that the data can be produced by resolving the
    * source in the context of the library if it is not already cached.
@@ skipping 46 matching lines @@
     CacheState state = dartEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       try {
         if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
           dartEntry = new GetContentTask(this, source).perform(_resultRecorder) as DartEntry;
         }
-        dartEntry = new ScanDartTask(this, source, dartEntry.modificationTime, dartEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as DartEntry;
+        dartEntry = new ScanDartTask(this, source, dartEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as DartEntry;
       } on AnalysisException catch (exception) {
         throw exception;
       } catch (exception, stackTrace) {
         throw new AnalysisException("Exception", new CaughtException(exception, stackTrace));
       }
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
@@ skipping 20 matching lines @@
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       LibraryElement library = computeLibraryElement(librarySource);
       CompilationUnit unit = resolveCompilationUnit(unitSource, library);
       if (unit == null) {
         throw new AnalysisException("Could not resolve compilation unit ${unitSource.fullName} in ${librarySource.fullName}");
       }
-      dartEntry = new GenerateDartErrorsTask(this, unitSource, dartEntry.modificationTime, unit, library).perform(_resultRecorder) as DartEntry;
+      dartEntry = new GenerateDartErrorsTask(this, unitSource, unit, library).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which all of the data represented by
    * the state of the given descriptors is either [CacheState.VALID] or
    * [CacheState.ERROR]. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
@@ skipping 20 matching lines @@
     CacheState state = htmlEntry.getState(descriptor);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       try {
         if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
           htmlEntry = new GetContentTask(this, source).perform(_resultRecorder) as HtmlEntry;
         }
-        htmlEntry = new ParseHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as HtmlEntry;
+        htmlEntry = new ParseHtmlTask(this, source, htmlEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as HtmlEntry;
       } on AnalysisException catch (exception) {
         throw exception;
       } catch (exception, stackTrace) {
         throw new AnalysisException("Exception", new CaughtException(exception, stackTrace));
       }
       state = htmlEntry.getState(descriptor);
     }
     return htmlEntry;
   }
 
@@ skipping 118 matching lines @@
     }
     CompilationUnit unit = unitEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     if (unit == null) {
       CaughtException exception = new CaughtException(new AnalysisException("Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}"), null);
       AnalysisEngine.instance.logger.logInformation2(exception.toString(), exception);
       unitEntry.recordResolutionError(exception);
       return new AnalysisContextImpl_TaskData(null, false);
     }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
     unitEntry.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
-    return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, unitSource, unitEntry.modificationTime, unit, libraryElement), false);
+    return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, unitSource, unit, libraryElement), false);
   }
 
   /**
    * Create a [GenerateDartHintsTask] for the given source, marking the hints as being
    * in-process.
    *
    * @param source the source whose content is to be verified
    * @param dartEntry the entry for the source
    * @param librarySource the source for the library containing the source
    * @param libraryEntry the entry for the library
@@ skipping 45 matching lines @@
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createParseDartTask(Source source, DartEntry dartEntry) {
     if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID || dartEntry.getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       return _createScanDartTask(source, dartEntry);
     }
     Token tokenStream = dartEntry.getValue(DartEntry.TOKEN_STREAM);
     dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
     dartEntry.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
-    return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source, dartEntry.modificationTime, tokenStream, dartEntry.getValue(SourceEntry.LINE_INFO)), false);
+    return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source, tokenStream, dartEntry.getValue(SourceEntry.LINE_INFO)), false);
   }
 
   /**
    * Create a [ParseHtmlTask] for the given source, marking the parse errors as being
    * in-process.
    *
    * @param source the source whose content is to be parsed
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createParseHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, htmlEntry);
     }
     String content = htmlEntry.getValue(SourceEntry.CONTENT);
     htmlEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     htmlEntry.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
-    return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, htmlEntry.modificationTime, content), false);
+    return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, content), false);
   }
 
   /**
    * Create a [PolymerBuildHtmlTask] for the given source, marking the Polymer elements as
    * being in-process.
    *
    * @param source the source whose content is to be processed
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createPolymerBuildHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     htmlEntry.setState(HtmlEntry.POLYMER_BUILD_ERRORS, CacheState.IN_PROCESS);
-    return new AnalysisContextImpl_TaskData(new PolymerBuildHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
+    return new AnalysisContextImpl_TaskData(new PolymerBuildHtmlTask(this, source, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
    * Create a [PolymerResolveHtmlTask] for the given source, marking the Polymer errors as
    * being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createPolymerResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     htmlEntry.setState(HtmlEntry.POLYMER_RESOLUTION_ERRORS, CacheState.IN_PROCESS);
-    return new AnalysisContextImpl_TaskData(new PolymerResolveHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
+    return new AnalysisContextImpl_TaskData(new PolymerResolveHtmlTask(this, source, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
    * Create a [ResolveAngularComponentTemplateTask] for the given source, marking the angular
    * errors as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createResolveAngularComponentTemplateTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     AngularApplication application = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
     AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
     htmlEntry.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.IN_PROCESS);
-    return new AnalysisContextImpl_TaskData(new ResolveAngularComponentTemplateTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT), component, application), false);
+    return new AnalysisContextImpl_TaskData(new ResolveAngularComponentTemplateTask(this, source, htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT), component, application), false);
   }
 
   /**
    * Create a [ResolveAngularEntryHtmlTask] for the given source, marking the angular entry as
    * being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createResolveAngularEntryHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     htmlEntry.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.IN_PROCESS);
-    return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
+    return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source, htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
    * Create a [ResolveDartLibraryTask] for the given source, marking ? as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createResolveDartLibraryTask(Source source, DartEntry dartEntry) {
@@ skipping 36 matching lines @@
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createScanDartTask(Source source, DartEntry dartEntry) {
     if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, dartEntry);
     }
     String content = dartEntry.getValue(SourceEntry.CONTENT);
     dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     dartEntry.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS);
-    return new AnalysisContextImpl_TaskData(new ScanDartTask(this, source, dartEntry.modificationTime, content), false);
+    return new AnalysisContextImpl_TaskData(new ScanDartTask(this, source, content), false);
   }
 
   /**
    * Create a source information object suitable for the given source. Return the source information
    * object that was created, or `null` if the source should not be tracked by this context.
    *
    * @param source the source for which an information object is being created
    * @param explicitlyAdded `true` if the source was explicitly added to the context
    * @return the source information object that was created
    */
@@ skipping 1127 matching lines @@
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
   DartEntry _recordGenerateDartHintsTask(GenerateDartHintsTask task) {
     Source librarySource = task.libraryElement.source;
     CaughtException thrownException = task.exception;
     DartEntry libraryEntry = null;
-    HashMap<Source, TimestampedData<List<AnalysisError>>> hintMap = task.hintMap;
+    HashMap<Source, List<AnalysisError>> hintMap = task.hintMap;
     if (hintMap == null) {
       // We don't have any information about which sources to mark as invalid
       // other than the library source.
       DartEntry libraryEntry = _cache.get(librarySource);
       if (thrownException == null) {
         String message = "GenerateDartHintsTask returned a null hint map "
             "without throwing an exception: ${librarySource.fullName}";
         thrownException = new CaughtException(new AnalysisException(message), null);
       }
       libraryEntry.recordHintErrorInLibrary(librarySource, thrownException);
       throw new AnalysisException('<rethrow>', thrownException);
     }
-    hintMap.forEach((Source unitSource, TimestampedData<List<AnalysisError>> results) {
+    hintMap.forEach((Source unitSource, List<AnalysisError> hints) {
       DartEntry dartEntry = _cache.get(unitSource);
       if (unitSource == librarySource) {
         libraryEntry = dartEntry;
       }
       if (thrownException == null) {
-        dartEntry.setValueInLibrary(DartEntry.HINTS, librarySource, results.data);
+        dartEntry.setValueInLibrary(DartEntry.HINTS, librarySource, hints);
         ChangeNoticeImpl notice = _getNotice(unitSource);
         LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO);
         notice.setErrors(dartEntry.allErrors, lineInfo);
       } else {
         dartEntry.recordHintErrorInLibrary(librarySource, thrownException);
       }
     });
     if (thrownException != null) {
       throw new AnalysisException('<rethrow>', thrownException);
     }
@@ skipping 850 matching lines @@
    */
   void _computePartsInLibrary(CycleBuilder_LibraryPair libraryPair) {
     ResolvableLibrary library = libraryPair.library;
     List<CycleBuilder_SourceEntryPair> entryPairs = libraryPair.entryPairs;
     int count = entryPairs.length;
     List<ResolvableCompilationUnit> units = new List<ResolvableCompilationUnit>(count);
     for (int i = 0; i < count; i++) {
       CycleBuilder_SourceEntryPair entryPair = entryPairs[i];
       Source source = entryPair.source;
       DartEntry dartEntry = entryPair.entry;
-      units[i] = new ResolvableCompilationUnit.con2(dartEntry.modificationTime, dartEntry.resolvableCompilationUnit, source);
+      units[i] = new ResolvableCompilationUnit(source, dartEntry.resolvableCompilationUnit);
     }
     library.resolvableCompilationUnits = units;
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation
    * unit with the given source.
    *
    * @param librarySource the source of the library's defining compilation unit
    * @return the library object that was created
@@ skipping 4439 matching lines @@
     StringLiteral uriLiteral = directive.uri;
     errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [directive.uriContent]));
   }
 
   /**
    * The source for which errors and warnings are to be produced.
    */
   final Source source;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  final int modificationTime;
-
-  /**
    * The compilation unit used to resolve the dependencies.
    */
   final CompilationUnit _unit;
 
   /**
    * The element model for the library containing the source.
    */
   final LibraryElement libraryElement;
 
   /**
    * The errors that were generated for the source.
    */
   List<AnalysisError> _errors;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source for which errors and warnings are to be produced
-   * @param modificationTime the time at which the contents of the source were last modified
    * @param unit the compilation unit used to resolve the dependencies
    * @param libraryElement the element model for the library containing the source
    */
-  GenerateDartErrorsTask(InternalAnalysisContext context, this.source, this.modificationTime, this._unit, this.libraryElement) : super(context);
+  GenerateDartErrorsTask(InternalAnalysisContext context, this.source, this._unit, this.libraryElement) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartErrorsTask(this);
 
   /**
    * Return the errors that were generated for the source.
    *
    * @return the errors that were generated for the source
    */
   List<AnalysisError> get errors => _errors;
@@ skipping 39 matching lines @@
    * first in the array.
    */
   final List<TimestampedData<CompilationUnit>> _units;
 
   /**
    * The element model for the library being analyzed.
    */
   final LibraryElement libraryElement;
 
   /**
-   * A table mapping the sources that were analyzed to the hints that were generated for the
-   * sources.
+   * A table mapping the sources that were analyzed to the hints that were
+   * generated for the sources.
    */
-  HashMap<Source, TimestampedData<List<AnalysisError>>> _hintMap;
+  HashMap<Source, List<AnalysisError>> _hintMap;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param units the compilation units that comprise the library, with the defining compilation
    *          unit appearing first in the array
    * @param libraryElement the element model for the library being analyzed
    */
   GenerateDartHintsTask(InternalAnalysisContext context, this._units, this.libraryElement) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartHintsTask(this);
 
   /**
    * Return a table mapping the sources that were analyzed to the hints that were generated for the
    * sources, or `null` if the task has not been performed or if the analysis did not complete
    * normally.
    *
    * @return a table mapping the sources that were analyzed to the hints that were generated for the
    *         sources
    */
-  HashMap<Source, TimestampedData<List<AnalysisError>>> get hintMap => _hintMap;
+  HashMap<Source, List<AnalysisError>> get hintMap => _hintMap;
 
   @override
   String get taskDescription {
     Source librarySource = libraryElement.source;
     if (librarySource == null) {
       return "generate Dart hints for library without source";
     }
     return "generate Dart hints for ${librarySource.fullName}";
   }
 
   @override
   void internalPerform() {
     //
     // Gather the compilation units.
     //
     int unitCount = _units.length;
     List<CompilationUnit> compilationUnits = new List<CompilationUnit>(unitCount);
     for (int i = 0; i < unitCount; i++) {
       compilationUnits[i] = _units[i].data;
     }
     //
     // Analyze all of the units.
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     HintGenerator hintGenerator = new HintGenerator(compilationUnits, context, errorListener);
     hintGenerator.generateForLibrary();
     //
     // Store the results.
     //
-    _hintMap = new HashMap<Source, TimestampedData<List<AnalysisError>>>();
+    _hintMap = new HashMap<Source, List<AnalysisError>>();
     for (int i = 0; i < unitCount; i++) {
-      int modificationTime = _units[i].modificationTime;
       Source source = _units[i].data.element.source;
-      List<AnalysisError> errors = errorListener.getErrorsForSource(source);
-      _hintMap[source] = new TimestampedData<List<AnalysisError>>(modificationTime, errors);
+      _hintMap[source] = errorListener.getErrorsForSource(source);
     }
   }
 }
 
 /**
  * Instances of the class `GetContentTask` get the contents of a source.
  */
 class GetContentTask extends AnalysisTask {
   /**
    * The source to be read.
@@ skipping 1119 matching lines @@
       return _basis.computeLineInfo(source);
     } on AnalysisException catch (e, stackTrace) {
       _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
-  ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) => _basis.computeResolvableCompilationUnit(source);
+  CompilationUnit computeResolvableCompilationUnit(Source source)
+      => _basis.computeResolvableCompilationUnit(source);
 
   @override
   void dispose() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-dispose");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.dispose();
     } finally {
       instrumentation.log();
@@ skipping 605 matching lines @@
    * Return an AST structure corresponding to the given source, but ensure that the structure has
    * not already been resolved and will not be resolved by any other threads or in any other
    * library.
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the compilation unit for which an AST structure should be returned
    * @return the AST structure representing the content of the source
    * @throws AnalysisException if the analysis could not be performed
    */
-  ResolvableCompilationUnit computeResolvableCompilationUnit(Source source);
+  CompilationUnit computeResolvableCompilationUnit(Source source);
 
   /**
    * Return context that owns the given source.
    *
    * @param source the source whose context is to be returned
    * @return the context that owns the partition that contains the source
    */
   InternalAnalysisContext getContextFor(Source source);
 
   /**
@@ skipping 413 matching lines @@
     }
     throw new RuntimeException(message: "Failed to handle validation code: ${code}");
   }
 
   /**
    * The source to be parsed.
    */
   final Source source;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  final int modificationTime;
-
-  /**
    * The head of the token stream used for parsing.
    */
   final Token _tokenStream;
 
   /**
    * The line information associated with the source.
    */
   final LineInfo lineInfo;
 
   /**
@@ skipping 29 matching lines @@
   /**
    * The errors that were produced by scanning and parsing the source.
    */
   List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
-   * @param modificationTime the time at which the contents of the source were last modified
    * @param tokenStream the head of the token stream used for parsing
    * @param lineInfo the line information associated with the source
    */
-  ParseDartTask(InternalAnalysisContext context, this.source, this.modificationTime, this._tokenStream, this.lineInfo) : super(context);
+  ParseDartTask(InternalAnalysisContext context, this.source, this._tokenStream, this.lineInfo) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseDartTask(this);
 
   /**
    * Return the compilation unit that was produced by parsing the source, or `null` if the
    * task has not yet been performed or if an exception occurred.
    *
    * @return the compilation unit that was produced by parsing the source
    */
@@ skipping 119 matching lines @@
 /**
  * Instances of the class `ParseHtmlTask` parse a specific source as an HTML file.
  */
 class ParseHtmlTask extends AnalysisTask {
   /**
    * The source to be parsed.
    */
   final Source source;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  final int modificationTime;
-
-  /**
    * The contents of the source.
    */
   final String _content;
 
   /**
    * The line information that was produced.
    */
   LineInfo _lineInfo;
 
   /**
@@ skipping 19 matching lines @@
   /**
    * The name of the 'script' tag in an HTML file.
    */
   static String _TAG_SCRIPT = "script";
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
-   * @param modificationTime the time at which the contents of the source were last modified
    * @param content the contents of the source
    */
-  ParseHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, this._content) : super(context);
+  ParseHtmlTask(InternalAnalysisContext context, this.source, this._content) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseHtmlTask(this);
 
   /**
    * Return the errors that were produced by scanning and parsing the source, or `null` if the
    * task has not yet been performed or if an exception occurred.
    *
    * @return the errors that were produced by scanning and parsing the source
    */
@@ skipping 176 matching lines @@
 /**
  * Instances of the class `PolymerBuildHtmlTask` build Polymer specific elements.
  */
 class PolymerBuildHtmlTask extends AnalysisTask {
   /**
    * The source to build which Polymer HTML elements for.
    */
   final Source source;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  final int modificationTime;
-
-  /**
    * The line information associated with the source.
    */
   final LineInfo _lineInfo;
 
   /**
    * The HTML unit to be resolved.
    */
   final ht.HtmlUnit _unit;
 
   /**
    * The resolution errors that were discovered while building elements.
    */
   List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be resolved
-   * @param modificationTime the time at which the contents of the source were last modified
    * @param lineInfo the line information associated with the source
    * @param unit the HTML unit to build Polymer elements for
    */
-  PolymerBuildHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, this._lineInfo, this._unit) : super(context);
+  PolymerBuildHtmlTask(InternalAnalysisContext context, this.source, this._lineInfo, this._unit) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitPolymerBuildHtmlTask(this);
 
   List<AnalysisError> get errors => _errors;
 
   @override
   String get taskDescription => "build Polymer elements ${source.fullName}";
 
   @override
@@ skipping 389 matching lines @@
  *
  * TODO(scheglov) implement it
  */
 class PolymerResolveHtmlTask extends AnalysisTask {
   /**
    * The source to be resolved.
    */
   final Source source;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  final int modificationTime;
-
-  /**
    * The line information associated with the source.
    */
   final LineInfo _lineInfo;
 
   /**
    * The HTML unit to be resolved.
    */
   final ht.HtmlUnit _unit;
 
   /**
    * The resolution errors that were discovered while resolving the source.
    */
   List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be resolved
-   * @param modificationTime the time at which the contents of the source were last modified
    * @param unit the HTML unit to be resolved
    */
-  PolymerResolveHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, this._lineInfo, this._unit) : super(context);
+  PolymerResolveHtmlTask(InternalAnalysisContext context, this.source, this._lineInfo, this._unit) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitPolymerResolveHtmlTask(this);
 
   List<AnalysisError> get errors => _errors;
 
   @override
   String get taskDescription => "resolve as Polymer ${source.fullName}";
 
   @override
@@ skipping 556 matching lines @@
       builder.append(oldState);
       builder.append(" -> ");
       builder.append(newState);
       return true;
     }
     return needsSeparator;
   }
 }
 
 /**
- * Instances of the class `ResolvableCompilationUnit` represent a compilation unit that is not
- * referenced by any other objects and for which we have modification stamp information. It is used
- * by the [LibraryResolver] to resolve a library.
+ * A `ResolvableCompilationUnit` is a compilation unit that is not referenced by
+ * any other objects. It is used by the [LibraryResolver] to resolve a library.
  */
-class ResolvableCompilationUnit extends TimestampedData<CompilationUnit> {
+class ResolvableCompilationUnit {
   /**
    * The source of the compilation unit.
    */
   final Source source;
 
   /**
-   * Initialize a newly created holder to hold the given values.
-   *
-   * @param modificationTime the modification time of the source from which the AST was created
-   * @param unit the AST that was created from the source
+   * The compilation unit.
    */
-  ResolvableCompilationUnit.con1(int modificationTime, CompilationUnit unit) : this.con2(modificationTime, unit, null);
+  final CompilationUnit compilationUnit;
 
   /**
    * Initialize a newly created holder to hold the given values.
    *
-   * @param modificationTime the modification time of the source from which the AST was created
+   * @param source the source of the compilation unit
    * @param unit the AST that was created from the source
-   * @param source the source of the compilation unit
    */
-  ResolvableCompilationUnit.con2(int modificationTime, CompilationUnit unit, this.source) : super(modificationTime, unit);
-
-  /**
-   * Return the AST that was created from the source.
-   *
-   * @return the AST that was created from the source
-   */
-  CompilationUnit get compilationUnit => data;
+  ResolvableCompilationUnit(this.source, this.compilationUnit);
 }
 
 /**
- * Instances of the class `ResolvableHtmlUnit` represent an HTML unit that is not referenced
- * by any other objects and for which we have modification stamp information. It is used by the
- * [ResolveHtmlTask] to resolve an HTML source.
- */
-class ResolvableHtmlUnit extends TimestampedData<ht.HtmlUnit> {
-  /**
-   * Initialize a newly created holder to hold the given values.
-   *
-   * @param modificationTime the modification time of the source from which the AST was created
-   * @param unit the AST that was created from the source
-   */
-  ResolvableHtmlUnit(int modificationTime, ht.HtmlUnit unit) : super(modificationTime, unit);
-
-  /**
-   * Return the AST that was created from the source.
-   *
-   * @return the AST that was created from the source
-   */
-  ht.HtmlUnit get compilationUnit => data;
-}
-
-/**
  * Instances of the class `ResolveAngularComponentTemplateTask` resolve HTML template
  * referenced by [AngularComponentElement].
  */
 class ResolveAngularComponentTemplateTask extends AnalysisTask {
   /**
    * The source to be resolved.
    */
   final Source source;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  final int modificationTime;
-
-  /**
    * The HTML unit to be resolved.
    */
   final ht.HtmlUnit _unit;
 
   /**
    * The [AngularComponentElement] to resolve template for.
    */
   final AngularComponentElement _component;
 
   /**
    * The Angular application to resolve in context of.
    */
   final AngularApplication _application;
 
   /**
    * The [HtmlUnit] that was resolved by this task.
    */
   ht.HtmlUnit _resolvedUnit;
 
   /**
    * The resolution errors that were discovered while resolving the source.
    */
   List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be resolved
-   * @param modificationTime the time at which the contents of the source were last modified
    * @param unit the HTML unit to be resolved
    * @param component the component that uses this HTML template, not `null`
    * @param application the Angular application to resolve in context of
    */
-  ResolveAngularComponentTemplateTask(InternalAnalysisContext context, this.source, this.modificationTime, this._unit, this._component, this._application) : super(context);
+  ResolveAngularComponentTemplateTask(InternalAnalysisContext context, this.source, this._unit, this._component, this._application) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveAngularComponentTemplateTask(this);
 
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
 
   /**
    * Return the [HtmlUnit] that was resolved by this task.
    *
    * @return the [HtmlUnit] that was resolved by this task
@@ skipping 29 matching lines @@
  * Instances of the class `ResolveAngularEntryHtmlTask` resolve a specific HTML file as an
  * Angular entry point.
  */
 class ResolveAngularEntryHtmlTask extends AnalysisTask {
   /**
    * The source to be resolved.
    */
   final Source source;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  final int modificationTime;
-
-  /**
    * The HTML unit to be resolved.
    */
   final ht.HtmlUnit _unit;
 
   /**
    * The listener to record errors.
    */
   RecordingErrorListener _errorListener = new RecordingErrorListener();
 
   /**
    * The [HtmlUnit] that was resolved by this task.
    */
   ht.HtmlUnit _resolvedUnit;
 
   /**
    * The element produced by resolving the source.
    */
   HtmlElement _element = null;
 
   /**
    * The Angular application to resolve in context of.
    */
   AngularApplication _application;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be resolved
-   * @param modificationTime the time at which the contents of the source were last modified
    * @param unit the HTML unit to be resolved
    */
-  ResolveAngularEntryHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, this._unit) : super(context);
+  ResolveAngularEntryHtmlTask(InternalAnalysisContext context, this.source, this._unit) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveAngularEntryHtmlTask(this);
 
   /**
    * Returns the [AngularApplication] for the Web application with this Angular entry point,
    * maybe `null` if not an Angular entry point.
    */
   AngularApplication get application => _application;
 
@@ skipping 170 matching lines @@
    * The source that is to be resolved.
    */
   final Source source;
 
   /**
    * The element model for the library containing the source.
    */
   final LibraryElement _libraryElement;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  int _modificationTime = -1;
-
-  /**
    * The compilation unit that was resolved by this task.
    */
   CompilationUnit _resolvedUnit;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param libraryElement the element model for the library containing the source
    */
   ResolveDartUnitTask(InternalAnalysisContext context, this.source, this._libraryElement) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartUnitTask(this);
 
   /**
    * Return the source for the library containing the source that is to be resolved.
    *
    * @return the source for the library containing the source that is to be resolved
    */
   Source get librarySource => _libraryElement.source;
 
   /**
-   * Return the time at which the contents of the source that was parsed were last modified, or a
-   * negative value if the task has not yet been performed or if an exception occurred.
-   *
-   * @return the time at which the contents of the source that was parsed were last modified
-   */
-  int get modificationTime => _modificationTime;
-
-  /**
    * Return the compilation unit that was resolved by this task.
    *
    * @return the compilation unit that was resolved by this task
    */
   CompilationUnit get resolvedUnit => _resolvedUnit;
 
   @override
   String get taskDescription {
     Source librarySource = _libraryElement.source;
     if (librarySource == null) {
       return "resolve unit null source";
     }
     return "resolve unit ${librarySource.fullName}";
   }
 
   @override
   void internalPerform() {
     TypeProvider typeProvider = (_libraryElement.context as InternalAnalysisContext).typeProvider;
-    ResolvableCompilationUnit resolvableUnit = context.computeResolvableCompilationUnit(source);
-    _modificationTime = resolvableUnit.modificationTime;
-    CompilationUnit unit = resolvableUnit.compilationUnit;
+    CompilationUnit unit = context.computeResolvableCompilationUnit(source);
     if (unit == null) {
       throw new AnalysisException("Internal error: computeResolvableCompilationUnit returned a value without a parsed Dart unit");
     }
     //
     // Resolve names in declarations.
     //
     new DeclarationResolver().resolve(unit, _find(_libraryElement, source));
     //
     // Resolve the type names.
     //
@@ skipping 169 matching lines @@
 /**
  * Instances of the class `ScanDartTask` scan a specific source as a Dart file.
  */
 class ScanDartTask extends AnalysisTask {
   /**
    * The source to be scanned.
    */
   final Source source;
 
   /**
-   * The time at which the contents of the source were last modified.
-   */
-  final int modificationTime;
-
-  /**
    * The contents of the source.
    */
   final String _content;
 
   /**
    * The token stream that was produced by scanning the source.
    */
   Token _tokenStream;
 
   /**
    * The line information that was produced.
    */
   LineInfo _lineInfo;
 
   /**
    * The errors that were produced by scanning the source.
    */
   List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
-   * @param modificationTime the time at which the contents of the source were last modified
    * @param content the contents of the source
    */
-  ScanDartTask(InternalAnalysisContext context, this.source, this.modificationTime, this._content) : super(context);
+  ScanDartTask(InternalAnalysisContext context, this.source, this._content) : super(context);
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitScanDartTask(this);
 
   /**
    * Return the errors that were produced by scanning the source, or `null` if the task has
    * not yet been performed or if an exception occurred.
    *
    * @return the errors that were produced by scanning the source
    */
@@ skipping 772 matching lines @@
     _index++;
     if (_index >= _manager._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < _manager._workQueues.length && _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }