rework analyzer_cli to use ContextBuilder getAnalysisOptions

pkg/analyzer_cli/lib/src/driver.dart

 // Copyright (c) 2015, 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_cli.src.driver;
 
 import 'dart:async';
 import 'dart:convert';
 import 'dart:io' as io;
 
@@ skipping 543 matching lines @@
 
     if (!useSummaries && options.buildSummaryInputs.isNotEmpty) {
       throw new _DriverError(
           'Summaries are not yet supported when using Flutter.');
     }
 
     // Read any input summaries.
     SummaryDataStore summaryDataStore = new SummaryDataStore(
         useSummaries ? options.buildSummaryInputs : <String>[]);
 
-    // Create a temporary source factory without an SDK resolver
-    // for resolving "include:" directives in analysis options files.
-    SourceFactory tempSourceFactory = _chooseUriResolutionPolicy(
-        options, embedderMap, packageInfo, summaryDataStore, false, null);
-
     AnalysisOptionsImpl analysisOptions =
-        createAnalysisOptions(resourceProvider, tempSourceFactory, options);
+        createAnalysisOptionsForCommandLineOptions(resourceProvider, options);
     analysisOptions.analyzeFunctionBodiesPredicate =
         _chooseDietParsingPolicy(options);
 
     // Once options and embedders are processed, setup the SDK.
     _setupSdk(options, useSummaries, analysisOptions);
 
     PackageBundle sdkBundle = sdk.getLinkedBundle();
     if (sdkBundle != null) {
       summaryDataStore.addBundle(null, sdkBundle);
     }
@@ skipping 152 matching lines @@
               sourcePath = path.absolute(sourcePath);
               sourcePath = path.normalize(sourcePath);
               return !path.isWithin(dartSdkPath, sourcePath);
             });
         dartSdk.analysisOptions = analysisOptions;
         sdk = dartSdk;
       }
     }
   }
 
-  static AnalysisOptionsImpl createAnalysisOptions(
-      file_system.ResourceProvider resourceProvider,
-      SourceFactory sourceFactory,
-      CommandLineOptions options) {
-    // Prepare context options.
-    AnalysisOptionsImpl analysisOptions =
-        createAnalysisOptionsForCommandLineOptions(options);
+  static AnalysisOptionsImpl createAnalysisOptionsForCommandLineOptions(
+      ResourceProvider resourceProvider, CommandLineOptions options) {
+    if (options.analysisOptionsFile != null) {
+      file_system.File file =
+          resourceProvider.getFile(options.analysisOptionsFile);
+      if (!file.exists) {
+        printAndFail('Options file not found: ${options.analysisOptionsFile}',
+            exitCode: ErrorSeverity.ERROR.ordinal);
+      }
+    }
 
-    // Process analysis options file (and notify all interested parties).
-    _processAnalysisOptions(
-        resourceProvider, sourceFactory, analysisOptions, options);
-    return analysisOptions;
-  }
+    AnalysisOptionsImpl contextOptions = new ContextBuilder(
+            resourceProvider, null, null,
+            options: options.contextBuilderOptions)

[Brian Wilkerson, 2017/02/23 21:29:23]

Might be good to create a ContextBuilder in one place and make it available
everywhere (such as a field) to make it easier to replace more code with calls
to ContextBuilder. (Maybe as a follow-on CL.)

[danrubel, 2017/02/23 21:51:20]

Good point. I'll do that when we start using ContextBuilder to build the context
as well as get the analysis options.

+        .getAnalysisOptions(options.sourceFiles.isNotEmpty
+            ? options.sourceFiles[0]
+            : path.current);
 
-  static AnalysisOptionsImpl createAnalysisOptionsForCommandLineOptions(
-      CommandLineOptions options) {
-    AnalysisOptionsImpl contextOptions = new AnalysisOptionsImpl();
     contextOptions.trackCacheDependencies = false;
     contextOptions.disableCacheFlushing = options.disableCacheFlushing;
     contextOptions.hint = !options.disableHints;
-    contextOptions.enableStrictCallChecks = options.enableStrictCallChecks;
-    contextOptions.enableSuperMixins = options.enableSuperMixins;
     contextOptions.generateImplicitErrors = options.showPackageWarnings;
     contextOptions.generateSdkErrors = options.showSdkWarnings;
-    contextOptions.lint = options.lints;
-    contextOptions.strongMode = options.strongMode;
-    contextOptions.implicitCasts = options.implicitCasts;
-    contextOptions.implicitDynamic = options.implicitDynamic;
+
+    // The following options are updated as appropriate by the
+    // ContextBuilder getAnalysisOptions(...)
+    //contextOptions.enableStrictCallChecks = options.enableStrictCallChecks;
+    //contextOptions.enableSuperMixins = options.enableSuperMixins;
+    //contextOptions.strongMode = options.strongMode;
+    //contextOptions.implicitCasts = options.implicitCasts;
+    //contextOptions.implicitDynamic = options.implicitDynamic;

[Brian Wilkerson, 2017/02/23 21:29:22]

Did you intend to remove these?

[danrubel, 2017/02/23 21:51:20]

Yeah. Forgot to do so. Now removed.

+
     return contextOptions;
   }
 
   static void setAnalysisContextOptions(
       file_system.ResourceProvider resourceProvider,
-      SourceFactory sourceFactory,
       AnalysisContext context,
       CommandLineOptions options,
       void configureContextOptions(AnalysisOptionsImpl contextOptions)) {
     AnalysisOptionsImpl analysisOptions =
-        createAnalysisOptions(resourceProvider, sourceFactory, options);
+        createAnalysisOptionsForCommandLineOptions(resourceProvider, options);
     configureContextOptions(analysisOptions);
     setupAnalysisContext(context, options, analysisOptions);
   }
 
   static void setupAnalysisContext(AnalysisContext context,
       CommandLineOptions options, AnalysisOptionsImpl analysisOptions) {
     Map<String, String> definedVariables = options.definedVariables;
     if (definedVariables.isNotEmpty) {
       DeclaredVariables declaredVariables = context.declaredVariables;
       definedVariables.forEach((String variableName, String value) {
@@ skipping 28 matching lines @@
       return false;
     }
     for (String key in m1.keys) {
       if (!m2.containsKey(key) || m1[key] != m2[key]) {
         return false;
       }
     }
     return true;
   }
 
-  static file_system.File _getOptionsFile(
-      file_system.ResourceProvider resourceProvider,
-      CommandLineOptions options) {
-    file_system.File file;
-    String filePath = options.analysisOptionsFile;
-    if (filePath != null) {
-      file = resourceProvider.getFile(filePath);
-      if (!file.exists) {
-        printAndFail('Options file not found: $filePath',
-            exitCode: ErrorSeverity.ERROR.ordinal);
-      }
-    } else {
-      filePath = AnalysisEngine.ANALYSIS_OPTIONS_FILE;
-      file = resourceProvider.getFile(filePath);
-      if (!file.exists) {
-        filePath = AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE;
-        file = resourceProvider.getFile(filePath);
-      }
-    }
-    return file;
-  }
-
   /// Convert [sourcePath] into an absolute path.
   static String _normalizeSourcePath(String sourcePath) =>
       path.normalize(new io.File(sourcePath).absolute.path);
-
-  static void _processAnalysisOptions(
-      file_system.ResourceProvider resourceProvider,
-      SourceFactory sourceFactory,
-      AnalysisOptionsImpl analysisOptions,
-      CommandLineOptions options) {
-    file_system.File file = _getOptionsFile(resourceProvider, options);
-
-    AnalysisOptionsProvider analysisOptionsProvider =
-        new AnalysisOptionsProvider(sourceFactory);
-    Map<String, YamlNode> optionMap =
-        analysisOptionsProvider.getOptionsFromFile(file);
-
-    // Fill in lint rule defaults in case lints are enabled and rules are
-    // not specified in an options file.
-    if (options.lints && !containsLintRuleEntry(optionMap)) {
-      analysisOptions.lintRules = Registry.ruleRegistry.defaultRules;
-    }
-
-    // Ask engine to further process options.
-    if (optionMap != null) {
-      applyToAnalysisOptions(analysisOptions, optionMap);
-    }
-  }
 }
 
 /// Provides a framework to read command line options from stdin and feed them
 /// to a callback.
 class _BatchRunner {
   /// Run the tool in 'batch' mode, receiving command lines through stdin and
   /// returning pass/fail status through stdout. This feature is intended for
   /// use in unit testing.
   static void runAsBatch(List<String> sharedArgs, _BatchRunnerHandler handler) {
     outSink.writeln('>>> BATCH START');
@@ skipping 73 matching lines @@
     for (var package in packages) {
       var packageName = path.basename(package.path);
       var realPath = package.resolveSymbolicLinksSync();
       result[packageName] = [
         PhysicalResourceProvider.INSTANCE.getFolder(realPath)
       ];
     }
     return result;
   }
 }