Get rid of ContextManager._contexts.

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 92 matching lines @@
 
   /**
    * Create the virtual [ContextInfo] which acts as an ancestor to all other
    * [ContextInfo]s.
    */
   ContextInfo._root()
       : folder = null,
         pathFilter = null;
 
   /**
+   * Iterate through all [children] and their children, recursively.
+   */
+  Iterable<ContextInfo> get descendants sync* {
+    for (ContextInfo child in children) {
+      yield child;
+      yield* child.descendants;
+    }
+  }
+
+  /**
    * Returns `true` if this is a "top level" context, meaning that the folder
    * associated with it is not contained within any other folders that have an
    * associated context.
    */
   bool get isTopLevel => parent.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);
 
+  /**
+   * Return the first [ContextInfo] in [children] whose associated folder is or
+   * contains [path].  If there is no such [ContextInfo], return `null`.
+   */
+  ContextInfo findChildInfoFor(String path) {
+    for (ContextInfo info in children) {
+      if (info.folder.isOrContains(path)) {
+        return info;
+      }
+    }
+    return null;
+  }
+
   /// 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;
 }
@@ skipping 31 matching lines @@
    */
   List<String> get excludedPaths;
 
   /**
    * Return the list of included paths (folders and files) most recently passed
    * to [setRoots].
    */
   List<String> get includedPaths;
 
   /**
-   * Return a list containing all of the contexts contained in the given
-   * [analysisRoot].
+   * 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);
 
   /**
    * Return `true` if the given absolute [path] is in one of the current
    * root folders and is not excluded.
    */
   bool isInAnalysisRoot(String path);
 
   /**
@@ skipping 94 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
-   * recent successful call to [setRoots].
-   */
-  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 51 matching lines @@
   final ContextInfo _rootInfo = new ContextInfo._root();
 
   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) {
-      if (analysisRoot.isOrContains(contextFolder.path)) {
-        contexts.add(info.context);
+    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;
   }
 
   /**
    * For testing: get the [ContextInfo] object for the given [folder], if any.
    */
-  ContextInfo getContextInfoFor(Folder folder) => _contexts[folder];
+  ContextInfo getContextInfoFor(Folder folder) {
+    ContextInfo info = _getInnermostContextInfoFor(folder.path);
+    if (folder == info.folder) {
+      return info;
+    }
+    return null;
+  }
 
   @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)) {
+    // 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 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(info, exclude);
     }
   }
 
   @override
   void refresh(List<Resource> roots) {
     // Destroy old contexts
-    List<Folder> contextFolders = _contexts.keys.toList();
+    List<ContextInfo> contextInfos = _rootInfo.descendants.toList();
     if (roots == null) {
-      contextFolders.forEach(_destroyContext);
+      contextInfos.forEach(_destroyContext);
     } else {
       roots.forEach((Resource resource) {
-        contextFolders.forEach((Folder contextFolder) {
-          if (resource is Folder && resource.isOrContains(contextFolder.path)) {
-            _destroyContext(contextFolder);
+        contextInfos.forEach((ContextInfo contextInfo) {
+          if (resource is Folder &&
+              resource.isOrContains(contextInfo.folder.path)) {
+            _destroyContext(contextInfo);
           }
         });
       });
     }
 
     // Rebuild contexts based on the data last sent to setRoots().
     setRoots(includedPaths, excludedPaths, packageRoots);
   }
 
   /**
@@ skipping 12 matching lines @@
     // 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>{};
     packageRoots.forEach((String sourcePath, String targetPath) {
       Resource resource = resourceProvider.getResource(sourcePath);
       if (resource is Folder) {
         normalizedPackageRoots[resource.path] = targetPath;
       }
     });
 
-    List<Folder> contextFolders = _contexts.keys.toList();
+    List<ContextInfo> contextInfos = _rootInfo.descendants.toList();
     // included
     Set<Folder> includedFolders = new HashSet<Folder>();
     for (int i = 0; i < includedPaths.length; i++) {
       String path = includedPaths[i];
       Resource resource = resourceProvider.getResource(path);
       if (resource is Folder) {
         includedFolders.add(resource);
       } else {
         // TODO(scheglov) implemented separate files analysis
         throw new UnimplementedError('$path is not a folder. '
             'Only support for folder analysis is implemented currently.');
       }
     }
     this.includedPaths = includedPaths;
     // excluded
     List<String> oldExcludedPaths = this.excludedPaths;
     this.excludedPaths = excludedPaths;
     // destroy old contexts
-    for (Folder contextFolder in contextFolders) {
+    for (ContextInfo contextInfo in contextInfos) {
       bool isIncluded = includedFolders.any((folder) {
-        return folder.isOrContains(contextFolder.path);
+        return folder.isOrContains(contextInfo.folder.path);
       });
       if (!isIncluded) {
-        _destroyContext(contextFolder);
+        _destroyContext(contextInfo);
       }
     }
     // Update package roots for existing contexts
-    _contexts.forEach((Folder folder, ContextInfo info) {
-      String newPackageRoot = normalizedPackageRoots[folder.path];
+    for (ContextInfo info in _rootInfo.descendants) {
+      String newPackageRoot = normalizedPackageRoots[info.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);
+      bool wasIncluded = contextInfos.any((info) {
+        return info.folder.isOrContains(includedFolder.path);
       });
       if (!wasIncluded) {
         _createContexts(_rootInfo, includedFolder, false);
       }
     }
     // remove newly excluded sources
-    _contexts.forEach((folder, info) {
+    for (ContextInfo info in _rootInfo.descendants) {
       // prepare excluded sources
       Map<String, Source> excludedSources = new HashMap<String, Source>();
       info.sources.forEach((String path, Source source) {
         if (_isExcludedBy(excludedPaths, path) &&
             !_isExcludedBy(oldExcludedPaths, path)) {
           excludedSources[path] = source;
         }
       });
       // apply exclusion
       ChangeSet changeSet = new ChangeSet();
       excludedSources.forEach((String path, Source source) {
         info.sources.remove(path);
         changeSet.removedSource(source);
       });
-      callbacks.applyChangesToContext(folder, changeSet);
-    });
+      callbacks.applyChangesToContext(info.folder, changeSet);
+    }
     // add previously excluded sources
-    _contexts.forEach((folder, info) {
+    for (ContextInfo info in _rootInfo.descendants) {
       ChangeSet changeSet = new ChangeSet();
-      _addPreviouslyExcludedSources(info, changeSet, folder, oldExcludedPaths);
-      callbacks.applyChangesToContext(folder, changeSet);
-    });
+      _addPreviouslyExcludedSources(
+          info, changeSet, info.folder, oldExcludedPaths);
+      callbacks.applyChangesToContext(info.folder, changeSet);
+    }
   }
 
   /**
    * Resursively adds all Dart and HTML files to the [changeSet].
    */
   void _addPreviouslyExcludedSources(ContextInfo info, ChangeSet changeSet,
       Folder folder, List<String> oldExcludedPaths) {
     if (info.excludesResource(folder)) {
       return;
     }
@@ skipping 99 matching lines @@
       }
     }
   }
 
   /**
    * 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;
+  List<String> _computeFlushedFiles(ContextInfo info) {
+    AnalysisContext context = info.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 _rootInfo.descendants) {
       AnalysisContext contextN = contextInfo.context;
       if (context != contextN) {
         for (Source source in contextN.sources) {
           flushedFiles.remove(source.fullName);
         }
       }
     }
     return flushedFiles.toList(growable: false);
   }
 
@@ skipping 74 matching lines @@
   }
 
   /**
    * Create a new empty context associated with [folder], having parent
    * [parent] and using [packagespecFile] to resolve package URI's.
    */
   ContextInfo _createContext(
       ContextInfo parent, Folder folder, File packagespecFile) {
     ContextInfo info = new ContextInfo(
         parent, folder, packagespecFile, normalizedPackageRoots[folder.path]);
-    _contexts[folder] = info;
     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) {
@@ skipping 68 matching lines @@
       // don't belong to the children.
       ChangeSet changeSet = new ChangeSet();
       _addSourceFiles(changeSet, folder, parent);
       callbacks.applyChangesToContext(folder, changeSet);
     }
   }
 
   /**
    * Clean up and destroy the context associated with the given folder.
    */
-  void _destroyContext(Folder folder) {
-    ContextInfo info = _contexts[folder];
+  void _destroyContext(ContextInfo info) {
     info.changeSubscription.cancel();
     _cancelDependencySubscriptions(info);
-    callbacks.removeContext(folder, _computeFlushedFiles(folder));
+    callbacks.removeContext(info.folder, _computeFlushedFiles(info));
     bool wasRemoved = info.parent.children.remove(info);
     assert(wasRemoved);
-    _contexts.remove(folder);
   }
 
   /**
    * Extract a new [packagespecFile]-based context from [oldInfo].
    */
   void _extractContext(ContextInfo oldInfo, File packagespecFile) {
     Folder newFolder = packagespecFile.parent;
     ContextInfo newInfo = _createContext(oldInfo, newFolder, packagespecFile);
     // prepare sources to extract
     Map<String, Source> extractedSources = new HashMap<String, Source>();
@@ skipping 18 matching lines @@
         oldInfo.sources.remove(path);
         changeSet.removedSource(source);
       });
       callbacks.applyChangesToContext(oldInfo.folder, changeSet);
     }
     // TODO(paulberry): every context that was previously a child of oldInfo is
     // is still a child of oldInfo.  This is wrong--some of them ought to be
     // adopted by newInfo now.
   }
 
+  /**
+   * Return the [ContextInfo] 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.
+   */
+  ContextInfo _getInnermostContextInfoFor(String path) {
+    ContextInfo info = _rootInfo.findChildInfoFor(path);
+    if (info == null) {
+      return null;
+    }
+    while (true) {
+      ContextInfo childInfo = info.findChildInfoFor(path);
+      if (childInfo == null) {
+        return info;
+      }
+      info = childInfo;
+    }
+  }
+
   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)) {
@@ skipping 163 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) {
     // destroy the context
-    _destroyContext(info.folder);
+    _destroyContext(info);
     // add files to the parent context
     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);
@@ skipping 67 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});
 }