Replace making getInnermostContext public with making a getFolder method

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';
@@ skipping 283 matching lines @@
    * 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);
 
   /**
-   * 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.)
+   * Like [getDriverFor] and [getContextFor], but returns the [Folder] which
+   * allows plugins to create & manage their own tree of drivers just like using
+   * [getDriverFor].
    *
-   * If no context contains the given path, `null` is returned.
+   * 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 is public at least temporarily, for plugin support until the new API
-   * is ready.
+   * This exists at least temporarily, for plugin support until the new API is
+   * ready.
    */
-  ContextInfo getInnermostContextInfoFor(String path);
+  Folder getContextFolderFor(String path);
 
   /**
    * Return a list of all of the analysis drivers reachable from the given
    * [analysisRoot] (the driver associated with [analysisRoot] and all of its
    * descendants).
    */
   List<AnalysisDriver> getDriversInAnalysisRoot(Folder analysisRoot);
 
   /**
    * Return `true` if the given [path] is ignored by a [ContextInfo] whose
@@ skipping 249 matching lines @@
       throw new StateError('Should not be used with the new analysis driver');
     } else {
       return _folderMap;
     }
   }
 
   @override
   List<AnalysisContext> contextsInAnalysisRoot(Folder analysisRoot) {
     List<AnalysisContext> contexts = <AnalysisContext>[];
     ContextInfo innermostContainingInfo =
-        getInnermostContextInfoFor(analysisRoot.path);
+        _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;
 
   @override
   AnalysisContext getContextFor(String path) {
-    return getInnermostContextInfoFor(path)?.context;
+    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);
+    ContextInfo info = _getInnermostContextInfoFor(folder.path);
     if (info != null && folder == info.folder) {
       return info;
     }
     return null;
   }
 
   @override
   AnalysisDriver getDriverFor(String path) {
-    return getInnermostContextInfoFor(path)?.analysisDriver;
+    return _getInnermostContextInfoFor(path)?.analysisDriver;
+  }
+
+  Folder getContextFolderFor(String path) {
+    return _getInnermostContextInfoFor(path)?.folder;
   }
 
   @override
   List<AnalysisDriver> getDriversInAnalysisRoot(Folder analysisRoot) {
     List<AnalysisDriver> drivers = <AnalysisDriver>[];
     void addContextAndDescendants(ContextInfo info) {
       drivers.add(info.analysisDriver);
       info.children.forEach(addContextAndDescendants);
     }
 
     ContextInfo innermostContainingInfo =
-        getInnermostContextInfoFor(analysisRoot.path);
+        _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);
           }
         }
       }
@@ skipping 694 matching lines @@
 
   /**
    * 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 _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;
     }
   }
 
   /**
    * Return the parent for a new [ContextInfo] with the given [path] folder.
    */
   ContextInfo _getParentForNewContext(String path) {
-    ContextInfo parent = getInnermostContextInfoFor(path);
+    ContextInfo parent = _getInnermostContextInfoFor(path);
     if (parent != null) {
       return parent;
     }
     return rootInfo;
   }
 
   void _handleWatchEvent(WatchEvent event) {
     // Figure out which context this event applies to.
     // 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).
-    ContextInfo info = getInnermostContextInfoFor(event.path);
+    ContextInfo info = _getInnermostContextInfoFor(event.path);
     if (info == null) {
       // This event doesn't apply to any context.  This could happen due to a
       // race condition (e.g. a context was removed while one of its events was
       // in the event loop).  The event is inapplicable now, so just ignore it.
       return;
     }
     _instrumentationService.logWatchEvent(
         info.folder.path, event.path, event.type.toString());
     String path = event.path;
     // First handle changes that affect folderDisposition (since these need to
@@ skipping 558 matching lines @@
     }
     return _embedderLocator;
   }
 
   @override
   SdkExtensionFinder getSdkExtensionFinder(ResourceProvider resourceProvider) {
     return _sdkExtensionFinder ??=
         new SdkExtensionFinder(buildPackageMap(resourceProvider));
   }
 }