In analysis server, favor package root setting over ".packages" file.

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 712 matching lines @@
   /**
    * Compute the appropriate [FolderDisposition] for [folder].  Use
    * [addDependency] to indicate which files needed to be consulted in order to
    * figure out the [FolderDisposition]; these dependencies will be watched in
    * order to determine when it is necessary to call this function again.
    *
    * TODO(paulberry): use [addDependency] for tracking all folder disposition
    * dependencies (currently we only use it to track "pub list" dependencies).
    */
   FolderDisposition _computeFolderDisposition(
-      Folder folder, void addDependency(String path)) {
+      Folder folder, void addDependency(String path), File packagespecFile) {
     String packageRoot = normalizedPackageRoots[folder.path];
     if (packageRoot != null) {
       // TODO(paulberry): We shouldn't be using JavaFile here because it
       // makes the code untestable (see dartbug.com/23909).
       JavaFile packagesDir = new JavaFile(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
@@ skipping 12 matching lines @@
         }
         return new PackageMapDisposition(packageMap, packageRoot: 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(packageRoot: packageRoot);
     } else {
+      PackageMapInfo packageMapInfo;
       callbacks.beginComputePackageMap();
-      if (packageResolverProvider != null) {
-        UriResolver resolver = packageResolverProvider(folder);
-        if (resolver != null) {
-          return new CustomPackageResolverDisposition(resolver);
+      try {
+        if (ENABLE_PACKAGESPEC_SUPPORT) {
+          // Try .packages first.
+          if (pathos.basename(packagespecFile.path) == PACKAGE_SPEC_NAME) {
+            Packages packages = _readPackagespec(packagespecFile);
+            return new PackagesFileDisposition(packages);
+          }
         }
+        if (packageResolverProvider != null) {
+          UriResolver resolver = packageResolverProvider(folder);
+          if (resolver != null) {
+            return new CustomPackageResolverDisposition(resolver);
+          }
+        }
+        ServerPerformanceStatistics.pub.makeCurrentWhile(() {
+          packageMapInfo = _packageMapProvider.computePackageMap(folder);
+        });
+      } finally {
+        callbacks.endComputePackageMap();
       }
-      PackageMapInfo packageMapInfo;
-      ServerPerformanceStatistics.pub.makeCurrentWhile(() {
-        packageMapInfo = _packageMapProvider.computePackageMap(folder);
-      });
-      callbacks.endComputePackageMap();
       for (String dependencyPath in packageMapInfo.dependencies) {
         addDependency(dependencyPath);
       }
       if (packageMapInfo.packageMap == null) {
         return new NoPackageFolderDisposition();
       }
       return new PackageMapDisposition(packageMapInfo.packageMap);
     }
   }
 
   /**
    * 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(this, parent, folder, packagespecFile,
         normalizedPackageRoots[folder.path]);
     Map<String, YamlNode> options = analysisOptionsProvider.getOptions(folder);
     processOptionsForContext(info, options);
     FolderDisposition disposition;
     List<String> dependencies = <String>[];
 
-    if (ENABLE_PACKAGESPEC_SUPPORT) {
-      // Try .packages first.
-      if (pathos.basename(packagespecFile.path) == PACKAGE_SPEC_NAME) {
-        Packages packages = _readPackagespec(packagespecFile);
-        disposition = new PackagesFileDisposition(packages);
-      }
-    }
-
     // Next resort to a package uri resolver.
     if (disposition == null) {
-      disposition = _computeFolderDisposition(folder, dependencies.add);
+      disposition =
+          _computeFolderDisposition(folder, dependencies.add, packagespecFile);
     }
 
     info.setDependencies(dependencies);
     info.context = callbacks.addContext(folder, disposition);
     info.context.name = folder.path;
     return info;
   }
 
   /**
    * 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].
    *
    * [parent] should be the parent of any contexts that are created.
    */
   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);
-    }
-
+    File packageSpec = _findPackageSpecFile(folder);
     bool createContext = packageSpec.exists || !withPackageSpecOnly;
     if (withPackageSpecOnly &&
         packageSpec.exists &&
         (parent != null) &&
         parent.ignored(packageSpec.path)) {
       // Don't create a context if the package spec is required and ignored.
       createContext = false;
     }
     if (createContext) {
       parent = _createContext(parent, folder, packageSpec);
@@ skipping 64 matching lines @@
         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.
   }
 
   /**
+   * Find the file that should be used to determine whether a context needs to
+   * be created here--this is either the ".packages" file or the "pubspec.yaml"
+   * file.
+   */
+  File _findPackageSpecFile(Folder folder) {
+    // 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);
+    }
+    return packageSpec;
+  }
+
+  /**
    * 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);
@@ skipping 233 matching lines @@
   /**
    * Recompute the [FolderDisposition] for the context described by [info],
    * and update the client appropriately.
    */
   void _recomputeFolderDisposition(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.
     List<String> dependencies = <String>[];
-    FolderDisposition disposition =
-        _computeFolderDisposition(info.folder, dependencies.add);
+    FolderDisposition disposition = _computeFolderDisposition(
+        info.folder, dependencies.add, _findPackageSpecFile(info.folder));
     info.setDependencies(dependencies);
     callbacks.updateContextPackageUriResolver(info.folder, disposition);
   }
 
   /**
    * Create and return a source representing the given [file] within the given
    * [context].
    */
   static Source createSourceInContext(AnalysisContext context, File file) {
     // TODO(brianwilkerson) Optimize this, by allowing support for source
@@ skipping 155 matching lines @@
   PackagesFileDisposition(this.packages) {}
 
   @override
   String get packageRoot => null;
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
           ResourceProvider resourceProvider) =>
       const <UriResolver>[];
 }