Remove ability to disable new analysis driver

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 17 matching lines @@
 import 'package:analysis_server/src/operation/operation_queue.dart';
 import 'package:analysis_server/src/plugin/notification_manager.dart';
 import 'package:analysis_server/src/plugin/plugin_manager.dart';
 import 'package:analysis_server/src/plugin/plugin_watcher.dart';
 import 'package:analysis_server/src/plugin/server_plugin.dart';
 import 'package:analysis_server/src/protocol_server.dart' as server;
 import 'package:analysis_server/src/server/diagnostic_server.dart';
 import 'package:analysis_server/src/services/correction/namespace.dart';
 import 'package:analysis_server/src/services/index/index.dart';
 import 'package:analysis_server/src/services/search/search_engine.dart';
-import 'package:analysis_server/src/services/search/search_engine_internal.dart';
 import 'package:analysis_server/src/services/search/search_engine_internal2.dart';
 import 'package:analysis_server/src/single_context_manager.dart';
 import 'package:analysis_server/src/utilities/null_string_sink.dart';
 import 'package:analyzer/context/context_root.dart';
 import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/dart/ast/standard_resolution_map.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/physical_file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/pub_package_map_provider.dart';
 import 'package:analyzer/src/context/builder.dart';
-import 'package:analyzer/src/dart/analysis/ast_provider_context.dart';
 import 'package:analyzer/src/dart/analysis/ast_provider_driver.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart' as nd;
 import 'package:analyzer/src/dart/analysis/file_state.dart' as nd;
 import 'package:analyzer/src/dart/analysis/status.dart' as nd;
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/ast_provider.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
-import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/util/glob.dart';
-import 'package:analyzer/task/dart.dart';
 import 'package:analyzer_plugin/protocol/protocol_common.dart' hide Element;
 import 'package:front_end/src/base/performace_logger.dart';
 import 'package:front_end/src/incremental/byte_store.dart';
 import 'package:front_end/src/incremental/file_byte_store.dart';
 import 'package:plugin/plugin.dart';
 import 'package:watcher/watcher.dart';
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);
 
 /**
@@ skipping 196 matching lines @@
    * The controller that is notified when analysis is started.
    */
   StreamController<bool> _onAnalysisStartedController;
 
   /**
    * The controller that is notified when a single file has been analyzed.
    */
   StreamController<ChangeNotice> _onFileAnalyzedController;
 
   /**
-   * The controller used to notify others when priority sources change.
-   */
-  StreamController<PriorityChangeEvent> _onPriorityChangeController;
-
-  /**
    * True if any exceptions thrown by analysis should be propagated up the call
    * stack.
    */
   bool rethrowExceptions;
 
   /**
    * The next time (milliseconds since epoch) after which the analysis server
    * should pause so that pending requests can be fetched by the system.
    */
   // Add 1 sec to prevent delay from impacting short running tests
@@ skipping 163 matching lines @@
       contextManager = new SingleContextManager(resourceProvider, sdkManager,
           packageResolverProvider, analyzedFilesGlobs, defaultContextOptions);
     } else {
       contextManager = new ContextManagerImpl(
           resourceProvider,
           sdkManager,
           packageResolverProvider,
           packageMapProvider,
           analyzedFilesGlobs,
           instrumentationService,
-          defaultContextOptions,
-          options.enableNewAnalysisDriver);
+          defaultContextOptions);
     }
     this.fileResolverProvider = fileResolverProvider;
     this.packageResolverProvider = packageResolverProvider;
     ServerContextManagerCallbacks contextManagerCallbacks =
         new ServerContextManagerCallbacks(this, resourceProvider);
     contextManager.callbacks = contextManagerCallbacks;
     AnalysisEngine.instance.logger = new AnalysisLogger(this);
     _onAnalysisStartedController = new StreamController.broadcast();
     _onFileAnalyzedController = new StreamController.broadcast();
     // temporary plugin support:
     _onFileAddedController = new StreamController.broadcast();
     // temporary plugin support:
     _onFileChangedController = new StreamController.broadcast();
-    _onPriorityChangeController =
-        new StreamController<PriorityChangeEvent>.broadcast();
     running = true;
     onAnalysisStarted.first.then((_) {
       onAnalysisComplete.then((_) {
         performanceAfterStartup = new ServerPerformance();
         _performance = performanceAfterStartup;
       });
     });
     _setupIndexInvalidation();
-    if (options.enableNewAnalysisDriver) {
-      searchEngine = new SearchEngineImpl2(driverMap.values);
-    } else if (index != null) {
-      searchEngine = new SearchEngineImpl(index, getAstProvider);
-    }
+    searchEngine = new SearchEngineImpl2(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
@@ skipping 73 matching lines @@
   Stream get onFileAnalyzed => _onFileAnalyzedController.stream;
 
   /**
    * The stream that is notified when a single file has been changed. This
    * exists as a temporary stopgap for plugins, until the official plugin API is
    * complete.
    */
   Stream get onFileChanged => _onFileChangedController.stream;
 
   /**
-   * The stream that is notified when priority sources change.
-   */
-  Stream<PriorityChangeEvent> get onPriorityChange =>
-      _onPriorityChangeController.stream;
-
-  /**
    * The [Future] that completes when the next operation is performed.
    */
   Future get test_onOperationPerformed {
     if (_test_onOperationPerformedCompleter == null) {
       _test_onOperationPerformedCompleter = new Completer();
     }
     return _test_onOperationPerformedCompleter.future;
   }
 
   /**
@@ skipping 47 matching lines @@
   DartSdk findSdk() {
     DartSdk sdk = sdkManager.anySdk;
     if (sdk != null) {
       return sdk;
     }
     // TODO(brianwilkerson) Should we create an SDK using the default options?
     return null;
   }
 
   /**
-   * Return the preferred [AnalysisContext] for analyzing the given [path].
-   * This will be the context that explicitly contains the path, if any such
-   * context exists, otherwise it will be the first analysis context that
-   * implicitly analyzes it.  Return `null` if no context is analyzing the
-   * path.
-   */
-  AnalysisContext getAnalysisContext(String path) {
-    return getContextSourcePair(path).context;
-  }
-
-  /**
-   * Return any [AnalysisContext] that is analyzing the given [source], either
-   * explicitly or implicitly.  Return `null` if there is no such context.
-   */
-  AnalysisContext getAnalysisContextForSource(Source source) {
-    for (AnalysisContext context in analysisContexts) {
-      SourceKind kind = context.getKindOf(source);
-      if (kind != SourceKind.UNKNOWN) {
-        return context;
-      }
-    }
-    return null;
-  }
-
-  /**
    * Return an analysis driver to which the file with the given [path] is
    * added if one exists, otherwise a driver in which the file was analyzed if
    * one exists, otherwise the first driver, otherwise `null`.
    */
   nd.AnalysisDriver getAnalysisDriver(String path) {
     List<nd.AnalysisDriver> drivers = driverMap.values.toList();
     if (drivers.isNotEmpty) {
       // Sort the drivers so that more deeply nested contexts will be checked
       // before enclosing contexts.
       drivers.sort((first, second) =>
@@ skipping 27 matching lines @@
       // Ignore the exception.
       // We don't want to log the same exception again and again.
       return null;
     }
   }
 
   /**
    * Return the [AstProvider] for the given [path].
    */
   AstProvider getAstProvider(String path) {
-    if (options.enableNewAnalysisDriver) {
-      var analysisDriver = getAnalysisDriver(path);
-      return new AstProviderForDriver(analysisDriver);
-    } else {
-      var analysisContext = getAnalysisContext(path);
-      return new AstProviderForContext(analysisContext);
-    }
-  }
-
-  CompilationUnitElement getCompilationUnitElement(String file) {
-    ContextSourcePair pair = getContextSourcePair(file);
-    if (pair == null) {
-      return null;
-    }
-    // prepare AnalysisContext and Source
-    AnalysisContext context = pair.context;
-    Source unitSource = pair.source;
-    if (context == null || unitSource == null) {
-      return null;
-    }
-    // get element in the first library
-    List<Source> librarySources = context.getLibrariesContaining(unitSource);
-    if (!librarySources.isNotEmpty) {
-      return null;
-    }
-    Source librarySource = librarySources.first;
-    return context.getCompilationUnitElement(unitSource, librarySource);
+    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);
   }
 
   /**
-   * Return the primary [ContextSourcePair] representing the given [path].
-   *
-   * The [AnalysisContext] of this pair will be the context that explicitly
-   * contains the path, if any such context exists, otherwise it will be the
-   * first context that implicitly analyzes it.
-   *
-   * If the [path] is not analyzed by any context, a [ContextSourcePair] with
-   * a `null` context and a `file` [Source] is returned.
-   *
-   * If the [path] doesn't represent a file, a [ContextSourcePair] with a `null`
-   * context and `null` [Source] is returned.
-   *
-   * Does not return `null`.
-   */
-  ContextSourcePair getContextSourcePair(String path) {
-    // try SDK
-    {
-      DartSdk sdk = findSdk();
-      if (sdk != null) {
-        Uri uri = resourceProvider.pathContext.toUri(path);
-        Source sdkSource = sdk.fromFileUri(uri);
-        if (sdkSource != null) {
-          return new ContextSourcePair(sdk.context, sdkSource);
-        }
-      }
-    }
-    // try to find the deep-most containing context
-    Resource resource = resourceProvider.getResource(path);
-    if (resource is! File) {
-      return new ContextSourcePair(null, null);
-    }
-    File file = resource;
-    {
-      AnalysisContext containingContext = getContainingContext(path);
-      if (containingContext != null) {
-        Source source =
-            ContextManagerImpl.createSourceInContext(containingContext, file);
-        return new ContextSourcePair(containingContext, source);
-      }
-    }
-    // try to find a context that analysed the file
-    for (AnalysisContext context in analysisContexts) {
-      Source source = ContextManagerImpl.createSourceInContext(context, file);
-      SourceKind kind = context.getKindOf(source);
-      if (kind != SourceKind.UNKNOWN) {
-        return new ContextSourcePair(context, source);
-      }
-    }
-    // try to find a context for which the file is a priority source
-    for (InternalAnalysisContext context in analysisContexts) {
-      List<Source> sources = context.getSourcesWithFullName(path);
-      if (sources.isNotEmpty) {
-        Source source = sources.first;
-        return new ContextSourcePair(context, source);
-      }
-    }
-    // file-based source
-    Source fileSource = file.createSource();
-    return new ContextSourcePair(null, fileSource);
-  }
-
-  /**
    * Return a [Future] that completes with the [Element] at the given
    * [offset] of the given [file], or with `null` if there is no node at the
    * [offset] or the node does not have an element.
    */
   Future<Element> getElementAtOffset(String file, int offset) async {
     AstNode node = await getNodeAtOffset(file, offset);
     return getElementOfNode(node);
   }
 
   /**
@@ skipping 14 matching lines @@
       return null;
     }
     Element element = ElementLocator.locate(node);
     if (node is SimpleIdentifier && element is PrefixElement) {
       element = getImportElement(node);
     }
     return element;
   }
 
   /**
-   * Return an analysis error info containing the array of all of the errors and
-   * the line info associated with [file].
-   *
-   * Returns `null` if [file] does not belong to any [AnalysisContext], or the
-   * file does not exist.
-   *
-   * The array of errors will be empty if there are no errors in [file]. The
-   * errors contained in the array can be incomplete.
-   *
-   * This method does not wait for all errors to be computed, and returns just
-   * the current state.
-   */
-  AnalysisErrorInfo getErrors(String file) {
-    ContextSourcePair contextSource = getContextSourcePair(file);
-    AnalysisContext context = contextSource.context;
-    Source source = contextSource.source;
-    if (context == null) {
-      return null;
-    }
-    if (!context.exists(source)) {
-      return null;
-    }
-    return context.getErrors(source);
-  }
-
-  /**
    * Return a [Future] that completes with the resolved [AstNode] at the
    * given [offset] of the given [file], or with `null` if there is no node as
    * the [offset].
    */
   Future<AstNode> getNodeAtOffset(String file, int offset) async {
-    CompilationUnit unit;
-    if (options.enableNewAnalysisDriver) {
-      nd.AnalysisResult result = await getAnalysisResult(file);
-      unit = result?.unit;
-    } else {
-      unit = await getResolvedCompilationUnit(file);
-    }
+    nd.AnalysisResult result = await getAnalysisResult(file);
+    CompilationUnit unit = result?.unit;
     if (unit != null) {
       return new NodeLocator(offset).searchWithin(unit);
     }
     return null;
   }
 
   /**
    * 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 {
-    if (options.enableNewAnalysisDriver) {
-      nd.AnalysisResult result = await getAnalysisResult(path);
-      return result?.unit;
-    }
-    ContextSourcePair contextSource = getContextSourcePair(path);
-    AnalysisContext context = contextSource.context;
-    if (context == null) {
-      return null;
-    }
-    return runWithActiveContext(context, () {
-      Source unitSource = contextSource.source;
-      List<Source> librarySources = context.getLibrariesContaining(unitSource);
-      for (Source librarySource in librarySources) {
-        return context.resolveCompilationUnit2(unitSource, librarySource);
-      }
-      return null;
-    });
+    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>();
@@ skipping 68 matching lines @@
   /**
    * Return `true` if the given path is a valid `FilePath`.
    *
    * This means that it is absolute and normalized.
    */
   bool isValidFilePath(String path) {
     return resourceProvider.absolutePathContext.isValid(path);
   }
 
   /**
-   * Returns a [Future] completing when [file] has been completely analyzed, in
-   * particular, all its errors have been computed.  The future is completed
-   * with an [AnalysisDoneReason] indicating what caused the file's analysis to
-   * be considered complete.
-   *
-   * If the given file doesn't belong to any context, null is returned.
-   *
-   * TODO(scheglov) this method should be improved.
-   *
-   * 1. The analysis context should be told to analyze this particular file ASAP.
-   *
-   * 2. We should complete the future as soon as the file is analyzed (not wait
-   *    until the context is completely finished)
-   */
-  Future<AnalysisDoneReason> onFileAnalysisComplete(String file) {
-    // prepare AnalysisContext
-    AnalysisContext context = getAnalysisContext(file);
-    if (context == null) {
-      return null;
-    }
-    // done if everything is already analyzed
-    if (isAnalysisComplete()) {
-      return new Future.value(AnalysisDoneReason.COMPLETE);
-    }
-    // schedule context analysis
-    schedulePerformAnalysisOperation(context);
-    // associate with the context completer
-    Completer<AnalysisDoneReason> completer =
-        contextAnalysisDoneCompleters[context];
-    if (completer == null) {
-      completer = new Completer<AnalysisDoneReason>();
-      contextAnalysisDoneCompleters[context] = completer;
-    }
-    return completer.future;
-  }
-
-  /**
    * Perform the next available [ServerOperation].
    */
   void performOperation() {
     assert(performOperationPending);
     PerformanceTag.unknown.makeCurrent();
     performOperationPending = false;
     if (!running) {
       // An error has occurred, or the connection to the client has been
       // closed, since this method was scheduled on the event queue.  So
       // don't do anything.  Instead clear the operation queue.
@@ skipping 240 matching lines @@
   }
 
   /**
    * Implementation for `analysis.setSubscriptions`.
    */
   void setAnalysisSubscriptions(
       Map<AnalysisService, Set<String>> subscriptions) {
     if (notificationManager != null) {
       notificationManager.setSubscriptions(subscriptions);
     }
-    if (options.enableNewAnalysisDriver) {
-      this.analysisServices = subscriptions;
-      Set<String> allNewFiles =
-          subscriptions.values.expand((files) => files).toSet();
-      for (String file in allNewFiles) {
-        // The result will be produced by the "results" stream with
-        // the fully resolved unit, and processed with sending analysis
-        // notifications as it happens after content changes.
-        if (AnalysisEngine.isDartFileName(file)) {
-          getAnalysisResult(file);
-        }
+    this.analysisServices = subscriptions;
+    Set<String> allNewFiles =
+        subscriptions.values.expand((files) => files).toSet();
+    for (String file in allNewFiles) {
+      // The result will be produced by the "results" stream with
+      // the fully resolved unit, and processed with sending analysis
+      // notifications as it happens after content changes.
+      if (AnalysisEngine.isDartFileName(file)) {
+        getAnalysisResult(file);
       }
-      return;
-    }
-    // send notifications for already analyzed sources
-    subscriptions.forEach((service, Set<String> newFiles) {
-      Set<String> oldFiles = analysisServices[service];
-      Set<String> todoFiles =
-          oldFiles != null ? newFiles.difference(oldFiles) : newFiles;
-      for (String file in todoFiles) {
-        if (contextManager.isIgnored(file)) {
-          continue;
-        }
-        // prepare context
-        ContextSourcePair contextSource = getContextSourcePair(file);
-        AnalysisContext context = contextSource.context;
-        if (context == null) {
-          continue;
-        }
-        Source source = contextSource.source;
-        // Ensure that if the AST is flushed / not ready, it will be
-        // computed eventually.
-        if (AnalysisEngine.isDartFileName(file)) {
-          (context as InternalAnalysisContext).ensureResolvedDartUnits(source);
-        }
-        // Send notifications that don't directly take an AST.
-        switch (service) {
-          case AnalysisService.NAVIGATION:
-            sendAnalysisNotificationNavigation(this, context, source);
-            continue;
-          case AnalysisService.OCCURRENCES:
-            sendAnalysisNotificationOccurrences(this, context, source);
-            continue;
-        }
-        // Dart unit notifications.
-        if (AnalysisEngine.isDartFileName(file)) {
-          // TODO(scheglov) This way to get resolved information is very Dart
-          // specific. OTOH as it is planned now Angular results are not
-          // flushable.
-          CompilationUnit dartUnit =
-              _getResolvedCompilationUnitToResendNotification(context, source);
-          if (dartUnit != null) {
-            switch (service) {
-              case AnalysisService.HIGHLIGHTS:
-                sendAnalysisNotificationHighlights(this, file, dartUnit);
-                break;
-              case AnalysisService.OUTLINE:
-                AnalysisContext context = resolutionMap
-                    .elementDeclaredByCompilationUnit(dartUnit)
-                    .context;
-                LineInfo lineInfo = context.getLineInfo(source);
-                SourceKind kind = context.getKindOf(source);
-                sendAnalysisNotificationOutline(
-                    this, file, lineInfo, kind, dartUnit);
-                break;
-              case AnalysisService.OVERRIDES:
-                sendAnalysisNotificationOverrides(this, file, dartUnit);
-                break;
-            }
-          }
-        }
-      }
-    });
-    // remember new subscriptions
-    this.analysisServices = subscriptions;
-    // special case for implemented elements
-    if (analysisServices.containsKey(AnalysisService.IMPLEMENTED) &&
-        isAnalysisComplete()) {
-      _scheduleAnalysisImplementedNotification();
     }
   }
 
   /**
    * Implementation for `analysis.setGeneralSubscriptions`.
    */
   void setGeneralAnalysisSubscriptions(
       List<GeneralAnalysisService> subscriptions) {
     Set<GeneralAnalysisService> newServices = subscriptions.toSet();
     if (newServices.contains(GeneralAnalysisService.ANALYZED_FILES) &&
         !generalAnalysisServices
             .contains(GeneralAnalysisService.ANALYZED_FILES) &&
         isAnalysisComplete()) {
       sendAnalysisNotificationAnalyzedFiles(this);
     } else if (!newServices.contains(GeneralAnalysisService.ANALYZED_FILES) &&
         generalAnalysisServices
             .contains(GeneralAnalysisService.ANALYZED_FILES)) {
       prevAnalyzedFiles = null;
     }
     generalAnalysisServices = newServices;
   }
 
   /**
    * Set the priority files to the given [files].
    */
   void setPriorityFiles(String requestId, List<String> files) {
-    if (options.enableNewAnalysisDriver) {
-      priorityFiles.clear();
-      priorityFiles.addAll(files);
-      // Set priority files in drivers.
-      driverMap.values.forEach((driver) {
-        driver.priorityFiles = files;
-      });
-      return;
-    }
-    // Note: when a file is a priority file, that information needs to be
-    // propagated to all contexts that analyze the file, so that all contexts
-    // will be able to do incremental resolution of the file.  See
-    // dartbug.com/22209.
-    Map<AnalysisContext, List<Source>> sourceMap =
-        new HashMap<AnalysisContext, List<Source>>();
-    List<String> unanalyzed = new List<String>();
-    Source firstSource = null;
-    files.forEach((String file) {
-      if (contextManager.isIgnored(file)) {
-        unanalyzed.add(file);
-        return;
-      }
-      // Prepare the context/source pair.
-      ContextSourcePair contextSource = getContextSourcePair(file);
-      AnalysisContext preferredContext = contextSource.context;
-      Source source = contextSource.source;
-      // Try to make the file analyzable.
-      // If it is not in any context yet, add it to the first one which
-      // could use it, e.g. imports its package, even if not the library.
-      if (preferredContext == null) {
-        Resource resource = resourceProvider.getResource(file);
-        if (resource is File && resource.exists) {
-          for (AnalysisContext context in analysisContexts) {
-            Uri uri = context.sourceFactory.restoreUri(source);
-            if (uri.scheme != 'file') {
-              preferredContext = context;
-              source =
-                  ContextManagerImpl.createSourceInContext(context, resource);
-              break;
-            }
-          }
-        }
-      }
-      // Fill the source map.
-      bool contextFound = false;
-      if (preferredContext != null) {
-        sourceMap.putIfAbsent(preferredContext, () => <Source>[]).add(source);
-        contextFound = true;
-      }
-      for (AnalysisContext context in analysisContexts) {
-        if (context != preferredContext &&
-            context.getKindOf(source) != SourceKind.UNKNOWN) {
-          sourceMap.putIfAbsent(context, () => <Source>[]).add(source);
-          contextFound = true;
-        }
-      }
-      if (firstSource == null) {
-        firstSource = source;
-      }
-      if (!contextFound) {
-        unanalyzed.add(file);
-      }
+    priorityFiles.clear();
+    priorityFiles.addAll(files);
+    // Set priority files in drivers.
+    driverMap.values.forEach((driver) {
+      driver.priorityFiles = files;
     });
-    if (unanalyzed.isNotEmpty) {
-      StringBuffer buffer = new StringBuffer();
-      buffer.writeAll(unanalyzed, ', ');
-      throw new RequestFailure(
-          new Response.unanalyzedPriorityFiles(requestId, buffer.toString()));
-    }
-    sourceMap.forEach((context, List<Source> sourceList) {
-      context.analysisPriorityOrder = sourceList;
-      // Schedule the context for analysis so that it has the opportunity to
-      // cache the AST's for the priority sources as soon as possible.
-      schedulePerformAnalysisOperation(context);
-    });
-    operationQueue.reschedule();
-    _onPriorityChangeController.add(new PriorityChangeEvent(firstSource));
   }
 
   /**
    * Returns `true` if errors should be reported for [file] with the given
    * absolute path.
    */
   bool shouldSendErrorsNotificationFor(String file) {
     return contextManager.isInAnalysisRoot(file);
   }
 
   void shutdown() {
     running = false;
     if (index != null) {
       index.stop();
     }
     // Defer closing the channel and shutting down the instrumentation server so
     // that the shutdown response can be sent and logged.
     new Future(() {
       instrumentationService.shutdown();
       channel.close();
     });
   }
 
-  void test_flushAstStructures(String file) {
-    if (AnalysisEngine.isDartFileName(file)) {
-      ContextSourcePair contextSource = getContextSourcePair(file);
-      InternalAnalysisContext context = contextSource.context;
-      Source source = contextSource.source;
-      context.test_flushAstStructures(source);
-    }
-  }
-
   /**
    * Performs all scheduled analysis operations.
    */
   void test_performAllAnalysisOperations() {
     while (true) {
       ServerOperation operation = operationQueue.takeIf((operation) {
         return operation is PerformAnalysisOperation;
       });
       if (operation == null) {
         break;
       }
       operation.perform(this);
     }
   }
 
   /**
    * Implementation for `analysis.updateContent`.
    */
   void updateContent(String id, Map<String, dynamic> changes) {
-    if (options.enableNewAnalysisDriver) {
-      changes.forEach((file, change) {
-        // Prepare the new contents.
-        String oldContents = fileContentOverlay[file];
-        String newContents;
-        if (change is AddContentOverlay) {
-          newContents = change.content;
-        } else if (change is ChangeContentOverlay) {
-          if (oldContents == null) {
-            // The client may only send a ChangeContentOverlay if there is
-            // already an existing overlay for the source.
-            throw new RequestFailure(new Response(id,
-                error: new RequestError(RequestErrorCode.INVALID_OVERLAY_CHANGE,
-                    'Invalid overlay change')));
-          }
-          try {
-            newContents = SourceEdit.applySequence(oldContents, change.edits);
-          } on RangeError {
-            throw new RequestFailure(new Response(id,
-                error: new RequestError(RequestErrorCode.INVALID_OVERLAY_CHANGE,
-                    'Invalid overlay change')));
-          }
-        } else if (change is RemoveContentOverlay) {
-          newContents = null;
-        } else {
-          // Protocol parsing should have ensured that we never get here.
-          throw new AnalysisException('Illegal change type');
-        }
-
-        fileContentOverlay[file] = newContents;
-
-        driverMap.values.forEach((driver) {
-          driver.changeFile(file);
-        });
-
-        // temporary plugin support:
-        _onFileChangedController.add(file);
-
-        // If the file did not exist, and is "overlay only", it still should be
-        // analyzed. Add it to driver to which it should have been added.
-        contextManager.getDriverFor(file)?.addFile(file);
-
-        // TODO(scheglov) implement other cases
-      });
-      return;
-    }
     changes.forEach((file, change) {
-      ContextSourcePair contextSource = getContextSourcePair(file);
-      Source source = contextSource.source;
-      operationQueue.sourceAboutToChange(source);
       // Prepare the new contents.
-      String oldContents = overlayState.getContents(source);
+      String oldContents = fileContentOverlay[file];
       String newContents;
       if (change is AddContentOverlay) {
         newContents = change.content;
       } else if (change is ChangeContentOverlay) {
         if (oldContents == null) {
           // The client may only send a ChangeContentOverlay if there is
           // already an existing overlay for the source.
           throw new RequestFailure(new Response(id,
               error: new RequestError(RequestErrorCode.INVALID_OVERLAY_CHANGE,
                   'Invalid overlay change')));
         }
         try {
           newContents = SourceEdit.applySequence(oldContents, change.edits);
         } on RangeError {
           throw new RequestFailure(new Response(id,
               error: new RequestError(RequestErrorCode.INVALID_OVERLAY_CHANGE,
                   'Invalid overlay change')));
         }
       } else if (change is RemoveContentOverlay) {
         newContents = null;
       } else {
         // Protocol parsing should have ensured that we never get here.
         throw new AnalysisException('Illegal change type');
       }
 
-      AnalysisContext containingContext = getContainingContext(file);
+      fileContentOverlay[file] = newContents;
 
-      // Check for an implicitly added but missing source.
-      // (For example, the target of an import might not exist yet.)
-      // We need to do this before setContents, which changes the stamp.
-      bool wasMissing = containingContext?.getModificationStamp(source) == -1;
+      driverMap.values.forEach((driver) {
+        driver.changeFile(file);
+      });
 
-      overlayState.setContents(source, newContents);
-      // If the source does not exist, then it was an overlay-only one.
-      // Remove it from contexts.
-      if (newContents == null && !source.exists()) {
-        for (InternalAnalysisContext context in analysisContexts) {
-          List<Source> sources = context.getSourcesWithFullName(file);
-          ChangeSet changeSet = new ChangeSet();
-          sources.forEach(changeSet.removedSource);
-          context.applyChanges(changeSet);
-          schedulePerformAnalysisOperation(context);
-        }
-        return;
-      }
-      // Update all contexts.
-      bool anyContextUpdated = false;
-      for (InternalAnalysisContext context in analysisContexts) {
-        List<Source> sources = context.getSourcesWithFullName(file);
-        sources.forEach((Source source) {
-          anyContextUpdated = true;
-          if (context == containingContext && wasMissing) {
-            // Promote missing source to an explicitly added Source.
-            context.applyChanges(new ChangeSet()..addedSource(source));
-            schedulePerformAnalysisOperation(context);
-          }
-          if (context.handleContentsChanged(
-              source, oldContents, newContents, true)) {
-            schedulePerformAnalysisOperation(context);
-          } else {
-            // When the client sends any change for a source, we should resend
-            // subscribed notifications, even if there were no changes in the
-            // source contents.
-            // TODO(scheglov) consider checking if there are subscriptions.
-            if (AnalysisEngine.isDartFileName(file)) {
-              List<CompilationUnit> dartUnits =
-                  context.ensureResolvedDartUnits(source);
-              if (dartUnits != null) {
-                AnalysisErrorInfo errorInfo = context.getErrors(source);
-                for (var dartUnit in dartUnits) {
-                  scheduleNotificationOperations(
-                      this,
-                      source,
-                      file,
-                      errorInfo.lineInfo,
-                      context,
-                      null,
-                      dartUnit,
-                      errorInfo.errors);
-                  scheduleIndexOperation(this, file, dartUnit);
-                }
-              } else {
-                schedulePerformAnalysisOperation(context);
-              }
-            }
-          }
-        });
-      }
-      // The source is not analyzed by any context, add to the containing one.
-      if (!anyContextUpdated) {
-        AnalysisContext context = contextSource.context;
-        if (context != null && source != null) {
-          ChangeSet changeSet = new ChangeSet();
-          changeSet.addedSource(source);
-          context.applyChanges(changeSet);
-          schedulePerformAnalysisOperation(context);
-        }
-      }
+      // temporary plugin support:
+      _onFileChangedController.add(file);
+
+      // If the file did not exist, and is "overlay only", it still should be
+      // analyzed. Add it to driver to which it should have been added.
+      contextManager.getDriverFor(file)?.addFile(file);
+
+      // TODO(scheglov) implement other cases
     });
   }
 
   /**
    * Use the given updaters to update the values of the options in every
    * existing analysis context.
    */
   void updateOptions(List<OptionUpdater> optionUpdaters) {
-    if (options.enableNewAnalysisDriver) {
-      // TODO(scheglov) implement for the new analysis driver
-      return;
-    }
-    //
-    // Update existing contexts.
-    //
-    for (AnalysisContext context in analysisContexts) {
-      AnalysisOptionsImpl options =
-          new AnalysisOptionsImpl.from(context.analysisOptions);
-      optionUpdaters.forEach((OptionUpdater optionUpdater) {
-        optionUpdater(options);
-      });
-      context.analysisOptions = options;
-      // TODO(brianwilkerson) As far as I can tell, this doesn't cause analysis
-      // to be scheduled for this context.
-    }
-    //
-    // Update the defaults used to create new contexts.
-    //
-    optionUpdaters.forEach((OptionUpdater optionUpdater) {
-      optionUpdater(defaultContextOptions);
-    });
+    // TODO(scheglov) implement for the new analysis driver
+//    //
+//    // Update existing contexts.
+//    //
+//    for (AnalysisContext context in analysisContexts) {
+//      AnalysisOptionsImpl options =
+//          new AnalysisOptionsImpl.from(context.analysisOptions);
+//      optionUpdaters.forEach((OptionUpdater optionUpdater) {
+//        optionUpdater(options);
+//      });
+//      context.analysisOptions = options;
+//      // TODO(brianwilkerson) As far as I can tell, this doesn't cause analysis
+//      // to be scheduled for this context.
+//    }
+//    //
+//    // Update the defaults used to create new contexts.
+//    //
+//    optionUpdaters.forEach((OptionUpdater optionUpdater) {
+//      optionUpdater(defaultContextOptions);
+//    });
   }
 
   void _computingPackageMap(bool computing) {
     if (serverServices.contains(ServerService.STATUS)) {
       PubStatus pubStatus = new PubStatus(computing);
       ServerStatusParams params = new ServerStatusParams(pub: pubStatus);
       sendNotification(params.toNotification());
     }
   }
 
@@ skipping 37 matching lines @@
   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;
   }
 
-  /**
-   * Returns the [CompilationUnit] of the Dart file with the given [source] that
-   * should be used to resend notifications for already resolved unit.
-   * Returns `null` if the file is not a part of any context, library has not
-   * been yet resolved, or any problem happened.
-   */
-  CompilationUnit _getResolvedCompilationUnitToResendNotification(
-      AnalysisContext context, Source source) {
-    List<Source> librarySources = context.getLibrariesContaining(source);
-    if (librarySources.isEmpty) {
-      return null;
-    }
-    // if library has not been resolved yet, the unit will be resolved later
-    Source librarySource = librarySources[0];
-    if (context.getResult(librarySource, LIBRARY_ELEMENT6) == null) {
-      return null;
-    }
-    // if library has been already resolved, resolve unit
-    return runWithActiveContext(context, () {
-      return context.resolveCompilationUnit2(source, librarySource);
-    });
-  }
-
   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 31 matching lines @@
    *
    * 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) {
-      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);
-      }
+      // 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.
+//      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 enableNewAnalysisDriver = false;
   bool useAnalysisHighlight2 = false;
   String fileReadMode = 'as-is';
   String newAnalysisDriverLog;
 
   String clientId;
   String clientVersion;
 
   // IDE options
   bool enableVerboseFlutterCompletions = false;
 }
@@ skipping 158 matching lines @@
     analysisServer.folderMap[folder] = context;
     analysisServer._onContextsChangedController
         .add(new ContextsChangedEvent(added: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
 
     return context;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
-    if (analysisServer.options.enableNewAnalysisDriver) {
-      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);
-          // temporary plugin support:
-          analysisServer._onFileChangedController.add(source.fullName);
-        });
-        changeSet.removedSources.forEach((source) {
-          analysisDriver.removeFile(source.fullName);
-        });
-      }
-    } else {
-      AnalysisContext context = analysisServer.folderMap[contextFolder];
-      if (context != null) {
-        context.applyChanges(changeSet);
-        analysisServer.schedulePerformAnalysisOperation(context);
-        List<String> flushedFiles = new List<String>();
-        for (Source source in changeSet.removedSources) {
-          flushedFiles.add(source.fullName);
-        }
-        sendAnalysisNotificationFlushResults(analysisServer, flushedFiles);
-      }
+    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);
+        // temporary plugin support:
+        analysisServer._onFileChangedController.add(source.fullName);
+      });
+      changeSet.removedSources.forEach((source) {
+        analysisDriver.removeFile(source.fullName);
+      });
     }
   }
 
   @override
   void applyFileRemoved(nd.AnalysisDriver driver, String file) {
     driver.removeFile(file);
     sendAnalysisNotificationFlushResults(analysisServer, [file]);
   }
 
   @override
@@ skipping 40 matching lines @@
 
   @override
   void moveContext(Folder from, Folder to) {
     // There is nothing to do.
     // This method is mostly for tests.
     // Context managers manage folders and contexts themselves.
   }
 
   @override
   void removeContext(Folder folder, List<String> flushedFiles) {
-    if (analysisServer.options.enableNewAnalysisDriver) {
-      sendAnalysisNotificationFlushResults(analysisServer, flushedFiles);
-      nd.AnalysisDriver driver = analysisServer.driverMap.remove(folder);
-      driver.dispose();
-    } else {
-      AnalysisContext context = analysisServer.folderMap.remove(folder);
-      sendAnalysisNotificationFlushResults(analysisServer, flushedFiles);
-
-      analysisServer.operationQueue.contextRemoved(context);
-      analysisServer._onContextsChangedController
-          .add(new ContextsChangedEvent(removed: [context]));
-      analysisServer.sendContextAnalysisDoneNotifications(
-          context, AnalysisDoneReason.CONTEXT_REMOVED);
-      context.dispose();
-    }
+    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) {
@@ skipping 189 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');
 }