Remove more dead code from analysis server

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';
@@ skipping 72 matching lines @@
    * is no longer relevant.
    */
   Set<String> _dependencies = new Set<String>();
 
   /**
    * The analysis driver that was created for the [folder].
    */
   AnalysisDriver analysisDriver;
 
   /**
-   * The analysis context that was created for the [folder].
-   */
-  AnalysisContext context;
-
-  /**
    * Map from full path to the [Source] object, for each source that has been
    * added to the context.
    */
   Map<String, Source> sources = new HashMap<String, Source>();
 
   ContextInfo(ContextManagerImpl contextManager, this.parent, Folder folder,
       File packagespecFile, this.packageRoot, this.disposition)
       : folder = folder,
         pathFilter = new PathFilter(
             folder.path, null, contextManager.resourceProvider.pathContext) {
@@ skipping 106 matching lines @@
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
 abstract class ContextManager {
   // TODO(brianwilkerson) Support:
   //   setting the default analysis options
   //   setting the default content cache
   //   setting the default SDK
-  //   maintaining AnalysisContext.folderMap (or remove it)
   //   telling server when a context has been added or removed (see onContextsChanged)
   //   telling server when a context needs to be re-analyzed
   //   notifying the client when results should be flushed
   //   using analyzeFileFunctions to determine which files to analyze
   //
   // TODO(brianwilkerson) Move this class to a public library.
 
   /**
-   * Return the [AnalysisContext]s that are being used to analyze the analysis
-   * roots.
-   */
-  Iterable<AnalysisContext> get analysisContexts;
-
-  /**
    * Get the callback interface used to create, destroy, and update contexts.
    */
   ContextManagerCallbacks get callbacks;
 
   /**
    * Set the callback interface used to create, destroy, and update contexts.
    */
   void set callbacks(ContextManagerCallbacks value);
 
   /**
    * A table mapping [Folder]s to the [AnalysisDriver]s associated with them.
    */
   Map<Folder, AnalysisDriver> get driverMap;
 
   /**
    * Return the list of excluded paths (folders and files) most recently passed
    * to [setRoots].
    */
   List<String> get excludedPaths;
 
   /**
-   * Return a table mapping [Folder]s to the [AnalysisContext]s associated with
-   * them.
-   */
-  Map<Folder, AnalysisContext> get folderMap;
-
-  /**
    * Return the list of included paths (folders and files) most recently passed
    * to [setRoots].
    */
   List<String> get includedPaths;
 
   /**
-   * Return a list of all of the contexts reachable from the given
-   * [analysisRoot] (the context associated with [analysisRoot] and all of its
-   * descendants).
-   */
-  List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot);
-
-  /**
-   * Like [getDriverFor] and [getContextFor], but returns the [Folder] which
-   * allows plugins to create & manage their own tree of drivers just like using
-   * [getDriverFor].
+   * Like [getDriverFor], but returns the [Folder] which allows plugins to
+   * create & manage their own tree of drivers just like using [getDriverFor].
    *
    * This folder should be the root of analysis context, not just the containing
    * folder of the path (like basename), as this is NOT just a file API.
    *
    * This exists at least temporarily, for plugin support until the new API is
    * ready.
    */
   Folder getContextFolderFor(String path);
 
   /**
-   * 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 getContextFor(String path);
-
-  /**
    * Return the [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 driver contains the given path, `null` is returned.
    */
   AnalysisDriver getDriverFor(String path);
 
@@ skipping 10 matching lines @@
    */
   bool isIgnored(String path);
 
   /**
    * Return `true` if the given absolute [path] is in one of the current
    * root folders and is not excluded.
    */
   bool isInAnalysisRoot(String path);
 
   /**
+   * Return the number of contexts reachable from the given [analysisRoot] (the
+   * context associated with [analysisRoot] and all of its descendants).
+   */
+  int numberOfContextsInAnalysisRoot(Folder analysisRoot);
+
+  /**
    * Rebuild the set of contexts from scratch based on the data last sent to
    * [setRoots]. Only contexts contained in the given list of analysis [roots]
    * will be rebuilt, unless the list is `null`, in which case every context
    * will be rebuilt.
    */
   void refresh(List<Resource> roots);
 
   /**
    * Change the set of paths which should be used as starting points to
    * determine the context directories.
@@ skipping 14 matching lines @@
  */
 abstract class ContextManagerCallbacks {
   /**
    * Create and return a new analysis driver rooted at the given [folder], with
    * the given analysis [options].
    */
   AnalysisDriver addAnalysisDriver(
       Folder folder, ContextRoot contextRoot, AnalysisOptions options);
 
   /**
-   * Create and return a new analysis context rooted at the given [folder], with
-   * the given analysis [options].
-   */
-  AnalysisContext addContext(Folder folder, AnalysisOptions options);
-
-  /**
    * Called when the set of files associated with a context have changed (or
    * some of those files have been modified).  [changeSet] is the set of
    * changes that need to be applied to the context.
    */
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet);
 
   /**
    * The given [file] was removed from the folder analyzed in the [driver].
    */
   void applyFileRemoved(AnalysisDriver driver, String file);
@@ skipping 20 matching lines @@
    * associated. Currently this is mostly FYI, and used only in tests.
    */
   void moveContext(Folder from, Folder to);
 
   /**
    * Remove the context associated with the given [folder].  [flushedFiles] is
    * a list of the files which will be "orphaned" by removing this context
    * (they will no longer be analyzed by any context).
    */
   void removeContext(Folder folder, List<String> flushedFiles);
-
-  /**
-   * Called when the package resolution for the given [context] has changed.
-   */
-  void updateContextPackageUriResolver(AnalysisContext context);
 }
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
 class ContextManagerImpl implements ContextManager {
   /**
    * The name of the `doc` directory.
    */
@@ skipping 125 matching lines @@
       this.sdkManager,
       this.packageResolverProvider,
       this._packageMapProvider,
       this.analyzedFilesGlobs,
       this._instrumentationService,
       this.defaultContextOptions) {
     absolutePathContext = resourceProvider.absolutePathContext;
     pathContext = resourceProvider.pathContext;
   }
 
-  @override
-  Iterable<AnalysisContext> get analysisContexts => folderMap.values;
-
-  Map<Folder, AnalysisContext> get 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);
-    }
-
-    if (innermostContainingInfo != null) {
-      if (analysisRoot == innermostContainingInfo.folder) {
-        addContextAndDescendants(innermostContainingInfo);
-      } else {
-        for (ContextInfo info in innermostContainingInfo.children) {
-          if (analysisRoot.isOrContains(info.folder.path)) {
-            addContextAndDescendants(info);
-          }
-        }
-      }
-    }
-    return contexts;
-  }
-
   /**
    * Check if this map defines embedded libraries.
    */
   bool definesEmbeddedLibs(Map map) => map[_EMBEDDED_LIB_MAP_KEY] != null;
 
   Folder getContextFolderFor(String path) {
     return _getInnermostContextInfoFor(path)?.folder;
   }
 
-  @override
-  AnalysisContext getContextFor(String path) {
-    return _getInnermostContextInfoFor(path)?.context;
-  }
-
   /**
    * For testing: get the [ContextInfo] object for the given [folder], if any.
    */
   ContextInfo getContextInfoFor(Folder folder) {
     ContextInfo info = _getInnermostContextInfoFor(folder.path);
     if (info != null && folder == info.folder) {
       return info;
     }
     return null;
   }
@@ skipping 50 matching lines @@
     // check if in one of the roots
     for (ContextInfo info in rootInfo.children) {
       if (info.folder.contains(path)) {
         return true;
       }
     }
     // no
     return false;
   }
 
-  /**
-   * Process [options] for the given context [info].
-   */
-  void processOptionsForContext(ContextInfo info, Map<String, Object> options,
-      {bool optionsRemoved: false}) {
-    if (options == null && !optionsRemoved) {
-      return;
+  @override
+  int numberOfContextsInAnalysisRoot(Folder analysisRoot) {
+    int count = 0;
+    void addContextAndDescendants(ContextInfo info) {
+      count++;
+      info.children.forEach(addContextAndDescendants);
     }
 
-    AnalysisOptionsImpl analysisOptions;
-    if (optionsRemoved) {
-      // In case options files are removed, revert to defaults.
-      analysisOptions = new AnalysisOptionsImpl.from(defaultContextOptions);
-      // Apply inherited options.
-      options = _toStringMap(_getEmbeddedOptions(info));
-    } else {
-      analysisOptions =
-          new AnalysisOptionsImpl.from(info.context.analysisOptions);
-      // Check for embedded options.
-      Map embeddedOptions = _getEmbeddedOptions(info);
-      if (embeddedOptions != null) {
-        options = _toStringMap(new Merger().merge(embeddedOptions, options));
-      }
-    }
-    if (options != null) {
-      applyToAnalysisOptions(analysisOptions, options);
-    }
-    info.context.analysisOptions = analysisOptions;
-
-    // Nothing more to do.
-    if (options == null) {
-      return;
-    }
-
-    var analyzer = options[AnalyzerOptions.analyzer];
-    if (analyzer is Map) {
-      // Set ignore patterns.
-      var exclude = analyzer[AnalyzerOptions.exclude];
-      if (exclude is YamlList) {
-        List<String> excludeList = toStringList(exclude);
-        if (excludeList != null) {
-          setIgnorePatternsForContext(info, excludeList);
+    ContextInfo innermostContainingInfo =
+        _getInnermostContextInfoFor(analysisRoot.path);
+    if (innermostContainingInfo != null) {
+      if (analysisRoot == innermostContainingInfo.folder) {
+        addContextAndDescendants(innermostContainingInfo);
+      } else {
+        for (ContextInfo info in innermostContainingInfo.children) {
+          if (analysisRoot.isOrContains(info.folder.path)) {
+            addContextAndDescendants(info);
+          }
         }
       }
     }
+    return count;
   }
 
   /**
    * Process [options] for the given context [info].
    */
   void processOptionsForDriver(ContextInfo info,
       AnalysisOptionsImpl analysisOptions, Map<String, Object> options) {
     if (options == null) {
       return;
     }
@@ skipping 175 matching lines @@
         if (!_shouldFileBeAnalyzed(child)) {
           continue;
         }
         // ignore if was not excluded
         bool wasExcluded = _isExcludedBy(oldExcludedPaths, path) &&
             !_isExcludedBy(excludedPaths, path);
         if (!wasExcluded) {
           continue;
         }
         // do add the file
-        Source source = createSourceInContext(info.context, child);
+        Source source = createSourceInContext(info.analysisDriver, child);
         changeSet.addedSource(source);
         info.sources[path] = source;
       } else if (child is Folder) {
         if (child.shortName == PACKAGES_NAME) {
           continue;
         }
         _addPreviouslyExcludedSources(info, changeSet, child, oldExcludedPaths);
       }
     }
   }
@@ skipping 17 matching lines @@
     }
     for (Resource child in children) {
       String path = child.path;
       // ignore excluded files or folders
       if (_isExcluded(path) || info.excludes(path) || info.ignored(path)) {
         continue;
       }
       // add files, recurse into folders
       if (child is File) {
         if (_shouldFileBeAnalyzed(child)) {
-          Source source = createSourceInContext(info.context, child);
+          Source source = createSourceInContext(info.analysisDriver, child);
           changeSet.addedSource(source);
           info.sources[path] = source;
         }
       } else if (child is Folder) {
         String shortName = child.shortName;
         if (shortName == PACKAGES_NAME) {
           continue;
         }
         _addSourceFiles(changeSet, child, info);
       }
@@ skipping 241 matching lines @@
       // Now that the child contexts have been created, add the sources that
       // don't belong to the children.
       ChangeSet changeSet = new ChangeSet();
       _addSourceFiles(changeSet, folder, parent);
       callbacks.applyChangesToContext(folder, changeSet);
     }
   }
 
   /**
    * Set up a [SourceFactory] that resolves packages as appropriate for the
-   * given [disposition].
+   * given [folder].
    */
-  SourceFactory _createSourceFactory(
-      InternalAnalysisContext context, AnalysisOptions options, Folder folder) {
+  SourceFactory _createSourceFactory(AnalysisOptions options, Folder folder) {
     ContextBuilder builder = callbacks.createContextBuilder(folder, options);
     return builder.createSourceFactory(folder.path, options);
   }
 
   /**
    * Clean up and destroy the context associated with the given folder.
    */
   void _destroyContext(ContextInfo info) {
     changeSubscriptions.remove(info.folder)?.cancel();
     callbacks.removeContext(info.folder, _computeFlushedFiles(info));
@@ skipping 385 matching lines @@
       }
       return stringMap;
     }
     return null;
   }
 
   void _updateContextPackageUriResolver(Folder contextFolder) {
     ContextInfo info = getContextInfoFor(contextFolder);
     AnalysisDriver driver = info.analysisDriver;
     SourceFactory sourceFactory =
-        _createSourceFactory(null, driver.analysisOptions, contextFolder);
+        _createSourceFactory(driver.analysisOptions, contextFolder);
     driver.configure(sourceFactory: sourceFactory);
   }
 
   /**
    * Create and return a source representing the given [file] within the given
-   * [context].
+   * [driver].
    */
-  static Source createSourceInContext(AnalysisContext context, File file) {
+  static Source createSourceInContext(AnalysisDriver driver, 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();
-    if (context == null) {
+    if (driver == null) {
       return source;
     }
-    Uri uri = context.sourceFactory.restoreUri(source);
+    Uri uri = driver.sourceFactory.restoreUri(source);
     return file.createSource(uri);
   }
 }
 
 /**
- * An indication that one or more contexts were added, changed, or removed.
- *
- * The lists of [added], [changed] and [removed] contexts will not contain
- * duplications (that is, a single context will not be in any list multiple
- * times), nor will there be any overlap between the lists (that is, a single
- * context will not be in more than one list).
- */
-class ContextsChangedEvent {
-  /**
-   * The contexts that were added to the server.
-   */
-  final List<AnalysisContext> added;
-
-  /**
-   * The contexts that were changed.
-   */
-  final List<AnalysisContext> changed;
-
-  /**
-   * The contexts that were removed from the server.
-   */
-  final List<AnalysisContext> removed;
-
-  /**
-   * Initialize a newly created event to indicate which contexts have changed.
-   */
-  ContextsChangedEvent(
-      {this.added: AnalysisContext.EMPTY_LIST,
-      this.changed: AnalysisContext.EMPTY_LIST,
-      this.removed: AnalysisContext.EMPTY_LIST});
-}
-
-/**
  * Concrete [FolderDisposition] object indicating that the context for a given
  * folder should resolve package URIs using a custom URI resolver.
  */
 class CustomPackageResolverDisposition extends FolderDisposition {
   /**
    * The [UriResolver] that should be used to resolve package URIs.
    */
   UriResolver resolver;
 
   CustomPackageResolverDisposition(this.resolver);
@@ skipping 13 matching lines @@
   EmbedderYamlLocator getEmbedderLocator(ResourceProvider resourceProvider) =>
       new EmbedderYamlLocator(null);
 
   @override
   SdkExtensionFinder getSdkExtensionFinder(ResourceProvider resourceProvider) =>
       new SdkExtensionFinder(null);
 }
 
 /**
  * An instance of the class [FolderDisposition] represents the information
- * gathered by the [ContextManagerImpl] to determine how to create an
- * [AnalysisContext] for a given folder.
+ * gathered by the [ContextManagerImpl] to determine how to create an analysis
+ * driver for a given folder.
  *
  * Note: [ContextManagerImpl] may use equality testing and hash codes to
  * determine when two folders should share the same context, so derived classes
  * may need to override operator== and hashCode() if object identity is
  * insufficient.
  *
  * TODO(paulberry): consider adding a flag to indicate that it is not necessary
  * to recurse into the given folder looking for additional contexts to create
  * or files to analyze (this could help avoid unnecessarily weighing down the
  * system with file watchers).
@@ skipping 157 matching lines @@
     }
     return _embedderLocator;
   }
 
   @override
   SdkExtensionFinder getSdkExtensionFinder(ResourceProvider resourceProvider) {
     return _sdkExtensionFinder ??=
         new SdkExtensionFinder(buildPackageMap(resourceProvider));
   }
 }