fix dartanalyzer sdk setup

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 15 matching lines @@
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/interner.dart';
 import 'package:analyzer/src/generated/java_engine.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'
     show PerformanceTag;
 import 'package:analyzer/src/lint/registry.dart';
-import 'package:analyzer/src/services/lint.dart';
 import 'package:analyzer/src/source/source_resource.dart';
 import 'package:analyzer/src/summary/idl.dart';
 import 'package:analyzer/src/summary/package_bundle_reader.dart';
 import 'package:analyzer/src/summary/summary_sdk.dart' show SummaryBasedDartSdk;
 import 'package:analyzer/src/task/options.dart';
 import 'package:analyzer_cli/src/analyzer_impl.dart';
 import 'package:analyzer_cli/src/build_mode.dart';
 import 'package:analyzer_cli/src/error_formatter.dart';
 import 'package:analyzer_cli/src/options.dart';
 import 'package:analyzer_cli/src/perf_report.dart';
@@ skipping 314 matching lines @@
     };
   }
 
   /// Decide on the appropriate method for resolving URIs based on the given
   /// [options] and [customUrlMappings] settings, and return a
   /// [SourceFactory] that has been configured accordingly.
   SourceFactory _chooseUriResolutionPolicy(
       CommandLineOptions options,
       Map<file_system.Folder, YamlMap> embedderMap,
       _PackageInfo packageInfo,
-      SummaryDataStore summaryDataStore) {
+      SummaryDataStore summaryDataStore,
+      bool includeSdkResolver,
+      AnalysisOptions analysisOptions) {

[Brian Wilkerson, 2017/02/04 16:58:38]

We should document that analysisOptions can / will be null when
includeSdkResolver is false.

[danrubel, 2017/02/04 17:08:34]

Good point. Done.

     // Create a custom package resolver if one has been specified.
     if (packageResolverProvider != null) {
       file_system.Folder folder = resourceProvider.getResource('.');
       UriResolver resolver = packageResolverProvider(folder);
       if (resolver != null) {
-        UriResolver sdkResolver = new DartUriResolver(sdk);
-
         // TODO(brianwilkerson) This doesn't handle sdk extensions.
-        List<UriResolver> resolvers = <UriResolver>[
-          sdkResolver,
-          new InSummaryUriResolver(resourceProvider, summaryDataStore),
-          resolver,
-          new file_system.ResourceUriResolver(resourceProvider)
-        ];
+        List<UriResolver> resolvers = <UriResolver>[];
+        if (includeSdkResolver) {
+          resolvers.add(new DartUriResolver(sdk));
+        }
+        resolvers
+            .add(new InSummaryUriResolver(resourceProvider, summaryDataStore));
+        resolvers.add(resolver);
+        resolvers.add(new file_system.ResourceUriResolver(resourceProvider));
         return new SourceFactory(resolvers);
       }
     }
 
     UriResolver packageUriResolver;
 
     if (options.packageRootPath != null) {
       ContextBuilderOptions builderOptions = new ContextBuilderOptions();
       builderOptions.defaultPackagesDirectoryPath = options.packageRootPath;
       ContextBuilder builder = new ContextBuilder(resourceProvider, null, null,
@@ skipping 21 matching lines @@
         }
       }
     }
 
     // Now, build our resolver list.
     List<UriResolver> resolvers = [];
 
     // 'dart:' URIs come first.
 
     // Setup embedding.
-    EmbedderSdk embedderSdk = new EmbedderSdk(resourceProvider, embedderMap);
-    if (embedderSdk.libraryMap.size() == 0) {
-      // The embedder uri resolver has no mappings. Use the default Dart SDK
-      // uri resolver.
-      resolvers.add(new DartUriResolver(sdk));
-    } else {
-      // The embedder uri resolver has mappings, use it instead of the default
-      // Dart SDK uri resolver.
-      embedderSdk.analysisOptions = _context.analysisOptions;
-      resolvers.add(new DartUriResolver(embedderSdk));
+    if (includeSdkResolver) {
+      EmbedderSdk embedderSdk = new EmbedderSdk(resourceProvider, embedderMap);
+      if (embedderSdk.libraryMap.size() == 0) {
+        // The embedder uri resolver has no mappings. Use the default Dart SDK
+        // uri resolver.
+        resolvers.add(new DartUriResolver(sdk));
+      } else {
+        // The embedder uri resolver has mappings, use it instead of the default
+        // Dart SDK uri resolver.
+        embedderSdk.analysisOptions = analysisOptions;
+        resolvers.add(new DartUriResolver(embedderSdk));
+      }
     }
 
     // Next SdkExts.
     if (packageInfo.packageMap != null) {
       resolvers.add(new SdkExtUriResolver(packageInfo.packageMap));
     }
 
     // Then package URIs from summaries.
     resolvers.add(new InSummaryUriResolver(resourceProvider, summaryDataStore));
 
@@ skipping 55 matching lines @@
     if (_canContextBeReused(options)) {
       return;
     }
     _previousOptions = options;
 
     // Save stats from previous context before clobbering it.
     if (_context != null) {
       _analyzedFileCount += _context.sources.length;
     }
 
-    // Create a context.
-    _context = AnalysisEngine.instance.createAnalysisContext();
-
     // Find package info.
     _PackageInfo packageInfo = _findPackages(options);
 
     // Process embedders.
     Map<file_system.Folder, YamlMap> embedderMap =
         new EmbedderYamlLocator(packageInfo.packageMap).embedderYamls;
 
     // Scan for SDK extenders.
     bool hasSdkExt = _hasSdkExt(packageInfo.packageMap?.values);
 
     // No summaries in the presence of embedders or extenders.
     bool useSummaries = embedderMap.isEmpty && !hasSdkExt;
 
     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);
+    analysisOptions.analyzeFunctionBodiesPredicate =
+        _chooseDietParsingPolicy(options);
+
     // Once options and embedders are processed, setup the SDK.
-    _setupSdk(options, useSummaries);
+    _setupSdk(options, useSummaries, analysisOptions);
 
     PackageBundle sdkBundle = sdk.getLinkedBundle();
     if (sdkBundle != null) {
       summaryDataStore.addBundle(null, sdkBundle);
     }
 
     // Choose a package resolution policy and a diet parsing policy based on
     // the command-line options.
-    SourceFactory sourceFactory = _chooseUriResolutionPolicy(
-        options, embedderMap, packageInfo, summaryDataStore);
+    SourceFactory sourceFactory = _chooseUriResolutionPolicy(options,
+        embedderMap, packageInfo, summaryDataStore, true, analysisOptions);
 
-    AnalyzeFunctionBodiesPredicate dietParsingPolicy =
-        _chooseDietParsingPolicy(options);
-    setAnalysisContextOptions(
-        resourceProvider, sourceFactory, _context, options,
-        (AnalysisOptionsImpl contextOptions) {
-      contextOptions.analyzeFunctionBodiesPredicate = dietParsingPolicy;
-    });
-
+    // Create a context.
+    _context = AnalysisEngine.instance.createAnalysisContext();
+    setupAnalysisContext(_context, options, analysisOptions);
     _context.sourceFactory = sourceFactory;
 
     if (options.enableNewAnalysisDriver) {
       PerformanceLog log = new PerformanceLog(null);
       AnalysisDriverScheduler scheduler = new AnalysisDriverScheduler(log);
       analysisDriver = new AnalysisDriver(
           scheduler,
           log,
           resourceProvider,
           analysisDriverByteStore,
@@ skipping 111 matching lines @@
     ErrorSeverity errorSeverity = await analyzer.analyze();
     if (errorSeverity == ErrorSeverity.ERROR) {
       io.exitCode = errorSeverity.ordinal;
     }
     if (options.warningsAreFatal && errorSeverity == ErrorSeverity.WARNING) {
       io.exitCode = errorSeverity.ordinal;
     }
     return errorSeverity;
   }
 
-  void _setupSdk(CommandLineOptions options, bool useSummaries) {
+  void _setupSdk(CommandLineOptions options, bool useSummaries,
+      AnalysisOptions analysisOptions) {
     if (sdk == null) {
       if (options.dartSdkSummaryPath != null) {
         sdk = new SummaryBasedDartSdk(
             options.dartSdkSummaryPath, options.strongMode);
       } else {
         String dartSdkPath = options.dartSdkPath;
         FolderBasedDartSdk dartSdk = new FolderBasedDartSdk(resourceProvider,
             resourceProvider.getFolder(dartSdkPath), options.strongMode);
         dartSdk.useSummary = useSummaries &&
             options.sourceFiles.every((String sourcePath) {
               sourcePath = path.absolute(sourcePath);
               sourcePath = path.normalize(sourcePath);
               return !path.isWithin(dartSdkPath, sourcePath);
             });
-
-        dartSdk.analysisOptions = context.analysisOptions;
+        dartSdk.analysisOptions = analysisOptions;
         sdk = dartSdk;
       }
     }
   }
 
   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;
     return contextOptions;
   }
 
+  static AnalysisOptionsImpl createAnalysisOptions(
+      file_system.ResourceProvider resourceProvider,
+      SourceFactory sourceFactory,
+      CommandLineOptions options) {
+    // Prepare context options.
+    AnalysisOptionsImpl analysisOptions =
+        createAnalysisOptionsForCommandLineOptions(options);
+
+    // Process analysis options file (and notify all interested parties).
+    _processAnalysisOptions(
+        resourceProvider, sourceFactory, analysisOptions, options);
+    return analysisOptions;
+  }
+
   static void setAnalysisContextOptions(
       file_system.ResourceProvider resourceProvider,
       SourceFactory sourceFactory,
       AnalysisContext context,
       CommandLineOptions options,
       void configureContextOptions(AnalysisOptionsImpl contextOptions)) {
+    AnalysisOptionsImpl analysisOptions =
+        createAnalysisOptions(resourceProvider, sourceFactory, 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) {
         declaredVariables.define(variableName, value);
       });
     }
 
     if (options.log) {
       AnalysisEngine.instance.logger = new StdLogger();
     }
 
-    // Prepare context options.
-    AnalysisOptionsImpl contextOptions =
-        createAnalysisOptionsForCommandLineOptions(options);
-    configureContextOptions(contextOptions);
-
     // Set context options.
-    context.analysisOptions = contextOptions;
-
-    // Process analysis options file (and notify all interested parties).
-    _processAnalysisOptions(resourceProvider, sourceFactory, context, options);
+    context.analysisOptions = analysisOptions;
   }
 
   /// Perform a deep comparison of two string lists.
   static bool _equalLists(List<String> l1, List<String> l2) {
     if (l1.length != l2.length) {
       return false;
     }
     for (int i = 0; i < l1.length; i++) {
       if (l1[i] != l2[i]) {
         return false;
@@ skipping 37 matching lines @@
     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,
-      AnalysisContext context,
+      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)) {
-      setLints(context, Registry.ruleRegistry.defaultRules);
+      analysisOptions.lintRules = Registry.ruleRegistry.defaultRules;
     }
 
     // Ask engine to further process options.
     if (optionMap != null) {
-      applyToAnalysisOptions(context.analysisOptions, optionMap);
+      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.
@@ skipping 75 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;
   }
 }