Issue 22617. Add/remove overlay-only sources to their containing contexts.

pkg/analysis_server/test/analysis/update_content_test.dart

 // Copyright (c) 2015, 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.updateContent;
 
 import 'package:analysis_server/src/constants.dart';
 import 'package:analysis_server/src/protocol.dart';
 import 'package:analysis_server/src/services/index/index.dart';
+import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/ast.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/generated/source.dart';
 import 'package:typed_mock/typed_mock.dart';
 import 'package:unittest/unittest.dart';
 
 import '../analysis_abstract.dart';
 import '../reflective_tests.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(UpdateContentTest);
 }
@@ skipping 76 matching lines @@
     // It will schedule an indexing operation.
     await server.test_onOperationPerformed;
     // Update the file and remove an overlay.
     resourceProvider.updateFile(testFile, 'main() { print(2); }');
     server.updateContent('2', {testFile: new RemoveContentOverlay()});
     // Validate that at the end the unit was indexed.
     await server.onAnalysisComplete;
     verify(server.index.indexUnit(anyObject, testUnitMatcher)).times(2);
   }
 
-  test_multiple_contexts() {
+  test_multiple_contexts() async {
     String fooPath = '/project1/foo.dart';
     resourceProvider.newFile(fooPath, '''
 library foo;
 import '../project2/baz.dart';
 main() { f(); }''');
     String barPath = '/project2/bar.dart';
     resourceProvider.newFile(barPath, '''
 library bar;
 import 'baz.dart';
 main() { f(); }''');
     String bazPath = '/project2/baz.dart';
     resourceProvider.newFile(bazPath, '''
 library baz;
 f(int i) {}
 ''');
     Request request = new AnalysisSetAnalysisRootsParams(
         ['/project1', '/project2'], []).toRequest('0');
     handleSuccessfulRequest(request);
-    return waitForTasksFinished().then((_) {
+    {
+      await server.onAnalysisComplete;
       // Files foo.dart and bar.dart should both have errors, since they both
       // call f() with the wrong number of arguments.
       expect(filesErrors[fooPath], hasLength(1));
       expect(filesErrors[barPath], hasLength(1));
       // Overlay the content of baz.dart to eliminate the errors.
       server.updateContent('1', {
         bazPath: new AddContentOverlay('''
 library baz;
 f() {}
 ''')
       });
-      return waitForTasksFinished();
-    }).then((_) {
+    }
+    {
+      await server.onAnalysisComplete;
       // The overlay should have been propagated to both contexts, causing both
       // foo.dart and bar.dart to be reanalyzed and found to be free of errors.
       expect(filesErrors[fooPath], isEmpty);
       expect(filesErrors[barPath], isEmpty);
-    });
+    }
+  }
+
+  test_overlayOnly() async {
+    String filePath = '/User/project1/test.dart';
+    Folder folder1 = resourceProvider.newFolder('/User/project1');
+    Folder folder2 = resourceProvider.newFolder('/User/project2');
+    Request request = new AnalysisSetAnalysisRootsParams(
+        [folder1.path, folder2.path], []).toRequest('0');
+    handleSuccessfulRequest(request);
+    // exactly 2 contexts
+    expect(server.folderMap, hasLength(2));
+    AnalysisContext context1 = server.folderMap[folder1];
+    AnalysisContext context2 = server.folderMap[folder2];
+    // no sources
+    expect(_getUserSources(context1), isEmpty);
+    expect(_getUserSources(context2), isEmpty);
+    // add an overlay - new Source in context1
+    server.updateContent('1', {filePath: new AddContentOverlay('')});
+    {
+      List<Source> sources = _getUserSources(context1);
+      expect(sources, hasLength(1));
+      expect(sources[0].fullName, filePath);
+    }
+    expect(_getUserSources(context2), isEmpty);
+    // remove the overlay - no sources
+    server.updateContent('2', {filePath: new RemoveContentOverlay()});
+    expect(_getUserSources(context1), isEmpty);
+    expect(_getUserSources(context2), isEmpty);
   }
 
   test_sendNoticesAfterNopChange() async {
     createProject();
     addTestFile('');
     await server.onAnalysisComplete;
     // add an overlay
     server.updateContent(
         '1', {testFile: new AddContentOverlay('main() {} main() {}')});
     await server.onAnalysisComplete;
@@ skipping 18 matching lines @@
     // clear errors and make a no-op change
     filesErrors.clear();
     server.test_flushResolvedUnit(testFile);
     server.updateContent('2', {
       testFile: new ChangeContentOverlay([new SourceEdit(0, 4, 'main')])
     });
     await server.onAnalysisComplete;
     // errors should have been resent
     expect(filesErrors, isNotEmpty);
   }
+
+  List<Source> _getUserSources(AnalysisContext context) {
+    List<Source> sources = <Source>[];
+    context.sources.forEach((source) {
+      if (source.fullName.startsWith('/User/')) {
+        sources.add(source);
+      }
+    });
+    return sources;
+  }
 }
 
 class _ArgumentMatcher_CompilationUnit extends ArgumentMatcher {
   final String file;
 
   _ArgumentMatcher_CompilationUnit(this.file);
 
   @override
   bool matches(arg) {
     return arg is CompilationUnit && arg.element.source.fullName == file;
   }
 }
 
 class _MockIndex extends TypedMock implements Index {
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }