Move driver creation into ContextBuilder

pkg/analyzer/lib/src/context/builder.dart

 // Copyright (c) 2016, 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 analyzer.src.context.context_builder;
 
 import 'dart:collection';
 import 'dart:core';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/src/command_line/arguments.dart'
     show applyAnalysisOptionFlags;
+import 'package:analyzer/src/dart/analysis/byte_store.dart';
+import 'package:analyzer/src/dart/analysis/driver.dart'
+    show AnalysisDriver, AnalysisDriverScheduler, PerformanceLog;
+import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/bazel.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/pub_summary.dart';
 import 'package:analyzer/src/summary/summary_sdk.dart';
 import 'package:analyzer/src/task/options.dart';
 import 'package:args/args.dart';
@@ skipping 32 matching lines @@
    */
   final ResourceProvider resourceProvider;
 
   /**
    * The manager used to manage the DartSdk's that have been created so that
    * they can be shared across contexts.
    */
   final DartSdkManager sdkManager;
 
   /**
-   * The cache containing the contents of overlaid files.
+   * The cache containing the contents of overlaid files. If this builder will
+   * be used to build analysis drivers, set the [fileContentOverlay] instead.
    */
   final ContentCache contentCache;
 
   /**
    * The options used by the context builder.
    */
   final ContextBuilderOptions builderOptions;
 
   /**
    * The resolver provider used to create a package: URI resolver, or `null` if
    * the normal (Package Specification DEP) lookup mechanism is to be used.
    */
   ResolverProvider packageResolverProvider;
 
   /**
    * The resolver provider used to create a file: URI resolver, or `null` if
    * the normal file URI resolver is to be used.
    */
   ResolverProvider fileResolverProvider;
 
   /**
+   * The scheduler used by any analysis drivers created through this interface.
+   */
+  AnalysisDriverScheduler analysisDriverScheduler;
+
+  /**
+   * The performance log used by any analysis drivers created through this
+   * interface.
+   */
+  PerformanceLog performanceLog;
+
+  /**
+   * The byte store used by any analysis drivers created through this interface.
+   */
+  ByteStore byteStore;
+
+  /**
+   * The file content overlay used by analysis drivers. If this builder will be
+   * used to build analysis contexts, set the [contentCache] instead.
+   */
+  FileContentOverlay fileContentOverlay;
+
+  /**
    * Initialize a newly created builder to be ready to build a context rooted in
    * the directory with the given [rootDirectoryPath].
    */
   ContextBuilder(this.resourceProvider, this.sdkManager, this.contentCache,
       {ContextBuilderOptions options})
       : builderOptions = options ?? new ContextBuilderOptions();
 
   /**
    * Return an analysis context that is configured correctly to analyze code in
    * the directory with the given [path].
    *
    * *Note:* This method is not yet fully implemented and should not be used.
    */
   AnalysisContext buildContext(String path) {
     InternalAnalysisContext context =
         AnalysisEngine.instance.createAnalysisContext();
     AnalysisOptions options = getAnalysisOptions(path);
     context.contentCache = contentCache;
     context.sourceFactory = createSourceFactory(path, options);
     context.analysisOptions = options;
     context.name = path;
     //_processAnalysisOptions(context, optionMap);
     declareVariables(context);
     configureSummaries(context);
     return context;
   }
 
   /**
+   * Return an analysis driver that is configured correctly to analyze code in
+   * the directory with the given [path].
+   */
+  AnalysisDriver buildDriver(String path) {
+    AnalysisOptions options = getAnalysisOptions(path);
+    //_processAnalysisOptions(context, optionMap);
+    AnalysisDriver driver = new AnalysisDriver(
+        analysisDriverScheduler,
+        performanceLog,
+        resourceProvider,
+        byteStore,
+        fileContentOverlay,
+        path,
+        createSourceFactory(path, options),
+        options);
+    declareVariablesInDriver(driver);
+    return driver;
+  }
+
+  /**
    * Configure the context to make use of summaries.
    */
   void configureSummaries(InternalAnalysisContext context) {
     PubSummaryManager manager = builderOptions.pubSummaryManager;
     if (manager != null) {
       List<LinkedPubPackage> linkedBundles = manager.getLinkedBundles(context);
       if (linkedBundles.isNotEmpty) {
         SummaryDataStore store = new SummaryDataStore([]);
         for (LinkedPubPackage package in linkedBundles) {
           store.addBundle(null, package.unlinked);
@@ skipping 97 matching lines @@
     Map<String, String> variables = builderOptions.declaredVariables;
     if (variables != null && variables.isNotEmpty) {
       DeclaredVariables contextVariables = context.declaredVariables;
       variables.forEach((String variableName, String value) {
         contextVariables.define(variableName, value);
       });
     }
   }
 
   /**
+   * Add any [declaredVariables] to the list of declared variables used by the
+   * given analysis [driver].
+   */
+  void declareVariablesInDriver(AnalysisDriver driver) {
+    Map<String, String> variables = builderOptions.declaredVariables;
+    if (variables != null && variables.isNotEmpty) {
+      DeclaredVariables contextVariables = driver.declaredVariables;
+      variables.forEach((String variableName, String value) {
+        contextVariables.define(variableName, value);
+      });
+    }
+  }
+
+  /**
    * Finds a package resolution strategy for the directory at the given absolute
    * [path].
    *
    * This function first tries to locate a `.packages` file in the directory. If
    * that is not found, it instead checks for the presence of a `packages/`
    * directory in the same place. If that also fails, it starts checking parent
    * directories for a `.packages` file, and stops if it finds it. Otherwise it
    * gives up and returns [Packages.noPackages].
    */
   Packages findPackagesFromFile(String path) {
@@ skipping 385 matching lines @@
   String _readEmbedderYaml(Folder libDir) {
     File file = libDir.getChild(EMBEDDER_FILE_NAME);
     try {
       return file.readAsStringSync();
     } on FileSystemException {
       // File can't be read.
       return null;
     }
   }
 }