Convert analysis server over to use ContextBuilder

pkg/analysis_server/lib/src/analysis_server.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 analysis.server;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:core' hide Resource;
 import 'dart:io' as io;
@@ skipping 14 matching lines @@
 import 'package:analysis_server/src/services/search/search_engine_internal.dart';
 import 'package:analysis_server/src/single_context_manager.dart';
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/pub_package_map_provider.dart';
 import 'package:analyzer/src/context/builder.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
-import 'package:analyzer/src/dart/sdk/sdk.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/generated/utilities_general.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/pub_summary.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/util/glob.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:plugin/plugin.dart';
-import 'package:yaml/yaml.dart';
 
 typedef void OptionUpdater(AnalysisOptionsImpl options);
 
 /**
  * Enum representing reasons why analysis might be done for a given file.
  */
 class AnalysisDoneReason {
   /**
    * Analysis of the file completed successfully.
    */
@@ skipping 1529 matching lines @@
   /**
    * The [ResourceProvider] by which paths are converted into [Resource]s.
    */
   final ResourceProvider resourceProvider;
 
   ServerContextManagerCallbacks(this.analysisServer, this.resourceProvider);
 
   @override
   AnalysisContext addContext(
       Folder folder, AnalysisOptions options, FolderDisposition disposition) {
-    InternalAnalysisContext context =
-        AnalysisEngine.instance.createAnalysisContext();
-    context.contentCache = analysisServer.overlayState;
-    analysisServer.folderMap[folder] = context;
-    context.fileResolverProvider = analysisServer.fileResolverProvider;
-    context.sourceFactory =
-        _createSourceFactory(context, options, disposition, folder);
-    context.analysisOptions = options;
+    ContextBuilder builder = createContextBuilder(folder, options);
+    AnalysisContext context = builder.buildContext(folder.path);
+
+    // TODO(brianwilkerson) Move bundle discovery into ContextBuilder
     if (analysisServer.options.enablePubSummaryManager) {
       List<LinkedPubPackage> linkedBundles =
           analysisServer.pubSummaryManager.getLinkedBundles(context);
       if (linkedBundles.isNotEmpty) {
         SummaryDataStore store = new SummaryDataStore([]);
         for (LinkedPubPackage package in linkedBundles) {
           store.addBundle(null, package.unlinked);
           store.addBundle(null, package.linked);
         }
-        context.resultProvider =
+        (context as InternalAnalysisContext).resultProvider =
             new InputPackagesResultProvider(context, store);
       }
     }
 
+    analysisServer.folderMap[folder] = context;
     analysisServer._onContextsChangedController
         .add(new ContextsChangedEvent(added: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
 
     return context;
   }
 
   @override
   void applyChangesToContext(Folder contextFolder, ChangeSet changeSet) {
     AnalysisContext context = analysisServer.folderMap[contextFolder];
     if (context != null) {
       ApplyChangesStatus changesStatus = context.applyChanges(changeSet);
       if (changesStatus.hasChanges) {
         analysisServer.schedulePerformAnalysisOperation(context);
       }
       List<String> flushedFiles = new List<String>();
       for (Source source in changeSet.removedSources) {
         flushedFiles.add(source.fullName);
       }
       sendAnalysisNotificationFlushResults(analysisServer, flushedFiles);
     }
   }
 
   @override
   void computingPackageMap(bool computing) =>
       analysisServer._computingPackageMap(computing);
 
   @override
+  ContextBuilder createContextBuilder(Folder folder, AnalysisOptions options) {
+    String defaultPackageFilePath = null;
+    String defaultPackagesDirectoryPath = null;
+    String path = (analysisServer.contextManager as ContextManagerImpl)
+        .normalizedPackageRoots[folder.path];
+    if (path != null) {
+      Resource resource = resourceProvider.getResource(path);
+      if (resource.exists) {
+        if (resource is File) {
+          defaultPackageFilePath = path;
+        } else {
+          defaultPackagesDirectoryPath = path;
+        }
+      }
+    }
+
+    ContextBuilder builder = new ContextBuilder(resourceProvider,
+        analysisServer.sdkManager, analysisServer.overlayState);
+    builder.defaultOptions = options;
+    builder.fileResolverProvider = analysisServer.fileResolverProvider;
+    builder.defaultPackageFilePath = defaultPackageFilePath;
+    builder.defaultPackagesDirectoryPath = defaultPackagesDirectoryPath;
+    return builder;
+  }
+
+  @override
   void moveContext(Folder from, Folder to) {
     // There is nothing to do.
     // This method is mostly for tests.
     // Context managers manage folders and contexts themselves.
   }
 
   @override
   void removeContext(Folder folder, List<String> flushedFiles) {
     AnalysisContext context = analysisServer.folderMap.remove(folder);
     sendAnalysisNotificationFlushResults(analysisServer, flushedFiles);
 
     analysisServer.operationQueue.contextRemoved(context);
     analysisServer._onContextsChangedController
         .add(new ContextsChangedEvent(removed: [context]));
     analysisServer.sendContextAnalysisDoneNotifications(
         context, AnalysisDoneReason.CONTEXT_REMOVED);
     context.dispose();
   }
 
   @override
   void updateContextPackageUriResolver(AnalysisContext context) {
     analysisServer._onContextsChangedController
         .add(new ContextsChangedEvent(changed: [context]));
     analysisServer.schedulePerformAnalysisOperation(context);
   }
-
-  /**
-   * 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);
-
-    // If no embedded URI resolver was provided, defer to a locator-backed one.
-    SdkExtensionFinder extFinder =
-        disposition.getSdkExtensionFinder(resourceProvider);
-    List<String> extFilePaths = extFinder.extensionFilePaths;
-    EmbedderYamlLocator locator =
-        disposition.getEmbedderLocator(resourceProvider);
-    Map<Folder, YamlMap> embedderYamls = locator.embedderYamls;
-    EmbedderSdk embedderSdk = new EmbedderSdk(resourceProvider, embedderYamls);
-    if (embedderSdk.libraryMap.size() == 0) {
-      // There was no embedder file, or the file was empty, so used the default
-      // SDK.
-      resolvers.add(new DartUriResolver(
-          analysisServer.sdkManager.getSdkForOptions(options)));
-    } else {
-      // The embedder file defines an alternate SDK, so use it.
-      List<String> paths = <String>[];
-      for (Folder folder in embedderYamls.keys) {
-        paths.add(folder
-            .getChildAssumingFile(EmbedderYamlLocator.EMBEDDER_FILE_NAME)
-            .path);
-      }
-      paths.addAll(extFilePaths);
-      DartSdk dartSdk = analysisServer.sdkManager
-          .getSdk(new SdkDescription(paths, options), () {
-        if (extFilePaths.isNotEmpty) {
-          embedderSdk.addExtensions(extFinder.urlMappings);
-        }
-        embedderSdk.analysisOptions = options;
-        // TODO(brianwilkerson) Enable summary use after we have decided where
-        // summary files for embedder files will live.
-        embedderSdk.useSummary = false;
-        return embedderSdk;
-      });
-      resolvers.add(new DartUriResolver(dartSdk));
-    }
-
-    resolvers.addAll(packageUriResolvers);
-    UriResolver fileResolver;
-    if (context.fileResolverProvider != null) {
-      fileResolver = context.fileResolverProvider(folder);
-    }
-    resolvers.add(fileResolver ?? new ResourceUriResolver(resourceProvider));
-    return new SourceFactory(resolvers, disposition.packages);
-  }
 }
 
 /**
  * A class used by [AnalysisServer] to record performance information
  * such as request latency.
  */
 class ServerPerformance {
   /**
    * The creation time and the time when performance information
    * started to be recorded here.
@@ skipping 83 matching lines @@
   /**
    * The [PerformanceTag] for time spent in server request handlers.
    */
   static PerformanceTag serverRequests = new PerformanceTag('serverRequests');
 
   /**
    * The [PerformanceTag] for time spent in split store microtasks.
    */
   static PerformanceTag splitStore = new PerformanceTag('splitStore');
 }