Invalidate hints instead of computing them in the incremental resolver.

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:math" as math;
@@ skipping 2235 matching lines @@
         _sourceChanged(source);
       }
     }
     if (notify && changed) {
       _onSourcesChangedController.add(
           new SourcesChangedEvent.changedContent(source, newContents));
     }
     return changed;
   }
 
+  /**
+   * Invalidates hints in the given [librarySource] and included parts.
+   */
+  void invalidateLibraryHints(Source librarySource) {
+    SourceEntry sourceEntry = _cache.get(librarySource);
+    if (sourceEntry is! DartEntry) {
+      return;
+    }
+    DartEntry dartEntry = sourceEntry;
+    // Prepare sources to invalidate hints in.
+    List<Source> sources = <Source>[librarySource];
+    sources.addAll(dartEntry.getValue(DartEntry.INCLUDED_PARTS));
+    // Invalidate hints.
+    for (Source source in sources) {
+      DartEntry dartEntry = _cache.get(source);
+      if (dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource) ==
+          CacheState.VALID) {
+        dartEntry.setStateInLibrary(
+            DartEntry.HINTS,
+            librarySource,
+            CacheState.INVALID);
+      }
+    }
+  }
+
   @override
   bool isClientLibrary(Source librarySource) {
     SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return dartEntry.getValue(DartEntry.IS_CLIENT) &&
           dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
@@ skipping 2797 matching lines @@
     List<Source> librarySources = getLibrariesContaining(unitSource);
     if (librarySources.length != 1) {
       return false;
     }
     Source librarySource = librarySources[0];
     // prepare the library element
     LibraryElement libraryElement = getLibraryElement(librarySource);
     if (libraryElement == null) {
       return false;
     }
-    // prepare the existing library units
-    Map<Source, CompilationUnit> units = <Source, CompilationUnit>{};
-    for (CompilationUnitElement unitElement in libraryElement.units) {
-      Source unitSource = unitElement.source;
-      CompilationUnit unit =
-          getResolvedCompilationUnit2(unitSource, librarySource);
-      if (unit == null) {
-        return false;
-      }
-      units[unitSource] = unit;
-    }
     // prepare the existing unit
-    CompilationUnit oldUnit = units[unitSource];
+    CompilationUnit oldUnit =
+        getResolvedCompilationUnit2(unitSource, librarySource);
     if (oldUnit == null) {
       return false;
     }
     // do resolution
     Stopwatch perfCounter = new Stopwatch()..start();
     PoorMansIncrementalResolver resolver = new PoorMansIncrementalResolver(
         typeProvider,
-        units,
         unitSource,
         dartEntry,
+        oldUnit,
         analysisOptions.incrementalApi);
     bool success = resolver.resolve(newCode);
     AnalysisEngine.instance.instrumentationService.logPerformance(
         AnalysisPerformanceKind.INCREMENTAL,
         perfCounter,
         'success=$success,context_id=$_id,code_length=${newCode.length}');
     if (!success) {
       return false;
     }
     // if validation, remember the result, but throw it away
     if (analysisOptions.incrementalValidation) {
       incrementalResolutionValidation_lastUnitSource = oldUnit.element.source;
       incrementalResolutionValidation_lastLibrarySource =
           oldUnit.element.library.source;
       incrementalResolutionValidation_lastUnit = oldUnit;
       return false;
     }
-    // prepare notices
-    units.forEach((Source source, CompilationUnit unit) {
-      DartEntry dartEntry = _cache.get(source);
-      LineInfo lineInfo = getLineInfo(source);
-      ChangeNoticeImpl notice = _getNotice(source);
-      notice.resolvedDartUnit = unit;
+    // prepare notice
+    {
+      LineInfo lineInfo = getLineInfo(unitSource);
+      ChangeNoticeImpl notice = _getNotice(unitSource);
+      notice.resolvedDartUnit = oldUnit;
       notice.setErrors(dartEntry.allErrors, lineInfo);
-    });
+    }
     // OK
     return true;
   }
 
   /**
    * 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.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
@@ skipping 4502 matching lines @@
         cache.offset,
         cache.offset + cache.oldLength);
     // Update the resolution
     TypeProvider typeProvider = this.typeProvider;
     if (_updatedUnit != null && typeProvider != null) {
       CompilationUnitElement element = _updatedUnit.element;
       if (element != null) {
         LibraryElement library = element.library;
         if (library != null) {
           IncrementalResolver resolver = new IncrementalResolver(
-              <Source, CompilationUnit>{},
               element,
               cache.offset,
               cache.oldLength,
               cache.newLength);
           resolver.resolve(parser.updatedNode);
         }
       }
     }
   }
 }
@@ skipping 2701 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }