Send notificatinos after no-op changes.

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 1838 matching lines @@
     _disposed = true;
     for (List<PendingFuture> pendingFutures in _pendingFutureSources.values) {
       for (PendingFuture pendingFuture in pendingFutures) {
         pendingFuture.forciblyComplete();
       }
     }
     _pendingFutureSources.clear();
   }
 
   @override
+  CompilationUnit ensureAnyResolvedDartUnit(Source source) {
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry is! DartEntry) {
+      return null;
+    }
+    DartEntry dartEntry = sourceEntry;
+    // Check if there is a resolved unit.
+    CompilationUnit unit = dartEntry.anyResolvedCompilationUnit;
+    if (unit != null) {
+      return unit;
+    }
+    // Invalidate the flushed RESOLVED_UNIT to force it eventually.
+    bool shouldBeScheduled = false;
+    List<Source> librariesContaining = dartEntry.containingLibraries;
+    for (Source librarySource in librariesContaining) {
+      if (dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) ==
+          CacheState.FLUSHED) {
+        dartEntry.setStateInLibrary(
+            DartEntry.RESOLVED_UNIT,
+            librarySource,
+            CacheState.INVALID);
+        shouldBeScheduled = true;
+      }
+    }
+    if (shouldBeScheduled) {
+      _workManager.add(source, SourcePriority.UNKNOWN);
+    }
+    // We cannot provide a resolved unit right now,
+    // but the future analysis will.
+    return null;
+  }
+
+  @override
   bool exists(Source source) {
     if (source == null) {
       return false;
     }
     if (_contentCache.getContents(source) != null) {
       return true;
     }
     return source.exists();
   }
 
@@ skipping 308 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);
         }
-        if (sourceEntry != null) {
-          sourceEntry.modificationTime =
-              _contentCache.getModificationStamp(source);
-          sourceEntry.setValue(SourceEntry.CONTENT, newContents);
-        }
+        sourceEntry.modificationTime =
+            _contentCache.getModificationStamp(source);
+        sourceEntry.setValue(SourceEntry.CONTENT, newContents);
       } else {
-        if (sourceEntry != null) {
-          sourceEntry.modificationTime =
-              _contentCache.getModificationStamp(source);
-        }
+        sourceEntry.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.
-      if (sourceEntry != null) {
-        try {
-          TimestampedData<String> fileContents = getContents(source);
-          String fileContentsData = fileContents.data;
-          if (fileContentsData == originalContents) {
-            sourceEntry.modificationTime = fileContents.modificationTime;
-            sourceEntry.setValue(SourceEntry.CONTENT, fileContentsData);
-            changed = false;
-          }
-        } catch (e) {
+      try {
+        TimestampedData<String> fileContents = getContents(source);
+        String fileContentsData = fileContents.data;
+        if (fileContentsData == originalContents) {
+          sourceEntry.modificationTime = fileContents.modificationTime;
+          sourceEntry.setValue(SourceEntry.CONTENT, fileContentsData);
+          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);
       }
     }
     if (notify && changed) {
       _onSourcesChangedController.add(
           new SourcesChangedEvent.changedContent(source, newContents));
@@ skipping 7471 matching lines @@
    *
    * <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
    */
   CompilationUnit computeResolvableCompilationUnit(Source source);
 
   /**
+   * Return any resolved [CompilationUnit] for the given [source] if not
+   * flushed, otherwise return `null` and ensures that the [CompilationUnit]
+   * will be eventually returned to the client from [performAnalysisTask].
+   */
+  CompilationUnit ensureAnyResolvedDartUnit(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);
 
   /**
    * Return a namespace containing mappings for all of the public names defined by the given
    * library.
    *
    * @param library the library whose public namespace is to be returned
    * @return the public namespace of the given library
    */
   Namespace getPublicNamespace(LibraryElement library);
 
   /**
    * Respond to a change which has been made to the given [source] file.
    * [originalContents] is the former contents of the file, and [newContents]
    * is the updated contents.  If [notify] is true, a source changed event is
    * triggered.
    *
-   * Normally it should not be necessary for clinets to call this function,
+   * Normally it should not be necessary for clients to call this function,
    * since it will be automatically invoked in response to a call to
    * [applyChanges] or [setContents].  However, if this analysis context is
    * sharing its content cache with other contexts, then the client must
    * manually update the content cache and call this function for each context.
    *
    * Return `true` if the change was significant to this context (i.e. [source]
    * is either implicitly or explicitly analyzed by this context, and a change
    * actually occurred).
    */
   bool handleContentsChanged(Source source, String originalContents,
@@ skipping 2582 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }