Remove ability to disable new analysis driver

pkg/analysis_server/lib/src/context_manager.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:convert';
 import 'dart:core';
 
 import 'package:analyzer/context/context_root.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/source/package_map_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/source/path_filter.dart';
 import 'package:analyzer/source/pub_package_map_provider.dart';
 import 'package:analyzer/source/sdk_ext.dart';
 import 'package:analyzer/src/context/builder.dart';
-import 'package:analyzer/src/context/context.dart' as context;
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_io.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/task/options.dart';
 import 'package:analyzer/src/util/absolute_path.dart';
 import 'package:analyzer/src/util/glob.dart';
@@ skipping 490 matching lines @@
   /**
    * The default options used to create new analysis contexts.
    */
   final AnalysisOptionsImpl defaultContextOptions;
 
   /**
    * The instrumentation service used to report instrumentation data.
    */
   final InstrumentationService _instrumentationService;
 
-  final bool enableNewAnalysisDriver;
-
   @override
   ContextManagerCallbacks callbacks;
 
   /**
    * Virtual [ContextInfo] which acts as the ancestor of all other
    * [ContextInfo]s.
    */
   final ContextInfo rootInfo = new ContextInfo._root();
 
   @override
   final Map<Folder, AnalysisDriver> driverMap =
       new HashMap<Folder, AnalysisDriver>();
 
   /**
-   * A table mapping [Folder]s to the [AnalysisContext]s associated with them.
-   */
-  final Map<Folder, AnalysisContext> _folderMap =
-      new HashMap<Folder, AnalysisContext>();
-
-  /**
    * Stream subscription we are using to watch each analysis root directory for
    * changes.
    */
   final Map<Folder, StreamSubscription<WatchEvent>> changeSubscriptions =
       <Folder, StreamSubscription<WatchEvent>>{};
 
   ContextManagerImpl(
       this.resourceProvider,
       this.sdkManager,
       this.packageResolverProvider,
       this._packageMapProvider,
       this.analyzedFilesGlobs,
       this._instrumentationService,
-      this.defaultContextOptions,
-      this.enableNewAnalysisDriver) {
+      this.defaultContextOptions) {
     absolutePathContext = resourceProvider.absolutePathContext;
     pathContext = resourceProvider.pathContext;
   }
 
   @override
   Iterable<AnalysisContext> get analysisContexts => folderMap.values;
 
   Map<Folder, AnalysisContext> get folderMap {
-    if (enableNewAnalysisDriver) {
-      throw new StateError('Should not be used with the new analysis driver');
-    } else {
-      return _folderMap;
-    }
+    throw new StateError('Should not be used with the new analysis driver');
   }
 
   @override
   List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
     List<AnalysisContext> contexts = <AnalysisContext>[];
     ContextInfo innermostContainingInfo =
         _getInnermostContextInfoFor(analysisRoot.path);
     void addContextAndDescendants(ContextInfo info) {
       contexts.add(info.context);
       info.children.forEach(addContextAndDescendants);
@@ skipping 409 matching lines @@
           continue;
         }
         _addSourceFiles(changeSet, child, info);
       }
     }
   }
 
   void _checkForAnalysisOptionsUpdate(
       String path, ContextInfo info, ChangeType changeType) {
     if (AnalysisEngine.isAnalysisOptionsFileName(path, pathContext)) {
-      if (enableNewAnalysisDriver) {
-        AnalysisDriver driver = info.analysisDriver;
-        String contextRoot = info.folder.path;
-        ContextBuilder builder =
-            callbacks.createContextBuilder(info.folder, defaultContextOptions);
-        AnalysisOptions options = builder.getAnalysisOptions(contextRoot,
-            contextRoot: driver.contextRoot);
-        SourceFactory factory =
-            builder.createSourceFactory(contextRoot, options);
-        driver.configure(analysisOptions: options, sourceFactory: factory);
-        // TODO(brianwilkerson) Set exclusion patterns.
-      } else {
-        var analysisContext = info.context;
-        if (analysisContext is context.AnalysisContextImpl) {
-          Map<String, Object> options =
-              readOptions(info.folder, info.disposition.packages);
-          processOptionsForContext(info, options,
-              optionsRemoved: changeType == ChangeType.REMOVE);
-          analysisContext.sourceFactory = _createSourceFactory(
-              analysisContext, analysisContext.analysisOptions, info.folder);
-          callbacks.applyChangesToContext(info.folder, new ChangeSet());
-        }
-      }
+      AnalysisDriver driver = info.analysisDriver;
+      String contextRoot = info.folder.path;
+      ContextBuilder builder =
+          callbacks.createContextBuilder(info.folder, defaultContextOptions);
+      AnalysisOptions options = builder.getAnalysisOptions(contextRoot,
+          contextRoot: driver.contextRoot);
+      SourceFactory factory = builder.createSourceFactory(contextRoot, options);
+      driver.configure(analysisOptions: options, sourceFactory: factory);
+      // TODO(brianwilkerson) Set exclusion patterns.
     }
   }
 
   void _checkForPackagespecUpdate(
       String path, ContextInfo info, Folder folder) {
     // Check to see if this is the .packages file for this context and if so,
     // update the context's source factory.
     if (absolutePathContext.basename(path) == PACKAGE_SPEC_NAME) {
       String contextRoot = info.folder.path;
       ContextBuilder builder =
           callbacks.createContextBuilder(info.folder, defaultContextOptions);
       AnalysisOptions options = builder.getAnalysisOptions(contextRoot,
           contextRoot: info.analysisDriver?.contextRoot);
       SourceFactory factory = builder.createSourceFactory(contextRoot, options);
-      if (enableNewAnalysisDriver) {
-        AnalysisDriver driver = info.analysisDriver;
-        driver.configure(analysisOptions: options, sourceFactory: factory);
-      } else {
-        info.context.analysisOptions = options;
-        info.context.sourceFactory = factory;
-      }
+      AnalysisDriver driver = info.analysisDriver;
+      driver.configure(analysisOptions: options, sourceFactory: factory);
     }
   }
 
   /**
    * Compute the set of files that are being flushed, this is defined as
    * the set of sources in the removed context (context.sources), that are
    * orphaned by this context being removed (no other context includes this
    * file.)
    */
   List<String> _computeFlushedFiles(ContextInfo info) {
-    if (enableNewAnalysisDriver) {
-      Set<String> flushedFiles = info.analysisDriver.addedFiles.toSet();
-      for (ContextInfo contextInfo in rootInfo.descendants) {
-        AnalysisDriver other = contextInfo.analysisDriver;
-        if (other != info.analysisDriver) {
-          flushedFiles.removeAll(other.addedFiles);
-        }
+    Set<String> flushedFiles = info.analysisDriver.addedFiles.toSet();
+    for (ContextInfo contextInfo in rootInfo.descendants) {
+      AnalysisDriver other = contextInfo.analysisDriver;
+      if (other != info.analysisDriver) {
+        flushedFiles.removeAll(other.addedFiles);
       }
-      return flushedFiles.toList(growable: false);
-    } else {
-      AnalysisContext context = info.context;
-      HashSet<String> flushedFiles = new HashSet<String>();
-      for (Source source in context.sources) {
-        flushedFiles.add(source.fullName);
-      }
-      for (ContextInfo contextInfo in rootInfo.descendants) {
-        AnalysisContext contextN = contextInfo.context;
-        if (context != contextN) {
-          for (Source source in contextN.sources) {
-            flushedFiles.remove(source.fullName);
-          }
-        }
-      }
-      return flushedFiles.toList(growable: false);
     }
+    return flushedFiles.toList(growable: false);
   }
 
   /**
    * Compute the appropriate [FolderDisposition] for [folder].  Use
    * [addDependency] to indicate which files needed to be consulted in order to
    * figure out the [FolderDisposition]; these dependencies will be watched in
    * order to determine when it is necessary to call this function again.
    *
    * TODO(paulberry): use [addDependency] for tracking all folder disposition
    * dependencies (currently we only use it to track "pub list" dependencies).
@@ skipping 80 matching lines @@
     ContextInfo info = new ContextInfo(this, parent, folder, packagesFile,
         normalizedPackageRoots[folder.path], disposition);
 
     Map<String, Object> optionMap =
         readOptions(info.folder, disposition.packages);
     AnalysisOptions options =
         new AnalysisOptionsImpl.from(defaultContextOptions);
     applyToAnalysisOptions(options, optionMap);
 
     info.setDependencies(dependencies);
-    if (enableNewAnalysisDriver) {
-      String includedPath = folder.path;
-      List<String> containedExcludedPaths = excludedPaths
-          .where((String excludedPath) =>
-              pathContext.isWithin(includedPath, excludedPath))
-          .toList();
-      processOptionsForDriver(info, options, optionMap);
-      info.analysisDriver = callbacks.addAnalysisDriver(folder,
-          new ContextRoot(folder.path, containedExcludedPaths), options);
-    } else {
-      info.context = callbacks.addContext(folder, options);
-      _folderMap[folder] = info.context;
-      info.context.name = folder.path;
-      processOptionsForContext(info, optionMap);
-    }
-
+    String includedPath = folder.path;
+    List<String> containedExcludedPaths = excludedPaths
+        .where((String excludedPath) =>
+            pathContext.isWithin(includedPath, excludedPath))
+        .toList();
+    processOptionsForDriver(info, options, optionMap);
+    info.analysisDriver = callbacks.addAnalysisDriver(
+        folder, new ContextRoot(folder.path, containedExcludedPaths), options);
     return info;
   }
 
   /**
    * Potentially create a new context associated with the given [folder].
    *
    * If there are subfolders with 'pubspec.yaml' files, separate contexts are
    * created for them and excluded from the context associated with the
    * [folder].
    *
@@ skipping 247 matching lines @@
             }
           }
         }
 
         // If the file went away and was replaced by a folder before we
         // had a chance to process the event, resource might be a Folder.  In
         // that case don't add it.
         if (resource is File) {
           File file = resource;
           if (_shouldFileBeAnalyzed(file)) {
-            if (enableNewAnalysisDriver) {
-              info.analysisDriver.addFile(path);
-            } else {
-              ChangeSet changeSet = new ChangeSet();
-              Source source = createSourceInContext(info.context, file);
-              changeSet.addedSource(source);
-              callbacks.applyChangesToContext(info.folder, changeSet);
-              info.sources[path] = source;
-            }
+            info.analysisDriver.addFile(path);
           }
         }
         break;
       case ChangeType.REMOVE:
 
         // If package spec info is removed, check to see if we can merge contexts.
         // Note that it's important to verify that there is NEITHER a .packages nor a
         // lingering pubspec.yaml before merging.
         if (!info.isTopLevel) {
           String directoryPath = absolutePathContext.dirname(path);
@@ skipping 16 matching lines @@
                   .getFile(
                       absolutePathContext.append(directoryPath, PUBSPEC_NAME))
                   .exists) {
                 _mergeContext(info);
                 return;
               }
             }
           }
         }
 
-        if (enableNewAnalysisDriver) {
-          callbacks.applyFileRemoved(info.analysisDriver, path);
-        } else {
-          List<Source> sources = info.context.getSourcesWithFullName(path);
-          if (!sources.isEmpty) {
-            ChangeSet changeSet = new ChangeSet();
-            sources.forEach((Source source) {
-              changeSet.removedSource(source);
-            });
-            callbacks.applyChangesToContext(info.folder, changeSet);
-            info.sources.remove(path);
-          }
-        }
+        callbacks.applyFileRemoved(info.analysisDriver, path);
         break;
       case ChangeType.MODIFY:
-        if (enableNewAnalysisDriver) {
-          for (AnalysisDriver driver in driverMap.values) {
-            driver.changeFile(path);
-          }
-        } else {
-          List<Source> sources = info.context.getSourcesWithFullName(path);
-          if (!sources.isEmpty) {
-            ChangeSet changeSet = new ChangeSet();
-            sources.forEach((Source source) {
-              changeSet.changedSource(source);
-            });
-            callbacks.applyChangesToContext(info.folder, changeSet);
-          }
+        for (AnalysisDriver driver in driverMap.values) {
+          driver.changeFile(path);
         }
         break;
     }
     _checkForPackagespecUpdate(path, info, info.folder);
     _checkForAnalysisOptionsUpdate(path, info, type);
   }
 
   /**
    * Determine whether the given [path], when interpreted relative to the
    * context root [root], contains a folder whose name starts with '.'.
@@ skipping 139 matching lines @@
         } else {
           return null;
         }
       }
       return stringMap;
     }
     return null;
   }
 
   void _updateContextPackageUriResolver(Folder contextFolder) {
-    if (enableNewAnalysisDriver) {
-      ContextInfo info = getContextInfoFor(contextFolder);
-      AnalysisDriver driver = info.analysisDriver;
-      SourceFactory sourceFactory =
-          _createSourceFactory(null, driver.analysisOptions, contextFolder);
-      driver.configure(sourceFactory: sourceFactory);
-    } else {
-      AnalysisContext context = folderMap[contextFolder];
-      context.sourceFactory =
-          _createSourceFactory(context, context.analysisOptions, contextFolder);
-      callbacks.updateContextPackageUriResolver(context);
-    }
+    ContextInfo info = getContextInfoFor(contextFolder);
+    AnalysisDriver driver = info.analysisDriver;
+    SourceFactory sourceFactory =
+        _createSourceFactory(null, driver.analysisOptions, contextFolder);
+    driver.configure(sourceFactory: sourceFactory);
   }
 
   /**
    * Create and return a source representing the given [file] within the given
    * [context].
    */
   static Source createSourceInContext(AnalysisContext context, File file) {
     // TODO(brianwilkerson) Optimize this, by allowing support for source
     // factories to restore URI's from a file path rather than a source.
     Source source = file.createSource();
@@ skipping 244 matching lines @@
     }
     return _embedderLocator;
   }
 
   @override
   SdkExtensionFinder getSdkExtensionFinder(ResourceProvider resourceProvider) {
     return _sdkExtensionFinder ??=
         new SdkExtensionFinder(buildPackageMap(resourceProvider));
   }
 }