Move more behavior out of ContextManagerCallbacks and into 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;
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/embedded_resolver_provider.dart';
 import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/source/embedder.dart';
 import 'package:analyzer/source/package_map_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/source/path_filter.dart';
 import 'package:analyzer/source/pub_package_map_provider.dart';
 import 'package:analyzer/source/sdk_ext.dart';
 import 'package:analyzer/src/context/context.dart' as context;
 import 'package:analyzer/src/context/source.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/java_io.dart';
+import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/task/options.dart';
 import 'package:analyzer/src/util/absolute_path.dart';
 import 'package:analyzer/src/util/glob.dart';
 import 'package:analyzer/src/util/yaml.dart';
 import 'package:package_config/packages.dart';
 import 'package:package_config/packages_file.dart' as pkgfile show parse;
 import 'package:package_config/src/packages_impl.dart' show MapPackages;
 import 'package:path/path.dart' as pathos;
@@ skipping 301 matching lines @@
   void computingPackageMap(bool computing);
 
   /**
    * Remove the context associated with the given [folder].  [flushedFiles] is
    * a list of the files which will be "orphaned" by removing this context
    * (they will no longer be analyzed by any context).
    */
   void removeContext(Folder folder, List<String> flushedFiles);
 
   /**
-   * Called when the disposition for a context has changed.
+   * Called when the package resolution for the given [context] has changed.
    */
-  void updateContextPackageUriResolver(
-      Folder contextFolder, FolderDisposition disposition);
+  void updateContextPackageUriResolver(AnalysisContext context);
 }
 
 /**
  * Class that maintains a mapping from included/excluded paths to a set of
  * folders that should correspond to analysis contexts.
  */
 class ContextManagerImpl implements ContextManager {
   /**
    * The name of the `doc` directory.
    */
@@ skipping 18 matching lines @@
    * File name of package spec files.
    */
   static const String PACKAGE_SPEC_NAME = '.packages';
 
   /**
    * The [ResourceProvider] using which paths are converted into [Resource]s.
    */
   final ResourceProvider resourceProvider;
 
   /**
+   * The manager used to access the SDK that should be associated with a
+   * particular context.
+   */
+  final DartSdkManager sdkManager;
+
+  /**
    * The context used to work with absolute file system paths.
    *
    * TODO(scheglov) remove [pathContext].
    */
   AbsolutePathContext absolutePathContext;
 
   /**
    * The context used to work with file system paths.
    */
   pathos.Context pathContext;
@@ skipping 78 matching lines @@
 
   /**
    * Stream subscription we are using to watch each analysis root directory for
    * changes.
    */
   final Map<Folder, StreamSubscription<WatchEvent>> changeSubscriptions =
       <Folder, StreamSubscription<WatchEvent>>{};
 
   ContextManagerImpl(
       this.resourceProvider,
+      this.sdkManager,
       this.packageResolverProvider,
       this.embeddedUriResolverProvider,
       this._packageMapProvider,
       this.analyzedFilesGlobs,
       this._instrumentationService,
       this.defaultContextOptions) {
     absolutePathContext = resourceProvider.absolutePathContext;
     pathContext = resourceProvider.pathContext;
   }
 
@@ skipping 420 matching lines @@
               info.context.sourceFactory = newFactory;
               return;
             }
           }
         }
 
         // Next check for package URI updates.
         if (info.isPathToPackageDescription(path)) {
           Packages packages = _readPackagespec(packagespec);
           if (packages != null) {
-            callbacks.updateContextPackageUriResolver(
+            _updateContextPackageUriResolver(
                 folder, new PackagesFileDisposition(packages));
           }
         }
       }
     }
   }
 
   /**
    * Compute the set of files that are being flushed, this is defined as
    * the set of sources in the removed context (context.sources), that are
@@ skipping 116 matching lines @@
           _computeFolderDisposition(folder, dependencies.add, packagespecFile);
     }
 
     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;
 
     processOptionsForContext(info, optionMap);
 
     return info;
   }
 
   /**
    * Potentially create a new context associated with the given [folder].
    *
@@ skipping 45 matching lines @@
     if (createContext) {
       // 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);
     }
   }
 
   /**
+   * 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);
+
+    EmbedderUriResolver embedderUriResolver;
+
+    // First check for a resolver provider.
+    if (embeddedUriResolverProvider != null) {
+      embedderUriResolver = embeddedUriResolverProvider(folder);
+    }
+
+    // If no embedded URI resolver was provided, defer to a locator-backed one.
+    embedderUriResolver ??=
+        new EmbedderUriResolver(context.embedderYamlLocator.embedderYamls);
+    if (embedderUriResolver.length == 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(embedderUriResolver);
+    }
+
+    resolvers.addAll(packageUriResolvers);
+    resolvers.add(new ResourceUriResolver(resourceProvider));
+    return new SourceFactory(resolvers, disposition.packages);
+  }
+
+  /**
    * Clean up and destroy the context associated with the given folder.
    */
   void _destroyContext(ContextInfo info) {
     changeSubscriptions.remove(info.folder)?.cancel();
     callbacks.removeContext(info.folder, _computeFlushedFiles(info));
     bool wasRemoved = info.parent.children.remove(info);
     assert(wasRemoved);
   }
 
   /**
@@ skipping 349 matching lines @@
    */
   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, _findPackageSpecFile(info.folder));
     info.setDependencies(dependencies);
-    callbacks.updateContextPackageUriResolver(info.folder, disposition);
+    _updateContextPackageUriResolver(info.folder, disposition);
   }
 
   /**
    * Return `true` if the given [file] should be analyzed.
    */
   bool _shouldFileBeAnalyzed(File file) {
     for (Glob glob in analyzedFilesGlobs) {
       if (glob.matches(file.path)) {
         // Emacs creates dummy links to track the fact that a file is open for
         // editing and has unsaved changes (e.g. having unsaved changes to
         // 'foo.dart' causes a link '.#foo.dart' to be created, which points to
         // the non-existent file 'username@hostname.pid'. To avoid these dummy
         // links causing the analyzer to thrash, just ignore links to
         // non-existent files.
         return file.exists;
       }
     }
     return false;
   }
 
+  void _updateContextPackageUriResolver(
+      Folder contextFolder, FolderDisposition disposition) {
+    AnalysisContext context = folderMap[contextFolder];
+    context.sourceFactory = _createSourceFactory(
+        context, context.analysisOptions, disposition, contextFolder);
+    callbacks.updateContextPackageUriResolver(context);
+  }
+
   /**
    * 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
     // factories to restore URI's from a file path rather than a source.
     Source source = file.createSource();
     if (context == null) {
       return source;
@@ skipping 175 matching lines @@
       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>[];
     }
   }
 }