Progress toward new AnalysisContextImpl

pkg/analyzer/lib/src/context/context.dart

 // Copyright (c) 2015, 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.
 
 library analyzer.src.context.context;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/cancelable_future.dart';
@@ skipping 530 matching lines @@
   @override
   List<Source> computeExportedLibraries(Source source) =>
       _computeResult(source, EXPORTED_LIBRARIES);
 
   @override
   // TODO(brianwilkerson) Implement this.
   HtmlElement computeHtmlElement(Source source) => null;
 
   @override
   List<Source> computeImportedLibraries(Source source) =>
-      _computeResult(source, IMPORTED_LIBRARIES);
+      _computeResult(source, EXPLICITLY_IMPORTED_LIBRARIES);
 
   @override
   SourceKind computeKindOf(Source source) {
     String name = source.shortName;
     if (AnalysisEngine.isDartFileName(name)) {
       return _computeResult(source, SOURCE_KIND);
     } else if (AnalysisEngine.isHtmlFileName(name)) {
       return SourceKind.HTML;
     }
     return SourceKind.UNKNOWN;
@@ skipping 846 matching lines @@
    */
   cache.CacheEntry _createCacheEntry(Source source, bool explicitlyAdded) {
     cache.CacheEntry entry = new cache.CacheEntry(source);
     entry.modificationTime = getModificationStamp(source);
     entry.explicitlyAdded = explicitlyAdded;
     _cache.put(entry);
     return entry;
   }
 
   /**
+   * Return a list containing all of the cache entries for targets associated
+   * with the given [source].
+   */
+  List<cache.CacheEntry> _entriesFor(Source source) {
+    List<cache.CacheEntry> entries = <cache.CacheEntry>[];
+    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+    while (iterator.moveNext()) {
+      if (iterator.key.source == source) {
+        entries.add(iterator.value);
+      }
+    }
+    return entries;
+  }
+
+  /**
    * Return a list containing all of the change notices that are waiting to be
    * returned. If there are no notices, then return either `null` or an empty
    * list, depending on the value of [nullIfEmpty].
    */
   List<ChangeNotice> _getChangeNotices(bool nullIfEmpty) {
     if (_pendingNotices.isEmpty) {
       if (nullIfEmpty) {
         return null;
       }
       return ChangeNoticeImpl.EMPTY_LIST;
@@ skipping 316 matching lines @@
       return;
     }
     // Check whether the content of the source is the same as it was the last
     // time.
     String sourceContent = entry.getValue(CONTENT);
     if (sourceContent != null) {
       entry.setState(CONTENT, CacheState.FLUSHED);
       try {
         TimestampedData<String> fileContents = getContents(source);
         if (fileContents.data == sourceContent) {
+          int time = fileContents.modificationTime;
+          for (cache.CacheEntry entry in _entriesFor(source)) {
+            entry.modificationTime = time;
+          }
           return;
         }
       } catch (e) {}
     }
     // We need to invalidate the cache.
     // TODO(brianwilkerson) Implement this.
 //    _propagateInvalidation(source, entry);
   }
 
   /**
@@ skipping 114 matching lines @@
   }
 
   /**
    * Check the cache for any invalid entries (entries whose modification time
    * does not match the modification time of the source associated with the
    * entry). Invalid entries will be marked as invalid so that the source will
    * be re-analyzed. Return `true` if at least one entry was invalid.
    */
   bool _validateCacheConsistency() {
     int consistencyCheckStart = JavaSystem.nanoTime();
-    List<AnalysisTarget> changedTargets = new List<AnalysisTarget>();
-    List<AnalysisTarget> missingTargets = new List<AnalysisTarget>();
+    HashSet<Source> changedSources = new HashSet<Source>();
+    HashSet<Source> missingSources = new HashSet<Source>();
     MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
-      AnalysisTarget target = iterator.key;
-      cache.CacheEntry entry = iterator.value;
-      if (target is Source) {
-        int sourceTime = getModificationStamp(target);
+      Source source = iterator.key.source;
+      if (source != null) {
+        cache.CacheEntry entry = iterator.value;
+        int sourceTime = getModificationStamp(source);
         if (sourceTime != entry.modificationTime) {
-          changedTargets.add(target);
+          changedSources.add(source);
         }
-      }
-      if (entry.exception != null) {
-        if (!exists(target)) {
-          missingTargets.add(target);
+        if (entry.exception != null) {
+          if (!exists(source)) {
+            missingSources.add(source);
+          }
         }
       }
     }
-    int count = changedTargets.length;
-    for (int i = 0; i < count; i++) {
-      _sourceChanged(changedTargets[i]);
+    for (Source source in changedSources) {
+      _sourceChanged(source);
     }
     int removalCount = 0;
-    for (AnalysisTarget target in missingTargets) {
-      if (target is Source &&
-          getLibrariesContaining(target).isEmpty &&
-          getLibrariesDependingOn(target).isEmpty) {
-        _cache.remove(target);
+    for (Source source in missingSources) {
+      if (getLibrariesContaining(source).isEmpty &&
+          getLibrariesDependingOn(source).isEmpty) {
+        _cache.remove(source);
         removalCount++;
       }
     }
     int consistencyCheckEnd = JavaSystem.nanoTime();
-    if (changedTargets.length > 0 || missingTargets.length > 0) {
+    if (changedSources.length > 0 || missingSources.length > 0) {
       StringBuffer buffer = new StringBuffer();
       buffer.write("Consistency check took ");
       buffer.write((consistencyCheckEnd - consistencyCheckStart) / 1000000.0);
       buffer.writeln(" ms and found");
       buffer.write("  ");
-      buffer.write(changedTargets.length);
+      buffer.write(changedSources.length);
       buffer.writeln(" inconsistent entries");
       buffer.write("  ");
-      buffer.write(missingTargets.length);
+      buffer.write(missingSources.length);
       buffer.write(" missing sources (");
       buffer.write(removalCount);
       buffer.writeln(" removed");
-      for (Source source in missingTargets) {
+      for (Source source in missingSources) {
         buffer.write("    ");
         buffer.writeln(source.fullName);
       }
       _logInformation(buffer.toString());
     }
-    return changedTargets.length > 0;
+    return changedSources.length > 0;
   }
 }
 
 /**
  * An object that manages the partitions that can be shared between analysis
  * contexts.
  */
 class PartitionManager {
   /**
    * A table mapping SDK's to the partitions used for those SDK's.
@@ skipping 149 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }