Issue 30238. Fix for subscribing for a notifications with already cached analysis result.

pkg/analysis_server/test/analysis/notification_outline_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.
 
 import 'dart:async';
 
 import 'package:analysis_server/protocol/protocol.dart';
 import 'package:analysis_server/protocol/protocol_constants.dart';
 import 'package:analysis_server/protocol/protocol_generated.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../analysis_abstract.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(_AnalysisNotificationOutlineTest);
   });
 }
 
 @reflectiveTest
 class _AnalysisNotificationOutlineTest extends AbstractAnalysisTest {
   FileKind fileKind;
   String libraryName;
   Outline outline;
 
-  Completer _resultsAvailable = new Completer();
+  Completer _outlineReceived = new Completer();
+  Completer _highlightsReceived = new Completer();
 
   Future prepareOutline() {
     addAnalysisSubscription(AnalysisService.OUTLINE, testFile);
-    return _resultsAvailable.future;
+    return _outlineReceived.future;
   }
 
   void processNotification(Notification notification) {
     if (notification.event == ANALYSIS_NOTIFICATION_OUTLINE) {
       var params = new AnalysisOutlineParams.fromNotification(notification);
       if (params.file == testFile) {
         fileKind = params.kind;
         libraryName = params.libraryName;
         outline = params.outline;
-        _resultsAvailable.complete(null);
+        _outlineReceived.complete(null);
+      }
+    }
+    if (notification.event == ANALYSIS_NOTIFICATION_HIGHLIGHTS) {
+      var params = new AnalysisHighlightsParams.fromNotification(notification);
+      if (params.file == testFile) {
+        _highlightsReceived?.complete(null);
+        _highlightsReceived = null;
       }
     }
   }
 
   @override
   void setUp() {
     super.setUp();
     createProject();
   }
 
@@ skipping 657 matching lines @@
       expect(element.name, "fieldD");
       {
         int offset = testCode.indexOf(" // marker");
         int end = testCode.indexOf(" // marker2");
         expect(outline.offset, offset);
         expect(outline.length, end - offset);
       }
     }
   }
 
+  test_subscribeWhenCachedResultIsAvailable() async {
+    // https://github.com/dart-lang/sdk/issues/30238
+    // We need to get notifications for new subscriptions even when the
+    // file is a priority file, and there is a cached result available.
+    addTestFile('''
+class A {}
+class B {}
+''');
+
+    // Make the file a priority one and subscribe for other notification.
+    // This will pre-cache the analysis result for the file.
+    setPriorityFiles([testFile]);
+    addAnalysisSubscription(AnalysisService.HIGHLIGHTS, testFile);
+    await _highlightsReceived.future;
+
+    // Now subscribe for outline notification, we must get it even though
+    // the result which is used is pre-cached, and not a newly computed.
+    await prepareOutline();
+    expect(outline.children, hasLength(2));
+  }
+
   test_topLevel() async {
     addTestFile('''
 typedef String FTA<K, V>(int i, String s);
 typedef FTB(int p);
 class A<T> {}
 class B {}
 class CTA<T> = A<T> with B;
 class CTB = A with B;
 String fA(int i, String s) => null;
 fB(int p) => null;
@@ skipping 117 matching lines @@
   }
 
   void _isEnumConstant(Outline outline, String name) {
     Element element = outline.element;
     expect(element.kind, ElementKind.ENUM_CONSTANT);
     expect(element.name, name);
     expect(element.parameters, isNull);
     expect(element.returnType, isNull);
   }
 }