Split out options from 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';
@@ skipping 51 matching lines @@
    * they can be shared across contexts.
    */
   final DartSdkManager sdkManager;
 
   /**
    * The cache containing the contents of overlaid files.
    */
   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.
    */
   @deprecated
   ResolverProvider packageResolverProvider;
 
   /**
    * The resolver provider used to create a file: URI resolver, or `null` if
    * the normal file URI resolver is to be used.
    */
   @deprecated
   ResolverProvider fileResolverProvider;
 
   /**
-   * The file path of the .packages file that should be used in place of any
-   * file found using the normal (Package Specification DEP) lookup mechanism,
-   * or `null` if the normal lookup mechanism should be used.
-   */
-  String defaultPackageFilePath;
-
-  /**
-   * The file path of the packages directory that should be used in place of any
-   * file found using the normal (Package Specification DEP) lookup mechanism,
-   * or `null` if the normal lookup mechanism should be used.
-   */
-  String defaultPackagesDirectoryPath;
-
-  /**
-   * The file path of the file containing the summary of the SDK that should be
-   * used to "analyze" the SDK. This option should only be specified by
-   * command-line tools such as 'dartanalyzer' or 'ddc'.
-   */
-  String dartSdkSummaryPath;
-
-  /**
-   * The file path of the analysis options file that should be used in place of
-   * any file in the root directory or a parent of the root directory, or `null`
-   * if the normal lookup mechanism should be used.
-   */
-  String defaultAnalysisOptionsFilePath;
-
-  /**
-   * The default analysis options that should be used unless some or all of them
-   * are overridden in the analysis options file, or `null` if the default
-   * defaults should be used.
-   */
-  AnalysisOptions defaultOptions;
-
-  /**
-   * A table mapping variable names to values for the declared variables, or
-   * `null` if no additional variables should be declared.
-   */
-  Map<String, String> declaredVariables;
-
-  /**
-   * The manager of pub package summaries.
-   */
-  PubSummaryManager pubSummaryManager;
-
-  /**
    * 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);
+  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(context, path);
     context.contentCache = contentCache;
     context.sourceFactory = createSourceFactory(path, options);
     context.analysisOptions = options;
     context.name = path;
     //_processAnalysisOptions(context, optionMap);
     declareVariables(context);
     configureSummaries(context);
     return context;
   }
 
   /**
    * Configure the context to make use of summaries.
    */
   void configureSummaries(InternalAnalysisContext context) {
-    if (pubSummaryManager != null) {
-      List<LinkedPubPackage> linkedBundles =
-          pubSummaryManager.getLinkedBundles(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);
           store.addBundle(null, package.linked);
         }
         context.resultProvider =
             new InputPackagesResultProvider(context, store);
       }
     }
@@ skipping 30 matching lines @@
 //      }
 //    } on Exception catch (e) {
 //      optionsProcessors.forEach((OptionsProcessor p) => p.onError(e));
 //    }
 //  }
 
   /**
    * Return an analysis options object containing the default option values.
    */
   AnalysisOptions createDefaultOptions() {
+    AnalysisOptions defaultOptions = builderOptions.defaultOptions;
     if (defaultOptions == null) {
       return new AnalysisOptionsImpl();
     }
     return new AnalysisOptionsImpl.from(defaultOptions);
   }
 
   Packages createPackageMap(String rootDirectoryPath) {
-    if (defaultPackageFilePath != null) {
-      File configFile = resourceProvider.getFile(defaultPackageFilePath);
+    String filePath = builderOptions.defaultPackageFilePath;
+    if (filePath != null) {
+      File configFile = resourceProvider.getFile(filePath);
       List<int> bytes = configFile.readAsBytesSync();
       Map<String, Uri> map = parse(bytes, configFile.toUri());
       resolveSymbolicLinks(map);
       return new MapPackages(map);
-    } else if (defaultPackagesDirectoryPath != null) {
-      Folder folder = resourceProvider.getFolder(defaultPackagesDirectoryPath);
+    }
+    String directoryPath = builderOptions.defaultPackagesDirectoryPath;
+    if (directoryPath != null) {
+      Folder folder = resourceProvider.getFolder(directoryPath);
       return getPackagesFromFolder(folder);
     }
     return findPackagesFromFile(rootDirectoryPath);
   }
 
   SourceFactory createSourceFactory(String rootPath, AnalysisOptions options) {
     BazelWorkspace bazelWorkspace =
         BazelWorkspace.find(resourceProvider, rootPath);
     if (bazelWorkspace != null) {
       List<UriResolver> resolvers = <UriResolver>[
@@ skipping 12 matching lines @@
       new ResourceUriResolver(resourceProvider)
     ];
     return new SourceFactory(resolvers, packages, resourceProvider);
   }
 
   /**
    * Add any [declaredVariables] to the list of declared variables used by the
    * given [context].
    */
   void declareVariables(InternalAnalysisContext context) {
-    if (declaredVariables != null && declaredVariables.isNotEmpty) {
+    Map<String, String> variables = builderOptions.declaredVariables;
+    if (variables != null && variables.isNotEmpty) {
       DeclaredVariables contextVariables = context.declaredVariables;
-      declaredVariables.forEach((String variableName, String value) {
+      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
@@ skipping 11 matching lines @@
       resolveSymbolicLinks(map);
       return new MapPackages(map);
     } else if (location is Folder) {
       return getPackagesFromFolder(location);
     }
     return Packages.noPackages;
   }
 
   /**
    * Return the SDK that should be used to analyze code. Use the given
-   * [packageMap] and [options] to locate the SDK.
+   * [packageMap] and [analysisOptions] to locate the SDK.
    */
   DartSdk findSdk(
-      Map<String, List<Folder>> packageMap, AnalysisOptions options) {
-    if (dartSdkSummaryPath != null) {
-      return new SummaryBasedDartSdk(dartSdkSummaryPath, options.strongMode);
+      Map<String, List<Folder>> packageMap, AnalysisOptions analysisOptions) {
+    String summaryPath = builderOptions.dartSdkSummaryPath;
+    if (summaryPath != null) {
+      return new SummaryBasedDartSdk(summaryPath, analysisOptions.strongMode);
     } else if (packageMap != null) {
       SdkExtensionFinder extFinder = new SdkExtensionFinder(packageMap);
       List<String> extFilePaths = extFinder.extensionFilePaths;
       EmbedderYamlLocator locator = new EmbedderYamlLocator(packageMap);
       Map<Folder, YamlMap> embedderYamls = locator.embedderYamls;
       EmbedderSdk embedderSdk =
           new EmbedderSdk(resourceProvider, embedderYamls);
       if (embedderSdk.sdkLibraries.length > 0) {
         //
         // There is an embedder file that defines the content of the SDK and
         // there might be an extension file that extends it.
         //
         List<String> paths = <String>[];
         for (Folder folder in embedderYamls.keys) {
           paths.add(folder
               .getChildAssumingFile(EmbedderYamlLocator.EMBEDDER_FILE_NAME)
               .path);
         }
         paths.addAll(extFilePaths);
-        SdkDescription description = new SdkDescription(paths, options);
+        SdkDescription description = new SdkDescription(paths, analysisOptions);
         DartSdk dartSdk = sdkManager.getSdk(description, () {
           if (extFilePaths.isNotEmpty) {
             embedderSdk.addExtensions(extFinder.urlMappings);
           }
-          embedderSdk.analysisOptions = options;
+          embedderSdk.analysisOptions = analysisOptions;
           embedderSdk.useSummary = sdkManager.canUseSummaries;
           return embedderSdk;
         });
         return dartSdk;
       } else if (extFilePaths != null && extFilePaths.isNotEmpty) {
         //
         // We have an extension file, but no embedder file.
         //
         String sdkPath = sdkManager.defaultSdkDirectory;
         List<String> paths = <String>[sdkPath];
         paths.addAll(extFilePaths);
-        SdkDescription description = new SdkDescription(paths, options);
+        SdkDescription description = new SdkDescription(paths, analysisOptions);
         return sdkManager.getSdk(description, () {
           FolderBasedDartSdk sdk = new FolderBasedDartSdk(
               resourceProvider, resourceProvider.getFolder(sdkPath));
           if (extFilePaths.isNotEmpty) {
             sdk.addExtensions(extFinder.urlMappings);
           }
-          sdk.analysisOptions = options;
+          sdk.analysisOptions = analysisOptions;
           sdk.useSummary = sdkManager.canUseSummaries;
           return sdk;
         });
       }
     }
     String sdkPath = sdkManager.defaultSdkDirectory;
-    SdkDescription description = new SdkDescription(<String>[sdkPath], options);
+    SdkDescription description =
+        new SdkDescription(<String>[sdkPath], analysisOptions);
     return sdkManager.getSdk(description, () {
       FolderBasedDartSdk sdk = new FolderBasedDartSdk(resourceProvider,
-          resourceProvider.getFolder(sdkPath), options.strongMode);
-      sdk.analysisOptions = options;
+          resourceProvider.getFolder(sdkPath), analysisOptions.strongMode);
+      sdk.analysisOptions = analysisOptions;
       sdk.useSummary = sdkManager.canUseSummaries;
       return sdk;
     });
   }
 
   /**
    * Return the analysis options that should be used when the given [context] is
    * used to analyze code in the directory with the given [path].
    */
   AnalysisOptions getAnalysisOptions(AnalysisContext context, String path) {
@@ skipping 13 matching lines @@
       }
     }
     return options;
   }
 
   /**
    * Return the analysis options file that should be used when analyzing code in
    * the directory with the given [path].
    */
   File getOptionsFile(String path) {
-    if (defaultAnalysisOptionsFilePath != null) {
-      return resourceProvider.getFile(defaultAnalysisOptionsFilePath);
+    String filePath = builderOptions.defaultAnalysisOptionsFilePath;
+    if (filePath != null) {
+      return resourceProvider.getFile(filePath);
     }
     Folder root = resourceProvider.getFolder(path);
     for (Folder folder = root; folder != null; folder = folder.parent) {
       File file =
           folder.getChildAssumingFile(AnalysisEngine.ANALYSIS_OPTIONS_FILE);
       if (file.exists) {
         return file;
       }
       file = folder
           .getChildAssumingFile(AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
@@ skipping 96 matching lines @@
       if (packagesCfgFile != null) {
         return packagesCfgFile;
       }
       parentDir = parentDir.parent;
     }
     return null;
   }
 }
 
 /**
+ * Options used by a [ContextBuilder].
+ */
+class ContextBuilderOptions {
+  /**
+   * The file path of the file containing the summary of the SDK that should be
+   * used to "analyze" the SDK. This option should only be specified by
+   * command-line tools such as 'dartanalyzer' or 'ddc'.
+   */
+  String dartSdkSummaryPath;
+
+  /**
+   * The file path of the analysis options file that should be used in place of
+   * any file in the root directory or a parent of the root directory, or `null`
+   * if the normal lookup mechanism should be used.
+   */
+  String defaultAnalysisOptionsFilePath;
+
+  /**
+   * A table mapping variable names to values for the declared variables, or
+   * `null` if no additional variables should be declared.
+   */
+  Map<String, String> declaredVariables;
+
+  /**
+   * The default analysis options that should be used unless some or all of them
+   * are overridden in the analysis options file, or `null` if the default
+   * defaults should be used.
+   */
+  AnalysisOptions defaultOptions;
+
+  /**
+   * The file path of the .packages file that should be used in place of any
+   * file found using the normal (Package Specification DEP) lookup mechanism,
+   * or `null` if the normal lookup mechanism should be used.
+   */
+  String defaultPackageFilePath;
+
+  /**
+   * The file path of the packages directory that should be used in place of any
+   * file found using the normal (Package Specification DEP) lookup mechanism,
+   * or `null` if the normal lookup mechanism should be used.
+   */
+  String defaultPackagesDirectoryPath;
+
+  /**
+   * The manager of pub package summaries.
+   */
+  PubSummaryManager pubSummaryManager;
+
+  /**
+   * Initialize a newly created set of options
+   */
+  ContextBuilderOptions();
+}
+
+/**
  * Given a package map, check in each package's lib directory for the existence
  * of an `_embedder.yaml` file. If the file contains a top level YamlMap, it
  * will be added to the [embedderYamls] map.
  */
 class EmbedderYamlLocator {
   /**
    * The name of the embedder files being searched for.
    */
   static const String EMBEDDER_FILE_NAME = '_embedder.yaml';
 
@@ skipping 73 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;
     }
   }
 }