Remove more dead code from analysis server

pkg/analysis_server/test/context_manager_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.context.directory.manager;
 
 import 'dart:async';
-import 'dart:collection';
 
 import 'package:analysis_server/src/context_manager.dart';
 import 'package:analysis_server/src/utilities/null_string_sink.dart';
 import 'package:analyzer/context/context_root.dart';
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/context/builder.dart';
@@ skipping 141 matching lines @@
     // Setup .packages file
     newFile(
         [projPath, '.packages'],
         r'''
 test_pack:lib/''');
     // Setup context.
 
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
     // Confirm that one context was created.
-    var contexts =
-        manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
-    expect(contexts, isNotNull);
-    expect(contexts.length, equals(1));
+    int count = manager
+        .numberOfContextsInAnalysisRoot(resourceProvider.newFolder(projPath));
+    expect(count, equals(1));
     var source = sourceFactory.forUri('dart:foobar');
     expect(source, isNotNull);
     expect(source.fullName, '/my/proj/sdk_ext/entry.dart');
     // We can't find dart:core because we didn't list it in our
     // embedded_libs map.
     expect(sourceFactory.forUri('dart:core'), isNull);
     // We can find dart:typed_data because we listed it in our
     // embedded_libs map.
     expect(sourceFactory.forUri('dart:typed_data'), isNotNull);
   }
@@ skipping 209 matching lines @@
 }
 ''');
     // Setup .packages file
     newFile(
         [projPath, '.packages'],
         r'''
 test_pack:lib/''');
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // Confirm that one context was created.
-    var contexts =
-        manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
-    expect(contexts, isNotNull);
-    expect(contexts.length, equals(1));
+    int count = manager
+        .numberOfContextsInAnalysisRoot(resourceProvider.newFolder(projPath));
+    expect(count, equals(1));
     var source = sourceFactory.forUri('dart:foobar');
     expect(source.fullName, equals('/my/proj/sdk_ext/entry.dart'));
   }
 
   void test_setRoots_addFolderWithDartFile() {
     String filePath = path.posix.join(projPath, 'foo.dart');
     resourceProvider.newFile(filePath, 'contents');
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     // verify
     Iterable<String> filePaths = callbacks.currentFilePaths;
@@ skipping 1336 matching lines @@
 
   void deleteFile(List<String> pathComponents) {
     String filePath = path.posix.joinAll(pathComponents);
     resourceProvider.deleteFile(filePath);
   }
 
   /**
    * TODO(brianwilkerson) This doesn't add the strong mode processor when using
    * the new analysis driver.
    */
-  ErrorProcessor getProcessor(AnalysisError error) =>
-      callbacks.currentDriver == null
-          ? ErrorProcessor.getProcessor(
-              callbacks.currentContext.analysisOptions, error)
-          : errorProcessors.firstWhere((ErrorProcessor p) => p.appliesTo(error),
-              orElse: () => null);
+  ErrorProcessor getProcessor(AnalysisError error) => errorProcessors
+      .firstWhere((ErrorProcessor p) => p.appliesTo(error), orElse: () => null);
 
   String newFile(List<String> pathComponents, [String content = '']) {
     String filePath = path.posix.joinAll(pathComponents);
     resourceProvider.newFile(filePath, content);
     return filePath;
   }
 
   String newFileFromBytes(List<String> pathComponents, List<int> bytes) {
     String filePath = path.posix.joinAll(pathComponents);
     resourceProvider.newFileWithBytes(filePath, bytes);
@@ skipping 326 matching lines @@
 linter:
   rules:
     - camel_case_types
 ''');
 
     // Setup context.
     manager.setRoots(<String>[projPath], <String>[], <String, String>{});
     await pumpEventQueue();
 
     // Confirm that one context was created.
-    var contexts =
-        manager.contextsInAnalysisRoot(resourceProvider.newFolder(projPath));
-    expect(contexts, isNotNull);
-    expect(contexts, hasLength(1));
+    int count = manager
+        .numberOfContextsInAnalysisRoot(resourceProvider.newFolder(projPath));
+    expect(count, equals(1));
 
     // Verify options.
     // * from `_embedder.yaml`:
     expect(analysisOptions.strongMode, isTrue);
     expect(analysisOptions.enableSuperMixins, isTrue);
     // * from analysis options:
     expect(analysisOptions.enableStrictCallChecks, isTrue);
 
     // * verify tests are excluded
     expect(
@@ skipping 389 matching lines @@
   }
 }
 
 class TestContextManagerCallbacks extends ContextManagerCallbacks {
   /**
    * Source of timestamps stored in [currentContextFilePaths].
    */
   int now = 0;
 
   /**
-   * The analysis context that was created.
-   */
-  AnalysisContext currentContext;
-
-  /**
    * The analysis driver that was created.
    */
   AnalysisDriver currentDriver;
 
   /**
    * A table mapping paths to the analysis driver associated with that path.
    */
   Map<String, AnalysisDriver> driverMap = <String, AnalysisDriver>{};
 
   /**
@@ skipping 43 matching lines @@
    * The watch events that have been broadcast.
    */
   List<WatchEvent> watchEvents = <WatchEvent>[];
 
   TestContextManagerCallbacks(
       this.resourceProvider, this.sdkManager, this.logger, this.scheduler);
 
   /**
    * Return the current set of analysis options.
    */
-  AnalysisOptions get analysisOptions => currentDriver == null
-      ? currentContext.analysisOptions
-      : currentDriver.analysisOptions;
+  AnalysisOptions get analysisOptions => currentDriver?.analysisOptions;
 
   /**
    * Return the paths to the context roots that currently exist.
    */
   Iterable<String> get currentContextRoots {
     return currentContextTimestamps.keys;
   }
 
   /**
    * Return the paths to the files being analyzed in the current context root.
    */
   Iterable<String> get currentFilePaths {
     if (currentDriver == null) {
-      if (currentContext == null) {
-        return <String>[];
-      }
-      Map<String, int> fileMap = currentContextFilePaths[currentContext.name];
-      if (fileMap == null) {
-        return <String>[];
-      }
-      return fileMap.keys;
+      return <String>[];
     }
     return currentDriver.addedFiles;
   }
 
   /**
    * Return the current source factory.
    */
-  SourceFactory get sourceFactory => currentDriver == null
-      ? currentContext.sourceFactory
-      : currentDriver.sourceFactory;
+  SourceFactory get sourceFactory => currentDriver?.sourceFactory;
 
   @override
   AnalysisDriver addAnalysisDriver(
       Folder folder, ContextRoot contextRoot, AnalysisOptions options) {
     String path = folder.path;
     expect(currentContextRoots, isNot(contains(path)));
     expect(contextRoot, isNotNull);
     expect(contextRoot.root, path);
     currentContextTimestamps[path] = now;
 
@@ skipping 15 matching lines @@
         analysisOptions);
     driverMap[path] = currentDriver;
     currentDriver.exceptions.listen((ExceptionResult result) {
       AnalysisEngine.instance.logger
           .logError('Analysis failed: ${result.path}', result.exception);
     });
     return currentDriver;
   }
 
   @override
-  AnalysisContext addContext(Folder folder, AnalysisOptions options) {
-    String path = folder.path;
-    expect(currentContextRoots, isNot(contains(path)));
-    currentContextTimestamps[path] = now;
-    currentContextFilePaths[path] = <String, int>{};
-    currentContextSources[path] = new HashSet<Source>();
-
-    ContextBuilder builder = createContextBuilder(folder, options);
-    currentContext = builder.buildContext(path);
-    currentContext.name = path;
-    return currentContext;
-  }
-
-  @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     AnalysisDriver driver = driverMap[contextFolder.path];
     if (driver != null) {
       changeSet.addedSources.forEach((source) {
         driver.addFile(source.fullName);
       });
       changeSet.changedSources.forEach((source) {
         driver.changeFile(source.fullName);
       });
       changeSet.removedSources.forEach((source) {
         driver.removeFile(source.fullName);
       });
-    } else {
-      Map<String, int> filePaths = currentContextFilePaths[contextFolder.path];
-      Set<Source> sources = currentContextSources[contextFolder.path];
-
-      for (Source source in changeSet.addedSources) {
-        expect(filePaths, isNot(contains(source.fullName)));
-        filePaths[source.fullName] = now;
-        sources.add(source);
-      }
-      for (Source source in changeSet.removedSources) {
-        expect(filePaths, contains(source.fullName));
-        filePaths.remove(source.fullName);
-        sources.remove(source);
-      }
-      for (Source source in changeSet.changedSources) {
-        expect(filePaths, contains(source.fullName));
-        filePaths[source.fullName] = now;
-      }
-
-      currentContext.applyChanges(changeSet);
     }
   }
 
   @override
   void applyFileRemoved(AnalysisDriver driver, String file) {
     driver.removeFile(file);
   }
 
   void assertContextFiles(String contextPath, List<String> expectedFiles) {
     expect(getCurrentFilePaths(contextPath), unorderedEquals(expectedFiles));
@@ skipping 22 matching lines @@
         resourceProvider, sdkManager, new ContentCache(),
         options: builderOptions);
     return builder;
   }
 
   /**
    * Return the paths to the files being analyzed in the current context root.
    */
   Iterable<Source> currentFileSources(String contextPath) {
     if (currentDriver == null) {
-      if (currentContext == null) {
-        return <Source>[];
-      }
-      Set<Source> sources = currentContextSources[contextPath];
-      return sources ?? <Source>[];
+      return <Source>[];
     }
     AnalysisDriver driver = driverMap[contextPath];
     SourceFactory sourceFactory = driver.sourceFactory;
     return driver.addedFiles.map((String path) {
       File file = resourceProvider.getFile(path);
       Source source = file.createSource();
       Uri uri = sourceFactory.restoreUri(source);
       return file.createSource(uri);
     });
   }
 
   /**
    * Return the paths to the files being analyzed in the current context root.
    */
   Iterable<String> getCurrentFilePaths(String contextPath) {
     if (currentDriver == null) {
-      if (currentContext == null) {
-        return <String>[];
-      }
-      Map<String, int> fileMap = currentContextFilePaths[contextPath];
-      if (fileMap == null) {
-        return <String>[];
-      }
-      return fileMap.keys;
+      return <String>[];
     }
     return driverMap[contextPath].addedFiles;
   }
 
   @override
   void moveContext(Folder from, Folder to) {
     String path = from.path;
     String path2 = to.path;
     expect(currentContextFilePaths, contains(path));
     expect(currentContextTimestamps, contains(path));
@@ skipping 35 matching lines @@
 class TestUriResolver extends UriResolver {
   Map<Uri, Source> uriMap;
 
   TestUriResolver(this.uriMap);
 
   @override
   Source resolveAbsolute(Uri uri, [Uri actualUri]) {
     return uriMap[uri];
   }
 }