Improve package root tests.

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 768 matching lines @@
           } catch (e, s) {
             // Ignore packages that do not exist
             _instrumentationService.logException(e, s);
             continue;
           }
           Resource res = resourceProvider.getResource(path);
           if (res is Folder) {
             packageMap[file.getName()] = <Folder>[res];
           }
         }
-        return new PackageMapDisposition(packageMap);
+        return new PackageMapDisposition(packageMap,
+            packageRoot: info.packageRoot);
       }
       // The package root does not exist (or is not a folder).  Since
       // [setRoots] ignores any package roots that don't exist (or aren't
       // folders), the only way we should be able to get here is due to a race
       // condition.  In any case, the package root folder is gone, so we can't
       // resolve packages.
-      return new NoPackageFolderDisposition();
+      return new NoPackageFolderDisposition(packageRoot: info.packageRoot);
     } else {
       callbacks.beginComputePackageMap();
       if (packageResolverProvider != null) {
         UriResolver resolver = packageResolverProvider(folder);
         if (resolver != null) {
           return new CustomPackageResolverDisposition(resolver);
         }
       }
       PackageMapInfo packageMapInfo;
       ServerPerformanceStatistics.pub.makeCurrentWhile(() {
@@ skipping 455 matching lines @@
  */
 class CustomPackageResolverDisposition extends FolderDisposition {
   /**
    * The [UriResolver] that should be used to resolve package URIs.
    */
   UriResolver resolver;
 
   CustomPackageResolverDisposition(this.resolver);
 
   @override
+  String get packageRoot => null;
+
+  @override
   Packages get packages => null;
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
       ResourceProvider resourceProvider) => <UriResolver>[resolver];
 }
 
 /**
  * An instance of the class [FolderDisposition] represents the information
  * gathered by the [ContextManagerImpl] to determine how to create an
  * [AnalysisContext] 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).
  */
 abstract class FolderDisposition {
   /**
+   * If this [FolderDisposition] was created based on a package root
+   * folder, the absolute path to that folder.  Otherwise `null`.
+   */
+  String get packageRoot;
+
+  /**
    * If contexts governed by this [FolderDisposition] should resolve packages
    * using the ".packages" file mechanism (DEP 5), retrieve the [Packages]
    * object that resulted from parsing the ".packages" file.
    */
   Packages get packages;
 
   /**
    * Create all the [UriResolver]s which should be used to resolve packages in
    * contexts governed by this [FolderDisposition].
    *
    * [resourceProvider] is provided since it is needed to construct most
    * [UriResolver]s.
    */
   Iterable<UriResolver> createPackageUriResolvers(
       ResourceProvider resourceProvider);
 }
 
 /**
  * Concrete [FolderDisposition] object indicating that the context for a given
  * folder should not resolve "package:" URIs at all.
- *
- * TODO(paulberry): consider making this a singleton object (which would cause
- * all folders that don't resolve "package:" URIs to share the same context).
  */
 class NoPackageFolderDisposition extends FolderDisposition {
   @override
+  final String packageRoot;
+
+  NoPackageFolderDisposition({this.packageRoot});
+
+  @override
   Packages get packages => null;
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
       ResourceProvider resourceProvider) => const <UriResolver>[];
 }
 
 /**
  * Concrete [FolderDisposition] object indicating that the context for a given
  * folder should resolve packages using a package map.
  */
 class PackageMapDisposition extends FolderDisposition {
   final Map<String, List<Folder>> packageMap;
 
-  PackageMapDisposition(this.packageMap);
+  @override
+  final String packageRoot;
+
+  PackageMapDisposition(this.packageMap, {this.packageRoot});
 
   @override
   Packages get packages => null;
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
           ResourceProvider resourceProvider) =>
       <UriResolver>[new PackageMapUriResolver(resourceProvider, packageMap)];
 }
 
 /**
  * Concrete [FolderDisposition] object indicating that the context for a given
  * folder should resolve packages using a ".packages" file.
  */
 class PackagesFileDisposition extends FolderDisposition {
   @override
   final Packages packages;
 
   PackagesFileDisposition(this.packages) {}
 
   @override
+  String get packageRoot => null;
+
+  @override
   Iterable<UriResolver> createPackageUriResolvers(
       ResourceProvider resourceProvider) => const <UriResolver>[];
 }