Pubspec-specified analysis configuration (#26359).

pkg/analysis_server/lib/src/context_manager.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 context.directory.manager;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:core' hide Resource;
 
 import 'package:analysis_server/src/analysis_server.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/instrumentation/instrumentation.dart';
 import 'package:analyzer/plugin/embedded_resolver_provider.dart';
 import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/plugin/resolver_provider.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
+import 'package:analyzer/source/config.dart';
 import 'package:analyzer/source/embedder.dart';
 import 'package:analyzer/source/package_map_provider.dart';
 import 'package:analyzer/source/package_map_resolver.dart';
 import 'package:analyzer/source/path_filter.dart';
 import 'package:analyzer/source/pub_package_map_provider.dart';
 import 'package:analyzer/source/sdk_ext.dart';
 import 'package:analyzer/src/context/context.dart' as context;
 import 'package:analyzer/src/context/source.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
@@ skipping 561 matching lines @@
       // Start with defaults.
       info.context.analysisOptions = new AnalysisOptionsImpl();
 
       // Apply inherited options.
       options = _toStringMap(_getEmbeddedOptions(info.context));
       if (options != null) {
         configureContextOptions(info.context, options);
       }
     } else {
       // Check for embedded options.
-      YamlMap embeddedOptions = _getEmbeddedOptions(info.context);
+      Map embeddedOptions = _getEmbeddedOptions(info.context);
       if (embeddedOptions != null) {
         options = _toStringMap(new Merger().merge(embeddedOptions, options));
       }
     }
 
     // Notify options processors.
     AnalysisEngine.instance.optionsPlugin.optionsProcessors
         .forEach((OptionsProcessor p) {
       try {
         p.optionsProcessed(info.context, options);
@@ skipping 454 matching lines @@
     Map<String, Object> optionMap = readOptions(info.folder);
     AnalysisOptions options =
         new AnalysisOptionsImpl.from(defaultContextOptions);
     applyToAnalysisOptions(options, optionMap);
 
     info.setDependencies(dependencies);
     info.context = callbacks.addContext(folder, options, disposition);
     folderMap[folder] = info.context;
     info.context.name = folder.path;
 
+    // Look for pubspec-specified analysis configuration.
+    File pubspec;
+    if (packagespecFile?.exists == true) {
+      if (packagespecFile.shortName == PUBSPEC_NAME) {
+        pubspec = packagespecFile;
+      }
+    }
+    if (pubspec == null) {
+      Resource child = folder.getChild(PUBSPEC_NAME);
+      if (child.exists && child is File) {
+        pubspec = child;
+      }
+    }
+    if (pubspec != null) {
+      File pubSource = resourceProvider.getFile(pubspec.path);
+      setConfiguration(
+          info.context,
+          new AnalysisConfiguration.fromPubspec(
+              pubSource, resourceProvider, disposition.packages));
+    }
+
     processOptionsForContext(info, optionMap);
 
     return info;
   }
 
   /**
    * Potentially create a new context associated with the given [folder].
    *
    * If there are subfolders with 'pubspec.yaml' files, separate contexts are
    * created for them and excluded from the context associated with the
@@ skipping 143 matching lines @@
     // Start by looking for .packages.
     packageSpec = folder.getChild(PACKAGE_SPEC_NAME);
 
     // Fall back to looking for a pubspec.
     if (packageSpec == null || !packageSpec.exists) {
       packageSpec = folder.getChild(PUBSPEC_NAME);
     }
     return packageSpec;
   }
 
-  /// Get analysis options associated with an `_embedder.yaml`. If there is
-  /// more than one `_embedder.yaml` associated with the given context, `null`
-  /// is returned.
-  YamlMap _getEmbeddedOptions(AnalysisContext context) {
-    if (context is InternalAnalysisContext) {
-      EmbedderYamlLocator locator = context.embedderYamlLocator;
-      Iterable<YamlMap> maps = locator.embedderYamls.values;
-      if (maps.length == 1) {
-        return maps.first;
+  /// Get analysis options inherited from an `_embedder.yaml` (deprecated)
+  /// and/or a package specified configuration.  If more than one
+  /// `_embedder.yaml` is associated with the given context, the embedder is
+  /// skipped.
+  ///
+  /// Returns null if there are no embedded/configured options.
+  Map _getEmbeddedOptions(AnalysisContext context) {
+    if (context is! InternalAnalysisContext) {

[Brian Wilkerson, 2016/04/28 18:05:59]

While I appreciate the fact that this style removed a level of nesting, making
the code easier to read, it requires an implicit or explicit cast, which is
expensive (and the introduction of another local variable, but that's minor).
I've been removing as many casts as possible, so it would be great if we didn't
add more back in.

[pquitslund, 2016/04/28 18:13:42]

Done.

+      return null;
+    }
+
+    InternalAnalysisContext internalContext = context;
+
+    Map embeddedOptions;
+    EmbedderYamlLocator locator = internalContext.embedderYamlLocator;
+    Iterable<YamlMap> maps = locator.embedderYamls.values;
+    if (maps.length == 1) {
+      embeddedOptions = maps.first;
+    }
+
+    AnalysisConfiguration configuration = getConfiguration(context);
+    if (configuration != null) {
+      Map configMap = configuration.options;
+      if (configMap != null) {
+        if (embeddedOptions != null) {
+          embeddedOptions = new Merger().merge(embeddedOptions, configMap);
+        } else {
+          embeddedOptions = configMap;
+        }
       }
     }
-    return null;
+
+    return embeddedOptions;
   }
 
   /**
    * Return the [ContextInfo] for the "innermost" context whose associated
    * folder is or contains the given path.  ("innermost" refers to the nesting
    * of contexts, so if there is a context for path /foo and a context for
    * path /foo/bar, then the innermost context containing /foo/bar/baz.dart is
    * the context for /foo/bar.)
    *
    * If no context contains the given path, `null` is returned.
@@ skipping 534 matching lines @@
       ResourceProvider resourceProvider) {
     if (packages != null) {
       // Construct package map for the SdkExtUriResolver.
       Map<String, List<Folder>> packageMap = buildPackageMap(resourceProvider);
       return <UriResolver>[new SdkExtUriResolver(packageMap)];
     } else {
       return const <UriResolver>[];
     }
   }
 }