Preliminary refactoring work on ContextManager.

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 25 matching lines @@
    * 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;
+  final List<ContextInfo> children = <ContextInfo>[];
 
   /**
    * The package root for this context, or null if there is no package root.
    */
   String packageRoot;
 
   /**
-   * The [ContextInfo] that encloses this one.
+   * The [ContextInfo] that encloses this one, or `null` if this is the virtual
+   * [ContextInfo] object that acts as the ancestor of all other [ContextInfo]
+   * objects.
    */
   ContextInfo parent;
 
   /**
    * The package description file path for this context.
    */
   String packageDescriptionPath;
 
   /**
    * Stream subscription we are using to watch the context's directory for
@@ skipping 20 matching lines @@
   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)
+      this.parent, Folder folder, File packagespecFile, this.packageRoot)
       : folder = folder,
         pathFilter = new PathFilter(folder.path, null) {
     packageDescriptionPath = packagespecFile.path;
-    for (ContextInfo child in children) {
-      child.parent = this;
-    }
+    parent.children.add(this);
   }
 
   /**
-   * Returns `true` if this context is root folder based.
+   * Create the virtual [ContextInfo] which acts as an ancestor to all other
+   * [ContextInfo]s.
    */
-  bool get isRoot => parent == null;
+  ContextInfo._ancestor()

[Brian Wilkerson, 2015/07/22 13:52:24]

Perhaps "ContextInfo._root"?

[Paul Berry, 2015/07/22 17:31:49]

Acknowledged.  After discussion this morning, I will look into the possibility
of clarifying the nomenclature in a future CL.

+      : folder = null,
+        pathFilter = null;
+
+  /**
+   * Returns `true` if the folder associated with this context is not contained
+   * within any other folders that have an associated context.
+   */
+  bool get isRoot => 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);
     });
   }
 
@@ skipping 225 matching lines @@
       new AnalysisOptionsProvider();
 
   /**
    * The instrumentation service used to report instrumentation data.
    */
   final InstrumentationService _instrumentationService;
 
   @override
   ContextManagerCallbacks callbacks;
 
+  /**
+   * Virtual [ContextInfo] which acts as the ancestor of all other
+   * [ContextInfo]s.
+   */
+  ContextInfo _ancestorInfo = new ContextInfo._ancestor();

[scheglov, 2015/07/22 00:05:51]

final?

[Brian Wilkerson, 2015/07/22 13:52:24]

Perhaps "_rootInfo"?

[Paul Berry, 2015/07/22 17:31:49]

Done.

+
   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)) {
@@ skipping 119 matching lines @@
         info.packageRoot = newPackageRoot;
         _recomputePackageUriResolver(info);
       }
     });
     // create new contexts
     for (Folder includedFolder in includedFolders) {
       bool wasIncluded = contextFolders.any((folder) {
         return folder.isOrContains(includedFolder.path);
       });
       if (!wasIncluded) {
-        _createContexts(includedFolder, false);
+        _createContexts(_ancestorInfo, includedFolder, false);
       }
     }
     // remove newly excluded sources
     _contexts.forEach((folder, info) {
       // 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;
@@ skipping 219 matching lines @@
         return null;
       }
       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].
+   * Create a new empty context associated with [folder], having parent
+   * [parent] and using [packagespecFile] to resolve package URI's.
    */
   ContextInfo _createContext(
-      Folder folder, File packagespecFile, List<ContextInfo> children) {
+      ContextInfo parent, Folder folder, File packagespecFile) {
     ContextInfo info = new ContextInfo(
-        folder, packagespecFile, children, normalizedPackageRoots[folder.path]);
+        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;
 
@@ skipping 21 matching lines @@
   /**
    * 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].
    *
    * 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.
+   * [parent] should be the parent of any contexts that are created.
    */
-  List<ContextInfo> _createContexts(Folder folder, bool withPackageSpecOnly) {
-    // Try to find subfolders with pubspecs or .packages files.
-    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.
-    }
-
+  void _createContexts(
+      ContextInfo parent, Folder folder, bool withPackageSpecOnly) {
+    // Decide whether a context needs to be created for [folder] here, and if
+    // so, create it.
     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>[
-        _createContextWithSources(folder, packageSpec, children)
-      ];
+    bool parentCreated = false;
+    if (packageSpec.exists || !withPackageSpecOnly) {
+      parentCreated = true;
+      parent = _createContext(parent, folder, packageSpec);
     }
-    // No packagespec? Done.
-    if (withPackageSpecOnly) {
-      return children;
+
+    // Try to find subfolders with pubspecs or .packages files.
+    try {
+      for (Resource child in folder.getChildren()) {
+        if (child is Folder) {
+          _createContexts(parent, 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.
     }
-    // OK, create a context without a packagespec.
-    return <ContextInfo>[
-      _createContextWithSources(folder, packageSpec, children)
-    ];
+
+    if (parentCreated) {
+      // 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);
+    }
   }
 
   /**
-   * 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);
-    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];
     info.changeSubscription.cancel();
     _cancelDependencySubscriptions(info);
     callbacks.removeContext(folder, _computeFlushedFiles(folder));
+    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(newFolder, packagespecFile, []);
-    newInfo.parent = oldInfo;
+    ContextInfo newInfo = _createContext(oldInfo, newFolder, packagespecFile);
     // 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);
     }
+    // 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.
   }
 
   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;
@@ skipping 253 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});
 }