Fix "reanalyze sources" when there are unsaved files.

pkg/analysis_server/lib/src/analysis_server.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.
 
 library analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analysis_server/src/analysis_logger.dart';
@@ skipping 189 matching lines @@
   /**
    * The next time (milliseconds since epoch) after which the analysis server
    * should pause so that pending requests can be fetched by the system.
    */
   // Add 1 sec to prevent delay from impacting short running tests
   int _nextPerformOperationDelayTime =
       new DateTime.now().millisecondsSinceEpoch +
       1000;
 
   /**
+   * The current state of overlays from the client.  This is used as the
+   * content cache for all contexts.
+   */
+  ContentCache _overlayState = new ContentCache();
+
+  /**
    * Initialize a newly created server to receive requests from and send
    * responses to the given [channel].
    *
    * If [rethrowExceptions] is true, then any exceptions thrown by analysis are
    * propagated up the call stack.  The default is true to allow analysis
    * exceptions to show up in unit tests, but it should be set to false when
    * running a full analysis server.
    */
   AnalysisServer(this.channel, this.resourceProvider,
       PackageMapProvider packageMapProvider, this.index,
@@ skipping 662 matching lines @@
       instrumentationService.shutdown();
       channel.close();
     });
   }
 
   /**
    * Implementation for `analysis.updateContent`.
    */
   void updateContent(String id, Map<String, dynamic> changes) {
     changes.forEach((file, change) {
-      AnalysisContext analysisContext = getAnalysisContext(file);
-      // TODO(paulberry): handle the case where a file is referred to by more
-      // than one context (e.g package A depends on package B using a local
-      // path, user has both packages open for editing in separate contexts,
-      // and user modifies a file in package B).
-      if (analysisContext != null) {
-        Source source = getSource(file);
-        if (change is AddContentOverlay) {
-          analysisContext.setContents(source, change.content);
-        } else if (change is ChangeContentOverlay) {
-          // TODO(paulberry): an error should be generated if source is not
-          // currently in the content cache.
-          TimestampedData<String> oldContents =
-              analysisContext.getContents(source);
-          String newContents;
-          try {
-            newContents =
-                SourceEdit.applySequence(oldContents.data, change.edits);
-          } on RangeError {
-            throw new RequestFailure(
-                new Response(
-                    id,
-                    error: new RequestError(
-                        RequestErrorCode.INVALID_OVERLAY_CHANGE,
-                        'Invalid overlay change')));
-          }
-          // TODO(paulberry): to aid in incremental processing it would be
-          // better to use setChangedContents.
-          analysisContext.setContents(source, newContents);
-        } else if (change is RemoveContentOverlay) {
-          analysisContext.setContents(source, null);
-        } else {
-          // Protocol parsing should have ensured that we never get here.
-          throw new AnalysisException('Illegal change type');
+      Source source = getSource(file);
+      String oldContents = _overlayState.getContents(source);

[Brian Wilkerson, 2015/01/26 23:05:02]

There is a subtle bug here that's being carried forward from the existing code.
I hadn't realized that there is a bug until I saw this change, so it's good. The
bug is that two sources representing the same disk file but with different URI's
will not compare equal, so changing the content for one source will not change
the content for the other source. I think we also need to re-write ContentCache
to use the file path rather than the URI, but that would be in a separate CL.

+      String newContents;
+      if (change is AddContentOverlay) {
+        newContents = change.content;
+      } else if (change is ChangeContentOverlay) {
+        if (oldContents == null) {
+          // The client may only send a ChangeContentOverlay if there is
+          // already an existing overlay for the source.
+          throw new RequestFailure(
+              new Response(
+                  id,
+                  error: new RequestError(
+                      RequestErrorCode.INVALID_OVERLAY_CHANGE,
+                      'Invalid overlay change')));
         }
-        schedulePerformAnalysisOperation(analysisContext);
+        try {
+          newContents = SourceEdit.applySequence(oldContents, change.edits);
+        } on RangeError {
+          throw new RequestFailure(
+              new Response(
+                  id,
+                  error: new RequestError(
+                      RequestErrorCode.INVALID_OVERLAY_CHANGE,
+                      'Invalid overlay change')));
+        }
+      } else if (change is RemoveContentOverlay) {
+        newContents = null;
+      } else {
+        // Protocol parsing should have ensured that we never get here.
+        throw new AnalysisException('Illegal change type');
+      }
+      _overlayState.setContents(source, newContents);
+      for (InternalAnalysisContext context in folderMap.values) {
+        if (context.handleContentsChanged(
+            source,
+            oldContents,
+            newContents,
+            true)) {
+          schedulePerformAnalysisOperation(context);
+        }
       }
     });
   }
 
   /**
    * Use the given updaters to update the values of the options in every
    * existing analysis context.
    */
   void updateOptions(List<OptionUpdater> optionUpdaters) {
     //
@@ skipping 109 matching lines @@
   }
 
   /**
    * The stream that is notified when contexts are added or removed.
    */
   Stream<ContextsChangedEvent> get onContextsChanged =>
       _onContextsChangedController.stream;
 
   @override
   void addContext(Folder folder, UriResolver packageUriResolver) {
-    AnalysisContext context = AnalysisEngine.instance.createAnalysisContext();
+    InternalAnalysisContext context =
+        AnalysisEngine.instance.createAnalysisContext();
+    context.contentCache = analysisServer._overlayState;
     analysisServer.folderMap[folder] = context;
     context.sourceFactory = _createSourceFactory(packageUriResolver);
     context.analysisOptions = new AnalysisOptionsImpl.con1(defaultOptions);
     _onContextsChangedController.add(
         new ContextsChangedEvent(added: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
@@ skipping 51 matching lines @@
    * [packageUriResolver].
    */
   SourceFactory _createSourceFactory(UriResolver packageUriResolver) {
     List<UriResolver> resolvers = <UriResolver>[
         new DartUriResolver(analysisServer.defaultSdk),
         new ResourceUriResolver(resourceProvider),
         packageUriResolver];
     return new SourceFactory(resolvers);
   }
 }