Remove more dead code from analysis server

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.
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core';
 import 'dart:io' as io;
 import 'dart:math' show max;
 
@@ skipping 302 matching lines @@
    */
   Set<String> prevAnalyzedFiles;
 
   /**
    * The default options used to create new analysis contexts. This object is
    * also referenced by the ContextManager.
    */
   final AnalysisOptionsImpl defaultContextOptions = new AnalysisOptionsImpl();
 
   /**
-   * The controller for sending [ContextsChangedEvent]s.
-   */
-  StreamController<ContextsChangedEvent> _onContextsChangedController =
-      new StreamController<ContextsChangedEvent>.broadcast();
-
-  /**
    * The file resolver provider used to override the way file URI's are
    * resolved in some contexts.
    */
   ResolverProvider fileResolverProvider;
 
   /**
    * The package resolver provider used to override the way package URI's are
    * resolved in some contexts.
    */
   ResolverProvider packageResolverProvider;
@@ skipping 138 matching lines @@
     searchEngine = new SearchEngineImpl(driverMap.values);
     Notification notification = new ServerConnectedParams(VERSION, io.pid,
             sessionId: instrumentationService.sessionId)
         .toNotification();
     channel.sendNotification(notification);
     channel.listen(handleRequest, onDone: done, onError: error);
     handlers = serverPlugin.createDomains(this);
   }
 
   /**
-   * Return the [AnalysisContext]s that are being used to analyze the analysis
-   * roots.
-   */
-  Iterable<AnalysisContext> get analysisContexts =>
-      contextManager.analysisContexts;
-
-  /**
    * Return a list of the globs used to determine which files should be analyzed.
    */
   List<Glob> get analyzedFilesGlobs {
     if (_analyzedFilesGlobs == null) {
       _analyzedFilesGlobs = <Glob>[];
       List<String> patterns = serverPlugin.analyzedFilePatterns;
       for (String pattern in patterns) {
         try {
           _analyzedFilesGlobs
               .add(new Glob(resourceProvider.pathContext.separator, pattern));
         } catch (exception, stackTrace) {
           AnalysisEngine.instance.logger.logError(
               'Invalid glob pattern: "$pattern"',
               new CaughtException(exception, stackTrace));
         }
       }
     }
     return _analyzedFilesGlobs;
   }
 
   /**
    * A table mapping [Folder]s to the [AnalysisDriver]s associated with them.
    */
   Map<Folder, nd.AnalysisDriver> get driverMap => contextManager.driverMap;
 
   /**
-   * Return a table mapping [Folder]s to the [AnalysisContext]s associated with
-   * them.
-   */
-  Map<Folder, AnalysisContext> get folderMap => contextManager.folderMap;
-
-  /**
    * The [Future] that completes when analysis is complete.
    */
   Future get onAnalysisComplete {
     if (isAnalysisComplete()) {
       return new Future.value();
     }
     if (_onAnalysisCompleteCompleter == null) {
       _onAnalysisCompleteCompleter = new Completer();
     }
     return _onAnalysisCompleteCompleter.future;
   }
 
   /**
    * The stream that is notified with `true` when analysis is started.
    */
   Stream<bool> get onAnalysisStarted {
     return _onAnalysisStartedController.stream;
   }
 
   /**
-   * The stream that is notified when contexts are added or removed.
-   */
-  Stream<ContextsChangedEvent> get onContextsChanged =>
-      _onContextsChangedController.stream;
-
-  /**
    * The stream that is notified when a single file has been added. This exists
    * as a temporary stopgap for plugins, until the official plugin API is
    * complete.
    */
   Stream get onFileAdded => _onFileAddedController.stream;
 
   /**
    * The stream that is notified when a single file has been analyzed.
    */
   Stream get onFileAnalyzed => _onFileAnalyzedController.stream;
@@ skipping 118 matching lines @@
 
   /**
    * Return the [AstProvider] for the given [path].
    */
   AstProvider getAstProvider(String path) {
     nd.AnalysisDriver analysisDriver = getAnalysisDriver(path);
     return new AstProviderForDriver(analysisDriver);
   }
 
   /**
-   * Return the [AnalysisContext] for the "innermost" context whose associated
-   * folder is or contains the given path.  ("innermost" refers to the nesting
-   * of contexts, so if there is a context for path /foo and a context for
-   * path /foo/bar, then the innermost context containing /foo/bar/baz.dart is
-   * the context for /foo/bar.)
-   *
-   * If no context contains the given path, `null` is returned.
-   */
-  AnalysisContext getContainingContext(String path) {
-    return contextManager.getContextFor(path);
-  }
-
-  /**
    * Return the [nd.AnalysisDriver] for the "innermost" context whose associated
    * folder is or contains the given path.  ("innermost" refers to the nesting
    * of contexts, so if there is a context for path /foo and a context for
    * path /foo/bar, then the innermost context containing /foo/bar/baz.dart is
    * the context for /foo/bar.)
    *
    * If no context contains the given path, `null` is returned.
    */
   nd.AnalysisDriver getContainingDriver(String path) {
     return contextManager.getDriverFor(path);
@@ skipping 50 matching lines @@
   /**
    * Return a [Future] that completes with the resolved [CompilationUnit] for
    * the Dart file with the given [path], or with `null` if the file is not a
    * Dart file or cannot be resolved.
    */
   Future<CompilationUnit> getResolvedCompilationUnit(String path) async {
     nd.AnalysisResult result = await getAnalysisResult(path);
     return result?.unit;
   }
 
-// TODO(brianwilkerson) Add the following method after 'prioritySources' has
-// been added to InternalAnalysisContext.
-//  /**
-//   * Return a list containing the full names of all of the sources that are
-//   * priority sources.
-//   */
-//  List<String> getPriorityFiles() {
-//    List<String> priorityFiles = new List<String>();
-//    folderMap.values.forEach((ContextDirectory directory) {
-//      InternalAnalysisContext context = directory.context;
-//      context.prioritySources.forEach((Source source) {
-//        priorityFiles.add(source.fullName);
-//      });
-//    });
-//    return priorityFiles;
-//  }
-
   /**
    * Handle a [request] that was read from the communication channel.
    */
   void handleRequest(Request request) {
     _performance.logRequest(request);
     runZoned(() {
       ServerPerformanceStatistics.serverRequests.makeCurrentWhile(() {
         int count = handlers.length;
         for (int i = 0; i < count; i++) {
           try {
@@ skipping 117 matching lines @@
 
   /**
    * Trigger reanalysis of all files in the given list of analysis [roots], or
    * everything if the analysis roots is `null`.
    */
   void reanalyze(List<Resource> roots) {
     // Clear any operations that are pending.
     if (roots == null) {
       operationQueue.clear();
     } else {
-      for (AnalysisContext context in _getContexts(roots)) {
-        operationQueue.contextRemoved(context);
-      }
+      // TODO(brianwilkerson) All of the contexts returned by _getContexts will
+      // be null. If we are still using the operation queue, then this needs to
+      // be changed to use drivers.
+//      for (AnalysisContext context in _getContexts(roots)) {
+//        operationQueue.contextRemoved(context);
+//      }
     }
     // Instruct the contextDirectoryManager to rebuild all contexts from
     // scratch.
     contextManager.refresh(roots);
   }
 
   /**
    * Schedule cache consistency validation in [context].
    * The most of the validation must be done asynchronously.
    */
@@ skipping 367 matching lines @@
     if (resourceProvider is PhysicalResourceProvider) {
       Folder stateLocation =
           resourceProvider.getStateLocation('.analysis-driver');
       if (stateLocation != null) {
         return stateLocation.path;
       }
     }
     return null;
   }
 
-  /**
-   * Return a set of all contexts whose associated folder is contained within,
-   * or equal to, one of the resources in the given list of [resources].
-   */
-  Set<AnalysisContext> _getContexts(List<Resource> resources) {
-    Set<AnalysisContext> contexts = new HashSet<AnalysisContext>();
-    resources.forEach((Resource resource) {
-      if (resource is Folder) {
-        contexts.addAll(contextManager.contextsInAnalysisRoot(resource));
-      }
-    });
-    return contexts;
-  }
-
   bool _hasAnalysisServiceSubscription(AnalysisService service, String file) {
     return analysisServices[service]?.contains(file) ?? false;
   }
 
   _scheduleAnalysisImplementedNotification() async {
     Set<String> files = analysisServices[AnalysisService.IMPLEMENTED];
     if (files != null) {
       scheduleImplementedNotification(this, files);
     }
   }
@@ skipping 30 matching lines @@
    * Listen for context events and invalidate index.
    *
    * It is possible that this method will do more in the future, e.g. listening
    * for summary information and linking pre-indexed packages into the index,
    * but for now we only invalidate project specific index information.
    */
   void _setupIndexInvalidation() {
     if (index == null) {
       return;
     }
-    onContextsChanged.listen((ContextsChangedEvent event) {
-      // TODO(brianwilkerson) `onContextsChanged` should never have anything
-      // written to it. Figure out whether we need something like this under the
-      // new analysis driver, and remove this method if not.
+    // TODO(brianwilkerson) onContextsChanged never has anything written to it.
+    // Figure out whether we need something like this under the new analysis
+    // driver, and remove this method if not.
+//    onContextsChanged.listen((ContextsChangedEvent event) {
 //      for (AnalysisContext context in event.added) {
 //        context
 //            .onResultChanged(RESOLVED_UNIT3)
 //            .listen((ResultChangedEvent event) {
 //          if (event.wasComputed) {
 //            Object value = event.value;
 //            if (value is CompilationUnit) {
 //              index.indexDeclarations(value);
 //            }
 //          }
 //        });
 //        context
 //            .onResultChanged(RESOLVED_UNIT)
 //            .listen((ResultChangedEvent event) {
 //          if (event.wasInvalidated) {
 //            LibrarySpecificUnit target = event.target;
 //            index.removeUnit(event.context, target.library, target.unit);
 //          }
 //        });
 //      }
 //      for (AnalysisContext context in event.removed) {
 //        index.removeContext(context);
 //      }
-    });
+//    });
   }
 }
 
 class AnalysisServerOptions {
   bool enableIncrementalResolutionApi = false;
   bool enableIncrementalResolutionValidation = false;
   bool useAnalysisHighlight2 = false;
   String fileReadMode = 'as-is';
   String newAnalysisDriverLog;
 
   String clientId;
   String clientVersion;
 
   // IDE options
   bool enableVerboseFlutterCompletions = false;
 }
 
 /**
- * Information about a file - an [AnalysisContext] that analyses the file,
- * and the [Source] representing the file in this context.
- */
-class ContextSourcePair {
-  /**
-   * A context that analysis the file.
-   * May be `null` if the file is not analyzed by any context.
-   */
-  final AnalysisContext context;
-
-  /**
-   * The source that corresponds to the file.
-   * May be `null` if the file is not a regular file.
-   * If the file cannot be found in the [context], then it has a `file` uri.
-   */
-  final Source source;
-
-  ContextSourcePair(this.context, this.source);
-}
-
-/**
  * A [PriorityChangeEvent] indicates the set the priority files has changed.
  */
 class PriorityChangeEvent {
   final Source firstSource;
 
   PriorityChangeEvent(this.firstSource);
 }
 
 class ServerContextManagerCallbacks extends ContextManagerCallbacks {
   final AnalysisServer analysisServer;
@@ skipping 111 matching lines @@
       if (result.contextKey != null) {
         message += ' context: ${result.contextKey}';
       }
       AnalysisEngine.instance.logger.logError(message, result.exception);
     });
     analysisServer.driverMap[folder] = analysisDriver;
     return analysisDriver;
   }
 
   @override
-  AnalysisContext addContext(Folder folder, AnalysisOptions options) {
-    ContextBuilder builder = createContextBuilder(folder, options);
-    AnalysisContext context = builder.buildContext(folder.path);
-
-    analysisServer.folderMap[folder] = context;
-    analysisServer._onContextsChangedController
-        .add(new ContextsChangedEvent(added: [context]));
-    analysisServer.schedulePerformAnalysisOperation(context);
-
-    return context;
-  }
-
-  @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     nd.AnalysisDriver analysisDriver = analysisServer.driverMap[contextFolder];
     if (analysisDriver != null) {
       changeSet.addedSources.forEach((source) {
         analysisDriver.addFile(source.fullName);
         // temporary plugin support:
         analysisServer._onFileAddedController.add(source.fullName);
       });
       changeSet.changedSources.forEach((source) {
         analysisDriver.changeFile(source.fullName);
@@ skipping 61 matching lines @@
     // Context managers manage folders and contexts themselves.
   }
 
   @override
   void removeContext(Folder folder, List<String> flushedFiles) {
     sendAnalysisNotificationFlushResults(analysisServer, flushedFiles);
     nd.AnalysisDriver driver = analysisServer.driverMap.remove(folder);
     driver.dispose();
   }
 
-  @override
-  void updateContextPackageUriResolver(AnalysisContext context) {
-    analysisServer._onContextsChangedController
-        .add(new ContextsChangedEvent(changed: [context]));
-    analysisServer.schedulePerformAnalysisOperation(context);
-  }
-
   List<HighlightRegion> _computeHighlightRegions(CompilationUnit unit) {
     if (analysisServer.options.useAnalysisHighlight2) {
       return new DartUnitHighlightsComputer2(unit).compute();
     } else {
       return new DartUnitHighlightsComputer(unit).compute();
     }
   }
 
   String _computeLibraryName(CompilationUnit unit) {
     for (Directive directive in unit.directives) {
@@ skipping 180 matching lines @@
   /**
    * The [PerformanceTag] for time spent in server request handlers.
    */
   static PerformanceTag serverRequests = server.createChild('requests');
 
   /**
    * The [PerformanceTag] for time spent in split store microtasks.
    */
   static PerformanceTag splitStore = new PerformanceTag('splitStore');
 }