Avoid redundant notifications when a file is analyzed in multiple contexts.

pkg/analysis_server/test/analysis_server_test.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 test.analysis_server;
 
 import 'dart:async';
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analysis_server/src/constants.dart';
@@ skipping 207 matching lines @@
           server.getAnalysisContextForSource(barSource);
       expect(barContext, isNotNull);
       expect(fooContext, isNot(same(barContext)));
       expect(fooContext.getKindOf(fooSource), SourceKind.LIBRARY);
       expect(fooContext.getKindOf(barSource), SourceKind.UNKNOWN);
       expect(barContext.getKindOf(fooSource), SourceKind.UNKNOWN);
       expect(barContext.getKindOf(barSource), SourceKind.LIBRARY);
     });
   }
 
+  /**
+   * Test that having multiple analysis contexts analyze the same file doesn't
+   * cause that file to receive duplicate notifications when it's modified.
+   */
+  Future test_no_duplicate_notifications() async {
+    // Subscribe to STATUS so we'll know when analysis is done.
+    server.serverServices = [ServerService.STATUS].toSet();
+    resourceProvider.newFolder('/foo');
+    resourceProvider.newFolder('/bar');
+    resourceProvider.newFile('/foo/foo.dart', 'import "../bar/bar.dart";');
+    File bar = resourceProvider.newFile('/bar/bar.dart', 'library bar;');
+    server.setAnalysisRoots('0', ['/foo', '/bar'], [], {});
+    Map<AnalysisService, Set<String>> subscriptions = <AnalysisService,
+        Set<String>>{};
+    for (AnalysisService service in AnalysisService.VALUES) {
+      subscriptions[service] = <String>[bar.path].toSet();
+    }
+    server.setAnalysisSubscriptions(subscriptions);
+    await pumpEventQueue(100);
+    expect(server.statusAnalyzing, isFalse);
+    channel.notificationsReceived.clear();
+    server.updateContent('0', {
+      bar.path: new AddContentOverlay('library bar; void f() {}')
+    });
+    await pumpEventQueue(100);
+    expect(server.statusAnalyzing, isFalse);
+    expect(channel.notificationsReceived, isNotEmpty);
+    Set<String> notificationTypesReceived = new Set<String>();
+    for (Notification notification in channel.notificationsReceived) {
+      String notificationType = notification.event;
+      switch (notificationType) {
+        case 'server.status':
+        case 'analysis.errors':
+          // It's normal for these notifications to be sent multiple times.
+          break;
+        case 'analysis.outline':
+          // It's normal for this notification to be sent twice.
+          // TODO(paulberry): why?

[danrubel, 2015/01/29 21:37:00]

Do we send an outline once when it is parsed and again when it is resolved?

+          break;
+        default:
+          if (!notificationTypesReceived.add(notificationType)) {
+            fail('Notification type $notificationType received more than once');
+          }
+          break;
+      }
+    }
+    return null; // Work around dartbug.com/22091
+  }
+
   Future test_prioritySourcesChangedEvent() {
     resourceProvider.newFolder('/foo');
 
     int eventCount = 0;
     Source firstSource = null;
     server.onPriorityChange.listen((PriorityChangeEvent event) {
       ++eventCount;
       firstSource = event.firstSource;
     });
 
@@ skipping 95 matching lines @@
   @override
   Response handleRequest(Request request) {
     if (request.method == 'echo') {
       return new Response(request.id, result: {
         'echo': true
       });
     }
     return null;
   }
 }