Remove redundant context lookups from option-processing code.

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.
 
 library context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:core' hide Resource;
@@ skipping 11 matching lines @@
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:package_config/packages.dart';
 import 'package:package_config/packages_file.dart' as pkgfile show parse;
 import 'package:package_config/src/packages_impl.dart' show MapPackages;
 import 'package:path/path.dart' as pathos;
 import 'package:watcher/watcher.dart';
 import 'package:yaml/yaml.dart';
 
 /**
+ * Information tracked by the [ContextManager] for each context.
+ */
+class ContextInfo {
+  /**
+   * The [Folder] for which this information object is created.
+   */
+  final Folder folder;
+
+  /// The [PathFilter] used to filter sources from being analyzed.
+  final PathFilter pathFilter;
+
+  /**
+   * The enclosed pubspec-based contexts.
+   */
+  final List<ContextInfo> children;
+
+  /**
+   * The package root for this context, or null if there is no package root.
+   */
+  String packageRoot;
+
+  /**
+   * The [ContextInfo] that encloses this one.
+   */
+  ContextInfo parent;
+
+  /**
+   * The package description file path for this context.
+   */
+  String packageDescriptionPath;
+
+  /**
+   * Stream subscription we are using to watch the context's directory for
+   * changes.
+   */
+  StreamSubscription<WatchEvent> changeSubscription;
+
+  /**
+   * Stream subscriptions we are using to watch the files
+   * used to determine the package map.
+   */
+  final List<StreamSubscription<WatchEvent>> dependencySubscriptions =
+      <StreamSubscription<WatchEvent>>[];
+
+  /**
+   * 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>();
+
+  /**
+   * Info returned by the last call to
+   * [OptimizingPubPackageMapProvider.computePackageMap], or `null` if the
+   * package map hasn't been computed for this context yet.
+   */
+  OptimizingPubPackageMapInfo packageMapInfo;
+
+  ContextInfo(
+      Folder folder, File packagespecFile, this.children, this.packageRoot)
+      : folder = folder,
+        pathFilter = new PathFilter(folder.path, null) {
+    packageDescriptionPath = packagespecFile.path;
+    for (ContextInfo child in children) {
+      child.parent = this;
+    }
+  }
+
+  /**
+   * Returns `true` if this context is root folder based.
+   */
+  bool get isRoot => parent == null;
+
+  /**
+   * Returns `true` if [path] is excluded, as it is in one of the children.
+   */
+  bool excludes(String path) {
+    return children.any((child) {
+      return child.folder.contains(path);
+    });
+  }
+
+  /**
+   * Returns `true` if [resource] is excluded, as it is in one of the children.
+   */
+  bool excludesResource(Resource resource) => excludes(resource.path);
+
+  /// Returns `true` if  [path] should be ignored.
+  bool ignored(String path) => pathFilter.ignored(path);
+
+  /**
+   * Returns `true` if [path] is the package description file for this context
+   * (pubspec.yaml or .packages).
+   */
+  bool isPathToPackageDescription(String path) =>
+      path == packageDescriptionPath;
+}
+
+/**
  * 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)
@@ skipping 135 matching lines @@
    * File name of pubspec files.
    */
   static const String PUBSPEC_NAME = 'pubspec.yaml';
 
   /**
    * File name of package spec files.
    */
   static const String PACKAGE_SPEC_NAME = '.packages';
 
   /**
-   * [_ContextInfo] object for each included directory in the most
+   * [ContextInfo] object for each included directory in the most
    * recent successful call to [setRoots].
    */
-  Map<Folder, _ContextInfo> _contexts = new HashMap<Folder, _ContextInfo>();
+  Map<Folder, ContextInfo> _contexts = new HashMap<Folder, ContextInfo>();
 
   /**
    * The [ResourceProvider] using which paths are converted into [Resource]s.
    */
   final ResourceProvider resourceProvider;
 
   /**
    * The context used to work with file system paths.
    */
   pathos.Context pathContext;
@@ skipping 47 matching lines @@
   ContextManagerCallbacks callbacks;
 
   ContextManagerImpl(this.resourceProvider, this.packageResolverProvider,
       this._packageMapProvider, this._instrumentationService) {
     pathContext = resourceProvider.pathContext;
   }
 
   @override
   List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
     List<AnalysisContext> contexts = <AnalysisContext>[];
-    _contexts.forEach((Folder contextFolder, _ContextInfo info) {
+    _contexts.forEach((Folder contextFolder, ContextInfo info) {
       if (analysisRoot.isOrContains(contextFolder.path)) {
         contexts.add(info.context);
       }
     });
     return contexts;
   }
 
+  /**
+   * For testing: get the [ContextInfo] object for the given [folder], if any.
+   */
+  ContextInfo getContextInfoFor(Folder folder) => _contexts[folder];
+
   @override
   bool isInAnalysisRoot(String path) {
     // check if excluded
     if (_isExcluded(path)) {
       return false;
     }
     // check if in of the roots
     for (Folder root in _contexts.keys) {
       if (root.contains(path)) {
         return true;
       }
     }
     // no
     return false;
   }
 
-  /// Process [options] for the context [folder].
-  void processOptionsForContext(Folder folder, Map<String, YamlNode> options) {
-    _ContextInfo info = _contexts[folder];
-    if (info == null) {
-      return;
-    }
+  /**
+   * Process [options] for the context having info [info].
+   */
+  void processOptionsForContext(
+      ContextInfo info, Map<String, YamlNode> options) {
     YamlMap analyzer = options['analyzer'];
     if (analyzer == null) {
       // No options for analyzer.
       return;
     }
 
     // Set ignore patterns.
     YamlList exclude = analyzer['exclude'];
     if (exclude != null) {
-      setIgnorePatternsForContext(folder, exclude);
+      setIgnorePatternsForContext(info, exclude);
     }
   }
 
   @override
   void refresh(List<Resource> roots) {
     // Destroy old contexts
     List<Folder> contextFolders = _contexts.keys.toList();
     if (roots == null) {
       contextFolders.forEach(_destroyContext);
     } else {
       roots.forEach((Resource resource) {
         contextFolders.forEach((Folder contextFolder) {
           if (resource is Folder && resource.isOrContains(contextFolder.path)) {
             _destroyContext(contextFolder);
           }
         });
       });
     }
 
     // Rebuild contexts based on the data last sent to setRoots().
     setRoots(includedPaths, excludedPaths, packageRoots);
   }
 
-  /// Sets the [ignorePatterns] for the context [folder].
-  void setIgnorePatternsForContext(Folder folder, List<String> ignorePatterns) {
-    _ContextInfo info = _contexts[folder];
-    if (info == null) {
-      return;
-    }
-    var pathFilter = info.pathFilter;
-    pathFilter.setIgnorePatterns(ignorePatterns);
+  /**
+   * Sets the [ignorePatterns] for the context having info [info].
+   */
+  void setIgnorePatternsForContext(
+      ContextInfo info, List<String> ignorePatterns) {
+    info.pathFilter.setIgnorePatterns(ignorePatterns);
   }
 
   @override
   void setRoots(List<String> includedPaths, List<String> excludedPaths,
       Map<String, String> packageRoots) {
     this.packageRoots = packageRoots;
 
     // Normalize all package root sources by mapping them to folders on the
     // filesystem.  Ignore any package root sources that aren't folders.
     normalizedPackageRoots = <String, String>{};
@@ skipping 25 matching lines @@
     // destroy old contexts
     for (Folder contextFolder in contextFolders) {
       bool isIncluded = includedFolders.any((folder) {
         return folder.isOrContains(contextFolder.path);
       });
       if (!isIncluded) {
         _destroyContext(contextFolder);
       }
     }
     // Update package roots for existing contexts
-    _contexts.forEach((Folder folder, _ContextInfo info) {
+    _contexts.forEach((Folder folder, ContextInfo info) {
       String newPackageRoot = normalizedPackageRoots[folder.path];
       if (info.packageRoot != newPackageRoot) {
         info.packageRoot = newPackageRoot;
         _recomputePackageUriResolver(info);
       }
     });
     // create new contexts
     for (Folder includedFolder in includedFolders) {
       bool wasIncluded = contextFolders.any((folder) {
         return folder.isOrContains(includedFolder.path);
@@ skipping 24 matching lines @@
     _contexts.forEach((folder, info) {
       ChangeSet changeSet = new ChangeSet();
       _addPreviouslyExcludedSources(info, changeSet, folder, oldExcludedPaths);
       callbacks.applyChangesToContext(folder, changeSet);
     });
   }
 
   /**
    * Resursively adds all Dart and HTML files to the [changeSet].
    */
-  void _addPreviouslyExcludedSources(_ContextInfo info, ChangeSet changeSet,
+  void _addPreviouslyExcludedSources(ContextInfo info, ChangeSet changeSet,
       Folder folder, List<String> oldExcludedPaths) {
     if (info.excludesResource(folder)) {
       return;
     }
     List<Resource> children;
     try {
       children = folder.getChildren();
     } on FileSystemException {
       // The folder no longer exists, or cannot be read, to there's nothing to
       // do.
@@ skipping 26 matching lines @@
           continue;
         }
         _addPreviouslyExcludedSources(info, changeSet, child, oldExcludedPaths);
       }
     }
   }
 
   /**
    * Resursively adds all Dart and HTML files to the [changeSet].
    */
-  void _addSourceFiles(ChangeSet changeSet, Folder folder, _ContextInfo info) {
+  void _addSourceFiles(ChangeSet changeSet, Folder folder, ContextInfo info) {
     if (info.excludesResource(folder) || folder.shortName.startsWith('.')) {
       return;
     }
     List<Resource> children = null;
     try {
       children = folder.getChildren();
     } on FileSystemException {
       // The directory either doesn't exist or cannot be read. Either way, there
       // are no children that need to be added.
       return;
@@ skipping 17 matching lines @@
           continue;
         }
         _addSourceFiles(changeSet, child, info);
       }
     }
   }
 
   /**
    * Cancel all dependency subscriptions for the given context.
    */
-  void _cancelDependencySubscriptions(_ContextInfo info) {
+  void _cancelDependencySubscriptions(ContextInfo info) {
     for (StreamSubscription<WatchEvent> s in info.dependencySubscriptions) {
       s.cancel();
     }
     info.dependencySubscriptions.clear();
   }
 
   void _checkForPackagespecUpdate(
-      String path, _ContextInfo info, Folder folder) {
+      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 (pathContext.basename(path) == PACKAGE_SPEC_NAME &&
         info.isPathToPackageDescription(path)) {
       File packagespec = resourceProvider.getFile(path);
       if (packagespec.exists) {
         Packages packages = _readPackagespec(packagespec);
         if (packages != null) {
           callbacks.updateContextPackageUriResolver(folder, null, packages);
         }
       }
     }
   }
 
   /**
    * 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(Folder folder) {
     AnalysisContext context = _contexts[folder].context;
     HashSet<String> flushedFiles = new HashSet<String>();
     for (Source source in context.sources) {
       flushedFiles.add(source.fullName);
     }
-    for (_ContextInfo contextInfo in _contexts.values) {
+    for (ContextInfo contextInfo in _contexts.values) {
       AnalysisContext contextN = contextInfo.context;
       if (context != contextN) {
         for (Source source in contextN.sources) {
           flushedFiles.remove(source.fullName);
         }
       }
     }
     return flushedFiles.toList(growable: false);
   }
 
   /**
    * Compute the appropriate package URI resolver for [folder], and store
    * dependency information in [info]. Return `null` if no package map can
    * be computed.
    */
-  UriResolver _computePackageUriResolver(Folder folder, _ContextInfo info) {
+  UriResolver _computePackageUriResolver(Folder folder, ContextInfo info) {
     _cancelDependencySubscriptions(info);
     if (info.packageRoot != null) {
       info.packageMapInfo = null;
       JavaFile packagesDir = new JavaFile(info.packageRoot);
       Map<String, List<Folder>> packageMap = new Map<String, List<Folder>>();
       if (packagesDir.isDirectory()) {
         for (JavaFile file in packagesDir.listFiles()) {
           // Ensure symlinks in packages directory are canonicalized
           // to prevent 'type X cannot be assigned to type X' warnings
           String path;
@@ skipping 53 matching lines @@
       return new PackageMapUriResolver(
           resourceProvider, packageMapInfo.packageMap);
       // TODO(paulberry): if any of the dependencies is outside of [folder],
       // we'll need to watch their parent folders as well.
     }
   }
 
   /**
    * Create a new empty context associated with [folder].
    */
-  _ContextInfo _createContext(
-      Folder folder, File packagespecFile, List<_ContextInfo> children) {
-    _ContextInfo info = new _ContextInfo(
+  ContextInfo _createContext(
+      Folder folder, File packagespecFile, List<ContextInfo> children) {
+    ContextInfo info = new ContextInfo(
         folder, packagespecFile, children, normalizedPackageRoots[folder.path]);
     _contexts[folder] = info;
-    var options = analysisOptionsProvider.getOptions(folder);
-    processOptionsForContext(folder, options);
+    Map<String, YamlNode> options = analysisOptionsProvider.getOptions(folder);
+    processOptionsForContext(info, options);
     info.changeSubscription = folder.changes.listen((WatchEvent event) {
       _handleWatchEvent(folder, info, event);
     });
     try {
       Packages packages;
       UriResolver packageUriResolver;
 
       if (ENABLE_PACKAGESPEC_SUPPORT) {
         // Try .packages first.
         if (pathos.basename(packagespecFile.path) == PACKAGE_SPEC_NAME) {
@@ skipping 20 matching lines @@
    *
    * If there are subfolders with 'pubspec.yaml' files, separate contexts are
    * created for them and excluded from the context associated with the
    * [folder].
    *
    * If [withPackageSpecOnly] is `true`, a context will be created only if there
    * is a 'pubspec.yaml' or '.packages' file in the [folder].
    *
    * Returns created contexts.
    */
-  List<_ContextInfo> _createContexts(Folder folder, bool withPackageSpecOnly) {
+  List<ContextInfo> _createContexts(Folder folder, bool withPackageSpecOnly) {
     // Try to find subfolders with pubspecs or .packages files.
-    List<_ContextInfo> children = <_ContextInfo>[];
+    List<ContextInfo> children = <ContextInfo>[];
     try {
       for (Resource child in folder.getChildren()) {
         if (child is Folder) {
           children.addAll(_createContexts(child, true));
         }
       }
     } on FileSystemException {
       // The directory either doesn't exist or cannot be read. Either way, there
       // are no subfolders that need to be added.
     }
 
     File packageSpec;
 
     if (ENABLE_PACKAGESPEC_SUPPORT) {
       // Start by looking for .packages.
       packageSpec = folder.getChild(PACKAGE_SPEC_NAME);
     }
 
     // Fall back to looking for a pubspec.
     if (packageSpec == null || !packageSpec.exists) {
       packageSpec = folder.getChild(PUBSPEC_NAME);
     }
 
     if (packageSpec.exists) {
-      return <_ContextInfo>[
+      return <ContextInfo>[
         _createContextWithSources(folder, packageSpec, children)
       ];
     }
     // No packagespec? Done.
     if (withPackageSpecOnly) {
       return children;
     }
     // OK, create a context without a packagespec.
-    return <_ContextInfo>[
+    return <ContextInfo>[
       _createContextWithSources(folder, packageSpec, children)
     ];
   }
 
   /**
    * Create a new context associated with the given [folder]. The [pubspecFile]
    * is the `pubspec.yaml` file contained in the folder. Add any sources that
    * are not included in one of the [children] to the context.
    */
-  _ContextInfo _createContextWithSources(
-      Folder folder, File pubspecFile, List<_ContextInfo> children) {
-    _ContextInfo info = _createContext(folder, pubspecFile, children);
+  ContextInfo _createContextWithSources(
+      Folder folder, File pubspecFile, List<ContextInfo> children) {
+    ContextInfo info = _createContext(folder, pubspecFile, children);
     ChangeSet changeSet = new ChangeSet();
     _addSourceFiles(changeSet, folder, info);
     callbacks.applyChangesToContext(folder, changeSet);
     return info;
   }
 
   /**
    * Clean up and destroy the context associated with the given folder.
    */
   void _destroyContext(Folder folder) {
-    _ContextInfo info = _contexts[folder];
+    ContextInfo info = _contexts[folder];
     info.changeSubscription.cancel();
     _cancelDependencySubscriptions(info);
     callbacks.removeContext(folder, _computeFlushedFiles(folder));
     _contexts.remove(folder);
   }
 
   /**
    * Extract a new [packagespecFile]-based context from [oldInfo].
    */
-  void _extractContext(_ContextInfo oldInfo, File packagespecFile) {
+  void _extractContext(ContextInfo oldInfo, File packagespecFile) {
     Folder newFolder = packagespecFile.parent;
-    _ContextInfo newInfo = _createContext(newFolder, packagespecFile, []);
+    ContextInfo newInfo = _createContext(newFolder, packagespecFile, []);
     newInfo.parent = oldInfo;
     // prepare sources to extract
     Map<String, Source> extractedSources = new HashMap<String, Source>();
     oldInfo.sources.forEach((path, source) {
       if (newFolder.contains(path)) {
         extractedSources[path] = source;
       }
     });
     // update new context
     {
       ChangeSet changeSet = new ChangeSet();
       extractedSources.forEach((path, source) {
         newInfo.sources[path] = source;
         changeSet.addedSource(source);
       });
       callbacks.applyChangesToContext(newFolder, changeSet);
     }
     // update old context
     {
       ChangeSet changeSet = new ChangeSet();
       extractedSources.forEach((path, source) {
         oldInfo.sources.remove(path);
         changeSet.removedSource(source);
       });
       callbacks.applyChangesToContext(oldInfo.folder, changeSet);
     }
   }
 
-  void _handleWatchEvent(Folder folder, _ContextInfo info, WatchEvent event) {
+  void _handleWatchEvent(Folder folder, ContextInfo info, WatchEvent event) {
     // TODO(brianwilkerson) If a file is explicitly included in one context
     // but implicitly referenced in another context, we will only send a
     // changeSet to the context that explicitly includes the file (because
     // that's the only context that's watching the file).
     _instrumentationService.logWatchEvent(
         folder.path, event.path, event.type.toString());
     String path = event.path;
     // maybe excluded globally
     if (_isExcluded(path)) {
       return;
@@ skipping 160 matching lines @@
   }
 
   bool _isPackagespec(String path) =>
       pathContext.basename(path) == PACKAGE_SPEC_NAME;
 
   bool _isPubspec(String path) => pathContext.basename(path) == PUBSPEC_NAME;
 
   /**
    * Merges [info] context into its parent.
    */
-  void _mergeContext(_ContextInfo info) {
+  void _mergeContext(ContextInfo info) {
     // destroy the context
     _destroyContext(info.folder);
     // add files to the parent context
-    _ContextInfo parentInfo = info.parent;
+    ContextInfo parentInfo = info.parent;
     if (parentInfo != null) {
       parentInfo.children.remove(info);
       ChangeSet changeSet = new ChangeSet();
       info.sources.forEach((path, source) {
         parentInfo.sources[path] = source;
         changeSet.addedSource(source);
       });
       callbacks.applyChangesToContext(parentInfo.folder, changeSet);
     }
   }
 
   Packages _readPackagespec(File specFile) {
     try {
       String contents = specFile.readAsStringSync();
       Map<String, Uri> map =
           pkgfile.parse(UTF8.encode(contents), new Uri.file(specFile.path));
       return new MapPackages(map);
     } catch (_) {
       //TODO(pquitslund): consider creating an error for the spec file.
       return null;
     }
   }
 
   /**
    * Recompute the package URI resolver for the context described by [info],
    * and update the client appropriately.
    */
-  void _recomputePackageUriResolver(_ContextInfo info) {
+  void _recomputePackageUriResolver(ContextInfo info) {
     // TODO(paulberry): when computePackageMap is changed into an
     // asynchronous API call, we'll want to suspend analysis for this context
     // while we're rerunning "pub list", since any analysis we complete while
     // "pub list" is in progress is just going to get thrown away anyhow.
     UriResolver packageUriResolver =
         _computePackageUriResolver(info.folder, info);
     callbacks.updateContextPackageUriResolver(
         info.folder, packageUriResolver, null);
   }
 
@@ skipping 37 matching lines @@
    */
   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});
 }
-
-/**
- * Information tracked by the [ContextManager] for each context.
- */
-class _ContextInfo {
-  /**
-   * The [Folder] for which this information object is created.
-   */
-  final Folder folder;
-
-  /// The [PathFilter] used to filter sources from being analyzed.
-  final PathFilter pathFilter;
-
-  /**
-   * The enclosed pubspec-based contexts.
-   */
-  final List<_ContextInfo> children;
-
-  /**
-   * The package root for this context, or null if there is no package root.
-   */
-  String packageRoot;
-
-  /**
-   * The [_ContextInfo] that encloses this one.
-   */
-  _ContextInfo parent;
-
-  /**
-   * The package description file path for this context.
-   */
-  String packageDescriptionPath;
-
-  /**
-   * Stream subscription we are using to watch the context's directory for
-   * changes.
-   */
-  StreamSubscription<WatchEvent> changeSubscription;
-
-  /**
-   * Stream subscriptions we are using to watch the files
-   * used to determine the package map.
-   */
-  final List<StreamSubscription<WatchEvent>> dependencySubscriptions =
-      <StreamSubscription<WatchEvent>>[];
-
-  /**
-   * 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>();
-
-  /**
-   * Info returned by the last call to
-   * [OptimizingPubPackageMapProvider.computePackageMap], or `null` if the
-   * package map hasn't been computed for this context yet.
-   */
-  OptimizingPubPackageMapInfo packageMapInfo;
-
-  _ContextInfo(
-      Folder folder, File packagespecFile, this.children, this.packageRoot)
-      : folder = folder,
-        pathFilter = new PathFilter(folder.path, null) {
-    packageDescriptionPath = packagespecFile.path;
-    for (_ContextInfo child in children) {
-      child.parent = this;
-    }
-  }
-
-  /**
-   * Returns `true` if this context is root folder based.
-   */
-  bool get isRoot => parent == null;
-
-  /**
-   * Returns `true` if [path] is excluded, as it is in one of the children.
-   */
-  bool excludes(String path) {
-    return children.any((child) {
-      return child.folder.contains(path);
-    });
-  }
-
-  /**
-   * Returns `true` if [resource] is excluded, as it is in one of the children.
-   */
-  bool excludesResource(Resource resource) => excludes(resource.path);
-
-  /// Returns `true` if  [path] should be ignored.
-  bool ignored(String path) => pathFilter.ignored(path);
-
-  /**
-   * Returns `true` if [path] is the package description file for this context
-   * (pubspec.yaml or .packages).
-   */
-  bool isPathToPackageDescription(String path) =>
-      path == packageDescriptionPath;
-}