Send notificatinos after no-op changes.

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 'dart:math' show max;
 
@@ skipping 571 matching lines @@
           return;
         }
       }
       channel.sendResponse(new Response.unknownRequest(request));
     }, onError: (exception, stackTrace) {
       sendServerErrorNotification(exception, stackTrace, fatal: true);
     });
   }
 
   /**
-   * Returns `true` if there is a subscription for the given [server] and [file].
+   * Returns `true` if there is a subscription for the given [service] and
+   * [file].
    */
   bool hasAnalysisSubscription(AnalysisService service, String file) {
     Set<String> files = analysisServices[service];
     return files != null && files.contains(file);
   }
 
   /**
    * Return `true` if analysis is complete.
    */
   bool isAnalysisComplete() {
@@ skipping 89 matching lines @@
     // Instruct the contextDirectoryManager to rebuild all contexts from
     // scratch.
     contextDirectoryManager.refresh();
   }
 
   /**
    * Schedules execution of the given [ServerOperation].
    */
   void scheduleOperation(ServerOperation operation) {
     addOperation(operation);
-    if (!performOperationPending) {
-      _schedulePerformOperation();
-    }
+    _schedulePerformOperation();
   }
 
   /**
    * Schedules analysis of the given context.
    */
   void schedulePerformAnalysisOperation(AnalysisContext context) {
     _onAnalysisStartedController.add(context);
     scheduleOperation(new PerformAnalysisOperation(context, false));
   }
 
@@ skipping 207 matching lines @@
       index.stop();
     }
     // Defer closing the channel and shutting down the instrumentation server so
     // that the shutdown response can be sent and logged.
     new Future(() {
       instrumentationService.shutdown();
       channel.close();
     });
   }
 
+  void test_flushResolvedUnit(String file) {
+    if (AnalysisEngine.isDartFileName(file)) {
+      AnalysisContextImpl context = getAnalysisContext(file);
+      Source source = getSource(file);
+      DartEntry dartEntry = context.getReadableSourceEntryOrNull(source);
+      dartEntry.flushAstStructures();
+    }
+  }
+
   /**
    * Implementation for `analysis.updateContent`.
    */
   void updateContent(String id, Map<String, dynamic> changes) {
     changes.forEach((file, change) {
       Source source = getSource(file);
       String oldContents = _overlayState.getContents(source);
       String newContents;
       if (change is AddContentOverlay) {
         newContents = change.content;
@@ skipping 18 matching lines @@
                       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);
+      // Update all contexts.
       for (InternalAnalysisContext context in folderMap.values) {
         if (context.handleContentsChanged(
             source,
             oldContents,
             newContents,
             true)) {
           schedulePerformAnalysisOperation(context);
+        } else {
+          // When the client sends any change for a source, we should resend
+          // subscribed notifications, even if there were no changes in the
+          // source contents.
+          // TODO(scheglov) consider checking if there are subscriptions.
+          if (AnalysisEngine.isDartFileName(file)) {
+            CompilationUnit dartUnit =
+                context.ensureAnyResolvedDartUnit(source);
+            if (dartUnit != null) {
+              AnalysisErrorInfo errorInfo = context.getErrors(source);
+              scheduleNotificationOperations(
+                  this,
+                  file,
+                  errorInfo.lineInfo,
+                  context,
+                  null,
+                  dartUnit,
+                  errorInfo.errors);
+            } else {
+              schedulePerformAnalysisOperation(context);
+            }
+          }
         }
       }
     });
   }
 
   /**
    * Use the given updaters to update the values of the options in every
    * existing analysis context.
    */
   void updateOptions(List<OptionUpdater> optionUpdaters) {
@@ skipping 14 matching lines @@
     AnalysisOptionsImpl options = contextDirectoryManager.defaultOptions;
     optionUpdaters.forEach((OptionUpdater optionUpdater) {
       optionUpdater(options);
     });
   }
 
   /**
    * Schedules [performOperation] exection.
    */
   void _schedulePerformOperation() {
-    assert(!performOperationPending);
+    if (performOperationPending) {
+      return;
+    }
     /*
      * TODO (danrubel) Rip out this workaround once the underlying problem
      * is fixed. Currently, the VM and dart:io do not deliver content
      * on stdin in a timely manner if the event loop is busy.
      * To work around this problem, we delay for 1 millisecond
      * every 25 milliseconds.
      *
      * To disable this workaround and see the underlying problem,
      * set performOperationDelayFreqency to zero
      */
@@ skipping 202 matching lines @@
           new DateTime.now().millisecondsSinceEpoch -
           request.clientRequestTime;
       requestLatency += latency;
       maxLatency = max(maxLatency, latency);
       if (latency > 150) {
         ++slowRequestCount;
       }
     }
   }
 }