Fix "reanalyze sources" when there are unsaved files.

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 1133 matching lines @@
       int count =
           math.min(sources.length, _options.cacheSize - _PRIORITY_ORDER_SIZE_DELTA);
       _priorityOrder = new List<Source>(count);
       for (int i = 0; i < count; i++) {
         _priorityOrder[i] = sources[i];
       }
     }
   }
 
   @override
+  set contentCache(ContentCache value) {
+    _contentCache = value;
+  }
+
+  @override
   DeclaredVariables get declaredVariables => _declaredVariables;
 
   @override
   List<Source> get htmlSources => _getSources(SourceKind.HTML);
 
   @override
   bool get isDisposed => _disposed;
 
   @override
   List<Source> get launchableClientLibrarySources {
@@ skipping 363 matching lines @@
     for (Source source in changeSet.changedSources) {
       if (_contentCache.getContents(source) != null) {
         // This source is overridden in the content cache, so the change will
         // have no effect. Just ignore it to avoid wasting time doing
         // re-analysis.
         continue;
       }
       _sourceChanged(source);
     }
     changeSet.changedContents.forEach((Source key, String value) {
-      _contentsChanged(key, value);
+      _contentsChanged(key, value, false);
     });
     changeSet.changedRanges.forEach(
         (Source source, ChangeSet_ContentChange change) {
       _contentRangeChanged(
           source,
           change.contents,
           change.offset,
           change.oldLength,
           change.newLength);
     });
@@ skipping 594 matching lines @@
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
     }
     return null;
   }
 
   @override
+  bool handleContentsChanged(Source source, String originalContents,
+      String newContents, bool notify) {
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry == null) {
+      return false;
+    }
+    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);
+        }
+      } else {
+        if (sourceEntry != null) {
+          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) {
+        }
+      }
+      // 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));
+    }
+    return changed;
+  }
+
+  @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 341 matching lines @@
               source,
               contents,
               offset,
               oldLength,
               newLength));
     }
   }
 
   @override
   void setContents(Source source, String contents) {
-    if (_contentsChanged(source, contents)) {
-      _onSourcesChangedController.add(
-          new SourcesChangedEvent.changedContent(source, contents));
-    }
+    _contentsChanged(source, contents, true);
   }
 
   @override
   void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
       DataDescriptor rowDesc, CacheState state)) {
     bool hintsEnabled = _options.hint;
     bool lintsEnabled = _options.lint;
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
@@ skipping 252 matching lines @@
           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.
    *
    * <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
@@ skipping 343 matching lines @@
       _sourceChanged(source);
       changed = true;
     }
     return changed;
   }
 
   /**
    * Set the contents of the given source to the given contents and mark the source as having
    * changed. This has the effect of overriding the default contents of the source. If the contents
    * are `null` the override is removed so that the default contents will be returned.
-   * [setContents] triggers a source changed event where as this method does not.
+   *
+   * If [notify] is true, a source changed event is triggered.
    *
    * @param source the source whose contents are being overridden
    * @param contents the new contents of the source
    */
-  bool _contentsChanged(Source source, String contents) {
-    bool changed = false;
+  void _contentsChanged(Source source, String contents, bool notify) {
     String originalContents = _contentCache.setContents(source, contents);
-    if (contents != null) {
-      if (contents != originalContents) {
-        _incrementalAnalysisCache =
-            IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
-        if (!analysisOptions.incremental ||
-            !_tryPoorMansIncrementalResolution(source, contents)) {
-          _sourceChanged(source);
-        }
-        changed = true;
-        SourceEntry sourceEntry = _cache.get(source);
-        if (sourceEntry != null) {
-          sourceEntry.modificationTime =
-              _contentCache.getModificationStamp(source);
-          sourceEntry.setValue(SourceEntry.CONTENT, contents);
-        }
-      } else {
-        SourceEntry sourceEntry = _cache.get(source);
-        if (sourceEntry != null) {
-          sourceEntry.modificationTime =
-              _contentCache.getModificationStamp(source);
-        }
-      }
-    } else if (originalContents != null) {
-      _incrementalAnalysisCache =
-          IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
-      changed = true;
-      // We are removing the overlay for the file, check if the file's
-      // contents is the same as it was in the overlay.
-      SourceEntry sourceEntry = _cache.get(source);
-      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) {
-        }
-      }
-      // If not the same content (e.g. the file is being closed without save),
-      // then force analysis.
-      if (changed) {
-        _sourceChanged(source);
-      }
-    }
-    return changed;
+    handleContentsChanged(source, originalContents, contents, notify);
   }
 
 //  /**
 //   * Create a [BuildUnitElementTask] for the given [source].
 //   */
 //  AnalysisContextImpl_TaskData _createBuildUnitElementTask(Source source,
 //      DartEntry dartEntry, Source librarySource) {
 //    CompilationUnit unit = dartEntry.resolvableCompilationUnit;
 //    if (unit == null) {
 //      return _createParseDartTask(source, dartEntry);
@@ skipping 141 matching lines @@
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createGetContentTask(Source source,
       SourceEntry sourceEntry) {
     sourceEntry.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(
         new GetContentTask(this, source),
         false);
   }
 
-
-
   /**
    * Create a [ParseDartTask] for the given [source].
    */
   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);
@@ skipping 1224 matching lines @@
     if (thrownException != null) {
       sourceEntry.recordContentError(thrownException);
       _workManager.remove(source);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     sourceEntry.modificationTime = task.modificationTime;
     sourceEntry.setValue(SourceEntry.CONTENT, task.content);
     return sourceEntry;
   }
 
-
   /**
    * Record the results produced by performing a [IncrementalAnalysisTask].
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry
       _recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) {
     CompilationUnit unit = task.compilationUnit;
@@ skipping 4980 matching lines @@
     }
   }
 }
 
 /**
  * The interface `InternalAnalysisContext` defines additional behavior for an analysis context
  * that is required by internal users of the context.
  */
 abstract class InternalAnalysisContext implements AnalysisContext {
   /**
+   * Allow the client to supply its own content cache.  This will take the
+   * place of the content cache created by default, allowing clients to share
+   * the content cache between contexts.
+   */
+  set contentCache(ContentCache value);
+
+  /**
    * Return an array containing all of the sources that have been marked as priority sources.
    * Clients must not modify the returned array.
    *
    * @return the sources that have been marked as priority sources
    */
   List<Source> get prioritySources;
 
   /**
    * Returns a statistics about this context.
    */
@@ skipping 62 matching lines @@
   /**
    * 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,
+   * 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,
+      String newContents, bool notify);
+
+  /**
    * Given a table mapping the source for the libraries represented by the corresponding elements to
    * the elements representing the libraries, record those mappings.
    *
    * @param elementMap a table mapping the source for the libraries represented by the elements to
    *          the elements representing the libraries
    */
   void recordLibraryElements(Map<Source, LibraryElement> elementMap);
 
   /**
    * Call the given callback function for eache cache item in the context.
@@ skipping 2569 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }