Record dependencies and invalidate results.

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 87 matching lines @@
   TaskManager _taskManager;
 
   /**
    * The analysis driver used to perform analysis.
    */
   AnalysisDriver _driver;
 
   /**
    * A list containing sources for which data should not be flushed.
    */
-  List<Source> _priorityOrder = Source.EMPTY_ARRAY;
+  List<Source> _priorityOrder = <Source>[];
 
   /**
    * A map from all sources for which there are futures pending to a list of
    * the corresponding PendingFuture objects.  These sources will be analyzed
    * in the same way as priority sources, except with higher priority.
    */
   HashMap<AnalysisTarget, List<PendingFuture>> _pendingFutureTargets =
       new HashMap<AnalysisTarget, List<PendingFuture>>();
 
   /**
@@ skipping 833 matching lines @@
     bool changed = newContents != originalContents;
     if (newContents != null) {
       if (newContents != originalContents) {
         _incrementalAnalysisCache =
             IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         if (!analysisOptions.incremental ||
             !_tryPoorMansIncrementalResolution(source, newContents)) {
           _sourceChanged(source);
         }
         entry.modificationTime = _contentCache.getModificationStamp(source);
-        entry.setValue(CONTENT, newContents);
+        entry.setValue(CONTENT, newContents, cache.TargetedResult.EMPTY_LIST);
       } else {
         entry.modificationTime = _contentCache.getModificationStamp(source);
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache =
           IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       changed = newContents != originalContents;
       // We are removing the overlay for the file, check if the file's
       // contents is the same as it was in the overlay.
       try {
         TimestampedData<String> fileContents = getContents(source);
         String fileContentsData = fileContents.data;
         if (fileContentsData == originalContents) {
-          entry.setValue(CONTENT, fileContentsData);
+          entry.setValue(
+              CONTENT, fileContentsData, cache.TargetedResult.EMPTY_LIST);
           entry.modificationTime = fileContents.modificationTime;
           changed = false;
         }
       } catch (e) {}
       // If not the same content (e.g. the file is being closed without save),
       // then force analysis.
       if (changed) {
         _sourceChanged(source);
       }
     }
@@ skipping 71 matching lines @@
     });
   }
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     elementMap.forEach((Source librarySource, LibraryElement library) {
       //
       // Cache the element in the library's info.
       //
       cache.CacheEntry entry = getCacheEntry(librarySource);
-      entry.setValue(BUILD_DIRECTIVES_ERRORS, AnalysisError.NO_ERRORS);
-      entry.setValue(
-          BUILD_FUNCTION_TYPE_ALIASES_ERRORS, AnalysisError.NO_ERRORS);
-      entry.setValue(BUILD_LIBRARY_ERRORS, AnalysisError.NO_ERRORS);
+      setValue(ResultDescriptor result, value) {
+        entry.setValue(result, value, cache.TargetedResult.EMPTY_LIST);
+      }
+      setValue(BUILD_DIRECTIVES_ERRORS, AnalysisError.NO_ERRORS);
+      setValue(BUILD_FUNCTION_TYPE_ALIASES_ERRORS, AnalysisError.NO_ERRORS);
+      setValue(BUILD_LIBRARY_ERRORS, AnalysisError.NO_ERRORS);
       // CLASS_ELEMENTS
-      entry.setValue(COMPILATION_UNIT_ELEMENT, library.definingCompilationUnit);
+      setValue(COMPILATION_UNIT_ELEMENT, library.definingCompilationUnit);
       // CONSTRUCTORS
       // CONSTRUCTORS_ERRORS
       entry.setState(CONTENT, CacheState.FLUSHED);
-      entry.setValue(EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+      setValue(EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
       // EXPORT_SOURCE_CLOSURE
-      entry.setValue(IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+      setValue(IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
       // IMPORT_SOURCE_CLOSURE
-      entry.setValue(INCLUDED_PARTS, Source.EMPTY_ARRAY);
-      entry.setValue(IS_CLIENT, true);
-      entry.setValue(IS_LAUNCHABLE, false);
-      entry.setValue(LIBRARY_ELEMENT, library);
-      entry.setValue(LIBRARY_ELEMENT1, library);
-      entry.setValue(LIBRARY_ELEMENT2, library);
-      entry.setValue(LIBRARY_ELEMENT3, library);
-      entry.setValue(LIBRARY_ELEMENT4, library);
-      entry.setValue(LIBRARY_ELEMENT5, library);
-      entry.setValue(LINE_INFO, new LineInfo(<int>[0]));
-      entry.setValue(PARSE_ERRORS, AnalysisError.NO_ERRORS);
+      setValue(INCLUDED_PARTS, Source.EMPTY_ARRAY);
+      setValue(IS_CLIENT, true);
+      setValue(IS_LAUNCHABLE, false);
+      setValue(LIBRARY_ELEMENT, library);
+      setValue(LIBRARY_ELEMENT1, library);
+      setValue(LIBRARY_ELEMENT2, library);
+      setValue(LIBRARY_ELEMENT3, library);
+      setValue(LIBRARY_ELEMENT4, library);
+      setValue(LIBRARY_ELEMENT5, library);
+      setValue(LINE_INFO, new LineInfo(<int>[0]));
+      setValue(PARSE_ERRORS, AnalysisError.NO_ERRORS);
       entry.setState(PARSED_UNIT, CacheState.FLUSHED);
       entry.setState(RESOLVE_TYPE_NAMES_ERRORS, CacheState.FLUSHED);
-      entry.setValue(SCAN_ERRORS, AnalysisError.NO_ERRORS);
-      entry.setValue(SOURCE_KIND, SourceKind.LIBRARY);
+      setValue(SCAN_ERRORS, AnalysisError.NO_ERRORS);
+      setValue(SOURCE_KIND, SourceKind.LIBRARY);
       entry.setState(TOKEN_STREAM, CacheState.FLUSHED);
-      entry.setValue(UNITS, <Source>[librarySource]);
+      setValue(UNITS, <Source>[librarySource]);
 
       LibrarySpecificUnit unit =
           new LibrarySpecificUnit(librarySource, librarySource);
       entry = getCacheEntry(unit);
-      entry.setValue(HINTS, AnalysisError.NO_ERRORS);
+      setValue(HINTS, AnalysisError.NO_ERRORS);
       // dartEntry.setValue(LINTS, AnalysisError.NO_ERRORS);
       entry.setState(RESOLVE_REFERENCES_ERRORS, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT1, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT2, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT3, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT4, CacheState.FLUSHED);
       entry.setState(RESOLVED_UNIT5, CacheState.FLUSHED);
       // USED_IMPORTED_ELEMENTS
       // USED_LOCAL_ELEMENTS
-      entry.setValue(VERIFY_ERRORS, AnalysisError.NO_ERRORS);
+      setValue(VERIFY_ERRORS, AnalysisError.NO_ERRORS);
     });
 
     cache.CacheEntry entry = getCacheEntry(AnalysisContextTarget.request);
-    entry.setValue(TYPE_PROVIDER, typeProvider);
+    entry.setValue(
+        TYPE_PROVIDER, typeProvider, cache.TargetedResult.EMPTY_LIST);
   }
 
   @override
   void removeListener(AnalysisListener listener) {
     _listeners.remove(listener);
   }
 
   @override
   CompilationUnit resolveCompilationUnit(
       Source unitSource, LibraryElement library) {
@@ skipping 223 matching lines @@
 //        if (_options.incremental) {
 //          _incrementalAnalysisCache = IncrementalAnalysisCache.update(
 //              _incrementalAnalysisCache, source, originalContents, contents,
 //              offset, oldLength, newLength, _cache.get(source));
 //        }
         _sourceChanged(source);
         changed = true;
         cache.CacheEntry entry = _cache.get(source);
         if (entry != null) {
           entry.modificationTime = _contentCache.getModificationStamp(source);
-          entry.setValue(CONTENT, contents);
+          entry.setValue(CONTENT, contents, cache.TargetedResult.EMPTY_LIST);
         }
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache =
           IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       _sourceChanged(source);
       changed = true;
     }
     return changed;
   }
@@ skipping 763 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }