Remove embedder locator from analysis context

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 58 matching lines @@
    * objects.
    */
   ContextInfo parent;
 
   /**
    * The package description file path for this context.
    */
   String packageDescriptionPath;
 
   /**
+   * The folder disposition for this context.
+   */
+  final FolderDisposition disposition;
+
+  /**
    * Paths to files which determine the folder disposition and package map.
    *
    * TODO(paulberry): if any of these files are outside of [folder], they won't
    * be watched for changes.  I believe the use case for watching these files
    * is no longer relevant.
    */
   Set<String> _dependencies = new Set<String>();
 
   /**
    * The analysis context that was created for the [folder].
    */
   AnalysisContext context;
 
   /**
    * Map from full path to the [Source] object, for each source that has been
    * added to the context.
    */
   Map<String, Source> sources = new HashMap<String, Source>();
 
   ContextInfo(ContextManagerImpl contextManager, this.parent, Folder folder,
-      File packagespecFile, this.packageRoot)
+      File packagespecFile, this.packageRoot, this.disposition)
       : folder = folder,
         pathFilter = new PathFilter(
             folder.path, null, contextManager.resourceProvider.pathContext) {
     packageDescriptionPath = packagespecFile.path;
     parent.children.add(this);
   }
 
   /**
    * Create the virtual [ContextInfo] which acts as an ancestor to all other
    * [ContextInfo]s.
    */
   ContextInfo._root()
       : folder = null,
-        pathFilter = null;
+        pathFilter = null,
+        packageRoot = null,
+        disposition = null;
 
   /**
    * Iterate through all [children] and their children, recursively.
    */
   Iterable<ContextInfo> get descendants sync* {
     for (ContextInfo child in children) {
       yield child;
       yield* child.descendants;
     }
   }
@@ skipping 452 matching lines @@
     if (options == null && !optionsRemoved) {
       return;
     }
 
     // In case options files are removed, revert to defaults.
     if (optionsRemoved) {
       // Start with defaults.
       info.context.analysisOptions = new AnalysisOptionsImpl();
 
       // Apply inherited options.
-      options = _toStringMap(_getEmbeddedOptions(info.context));
+      options = _toStringMap(_getEmbeddedOptions(info));
       if (options != null) {
         configureContextOptions(info.context, options);
       }
     } else {
       // Check for embedded options.
-      Map embeddedOptions = _getEmbeddedOptions(info.context);
+      Map embeddedOptions = _getEmbeddedOptions(info);
       if (embeddedOptions != null) {
         options = _toStringMap(new Merger().merge(embeddedOptions, options));
       }
     }
 
     // Notify options processors.
     AnalysisEngine.instance.optionsPlugin.optionsProcessors
         .forEach((OptionsProcessor p) {
       try {
         p.optionsProcessed(info.context, options);
@@ skipping 429 matching lines @@
       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) {
+    List<String> dependencies = <String>[];
+    FolderDisposition disposition =
+        _computeFolderDisposition(folder, dependencies.add, packagespecFile);
     ContextInfo info = new ContextInfo(this, parent, folder, packagespecFile,
-        normalizedPackageRoots[folder.path]);
-
-    FolderDisposition disposition;
-    List<String> dependencies = <String>[];
-
-    // Next resort to a package uri resolver.
-    if (disposition == null) {
-      disposition =
-          _computeFolderDisposition(folder, dependencies.add, packagespecFile);
-    }
+        normalizedPackageRoots[folder.path], disposition);
 
     Map<String, Object> optionMap = readOptions(info.folder);
     AnalysisOptions options =
         new AnalysisOptionsImpl.from(defaultContextOptions);
     applyToAnalysisOptions(options, optionMap);
 
     info.setDependencies(dependencies);
     info.context = callbacks.addContext(folder, options, disposition);
     folderMap[folder] = info.context;
     info.context.name = folder.path;
@@ skipping 84 matching lines @@
   /**
    * Set up a [SourceFactory] that resolves packages as appropriate for the
    * given [disposition].
    */
   SourceFactory _createSourceFactory(InternalAnalysisContext context,
       AnalysisOptions options, FolderDisposition disposition, Folder folder) {
     List<UriResolver> resolvers = [];
     List<UriResolver> packageUriResolvers =
         disposition.createPackageUriResolvers(resourceProvider);
 
-    EmbedderSdk sdk =
-        new EmbedderSdk(context.embedderYamlLocator.embedderYamls);
+    EmbedderYamlLocator locator =
+        disposition.getEmbedderLocator(resourceProvider);
+    EmbedderSdk sdk = new EmbedderSdk(locator.embedderYamls);
     if (sdk.libraryMap.size() == 0) {
       // The embedder uri resolver has no mappings. Use the default Dart SDK
       // uri resolver.
       resolvers.add(new DartUriResolver(sdkManager.getSdkForOptions(options)));
     } else {
       // The embedder uri resolver has mappings, use it instead of the default
       // Dart SDK uri resolver.
       resolvers.add(new DartUriResolver(sdk));
     }
 
@@ skipping 67 matching lines @@
     }
     return packageSpec;
   }
 
   /// Get analysis options inherited from an `_embedder.yaml` (deprecated)
   /// and/or a package specified configuration.  If more than one
   /// `_embedder.yaml` is associated with the given context, the embedder is
   /// skipped.
   ///
   /// Returns null if there are no embedded/configured options.
-  Map _getEmbeddedOptions(AnalysisContext context) {
-    Map embeddedOptions;
+  Map _getEmbeddedOptions(ContextInfo info) {
+    Map embeddedOptions = null;
+    EmbedderYamlLocator locator =
+        info.disposition.getEmbedderLocator(resourceProvider);
+    Iterable<YamlMap> maps = locator.embedderYamls.values;
+    if (maps.length == 1) {
+      embeddedOptions = maps.first;
+    }
 
-    if (context is InternalAnalysisContext) {
-      EmbedderYamlLocator locator = context.embedderYamlLocator;
-      Iterable<YamlMap> maps = locator.embedderYamls.values;
-      if (maps.length == 1) {
-        embeddedOptions = maps.first;
-      }
-
-      AnalysisConfiguration configuration = getConfiguration(context);
-      if (configuration != null) {
-        Map configMap = configuration.options;
-        if (configMap != null) {
-          if (embeddedOptions != null) {
-            embeddedOptions = new Merger().merge(embeddedOptions, configMap);
-          } else {
-            embeddedOptions = configMap;
-          }
+    AnalysisConfiguration configuration = getConfiguration(info.context);
+    if (configuration != null) {
+      Map configMap = configuration.options;
+      if (configMap != null) {
+        if (embeddedOptions != null) {
+          embeddedOptions = new Merger().merge(embeddedOptions, configMap);
+        } else {
+          embeddedOptions = configMap;
         }
       }
     }
-
     return embeddedOptions;
   }
 
   /**
    * 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.)
    *
@@ skipping 411 matching lines @@
   @override
   String get packageRoot => null;
 
   @override
   Packages get packages => null;
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
           ResourceProvider resourceProvider) =>
       <UriResolver>[resolver];
+
+  @override
+  EmbedderYamlLocator getEmbedderLocator(ResourceProvider resourceProvider) =>
+      new EmbedderYamlLocator(null);
 }
 
 /**
  * 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
@@ skipping 20 matching lines @@
 
   /**
    * 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);
+
+  /**
+   * Return the locator used to locate the _embedder.yaml file used to configure
+   * the SDK. The [resourceProvider] is used to access the file system in cases
+   * where that is necessary.
+   */
+  EmbedderYamlLocator getEmbedderLocator(ResourceProvider resourceProvider);
 }
 
 /**
  * Concrete [FolderDisposition] object indicating that the context for a given
  * folder should not resolve "package:" URIs at all.
  */
 class NoPackageFolderDisposition extends FolderDisposition {
   @override
   final String packageRoot;
 
   NoPackageFolderDisposition({this.packageRoot});
 
   @override
   Packages get packages => null;
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
           ResourceProvider resourceProvider) =>
       const <UriResolver>[];
+
+  @override
+  EmbedderYamlLocator getEmbedderLocator(ResourceProvider resourceProvider) =>
+      new EmbedderYamlLocator(null);
 }
 
 /**
  * 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;
 
+  EmbedderYamlLocator _embedderLocator;
+
   @override
   final String packageRoot;
 
   PackageMapDisposition(this.packageMap, {this.packageRoot});
 
   @override
   Packages get packages => null;
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
           ResourceProvider resourceProvider) =>
       <UriResolver>[
         new SdkExtUriResolver(packageMap),
         new PackageMapUriResolver(resourceProvider, packageMap)
       ];
+
+  @override
+  EmbedderYamlLocator getEmbedderLocator(ResourceProvider resourceProvider) {
+    if (_embedderLocator == null) {
+      _embedderLocator = new EmbedderYamlLocator(packageMap);
+    }
+    return _embedderLocator;
+  }
 }
 
 /**
  * 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;
 
+  Map<String, List<Folder>> packageMap;
+
+  EmbedderYamlLocator _embedderLocator;
+
   PackagesFileDisposition(this.packages);
 
   @override
   String get packageRoot => null;
 
   Map<String, List<Folder>> buildPackageMap(ResourceProvider resourceProvider) {
-    Map<String, List<Folder>> packageMap = <String, List<Folder>>{};
-    if (packages == null) {
-      return packageMap;
+    if (packageMap == null) {
+      packageMap = <String, List<Folder>>{};
+      if (packages != null) {
+        packages.asMap().forEach((String name, Uri uri) {
+          if (uri.scheme == 'file' || uri.scheme == '' /* unspecified */) {
+            var path = resourceProvider.pathContext.fromUri(uri);
+            packageMap[name] = <Folder>[resourceProvider.getFolder(path)];
+          }
+        });
+      }
     }
-    packages.asMap().forEach((String name, Uri uri) {
-      if (uri.scheme == 'file' || uri.scheme == '' /* unspecified */) {
-        var path = resourceProvider.pathContext.fromUri(uri);
-        packageMap[name] = <Folder>[resourceProvider.getFolder(path)];
-      }
-    });
     return packageMap;
   }
 
   @override
   Iterable<UriResolver> createPackageUriResolvers(
       ResourceProvider resourceProvider) {
     if (packages != null) {
       // Construct package map for the SdkExtUriResolver.
       Map<String, List<Folder>> packageMap = buildPackageMap(resourceProvider);
       return <UriResolver>[new SdkExtUriResolver(packageMap)];
     } else {
       return const <UriResolver>[];
     }
   }
+
+  @override
+  EmbedderYamlLocator getEmbedderLocator(ResourceProvider resourceProvider) {
+    if (_embedderLocator == null) {
+      _embedderLocator =
+          new EmbedderYamlLocator(buildPackageMap(resourceProvider));
+    }
+    return _embedderLocator;
+  }
 }