Embedded option processing fixes (#25115).

pkg/analyzer/lib/src/task/options.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.src.task.options;
 
 import 'dart:collection';
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/plugin/options.dart';
@@ skipping 12 matching lines @@
 /// The errors produced while parsing `.analysis_options` files.
 ///
 /// The list will be empty if there were no errors, but will not be `null`.
 final ListResultDescriptor<AnalysisError> ANALYSIS_OPTIONS_ERRORS =
     new ListResultDescriptor<AnalysisError>(
         'ANALYSIS_OPTIONS_ERRORS', AnalysisError.NO_ERRORS);
 
 final _OptionsProcessor _processor = new _OptionsProcessor();
 
 /// Configure this [context] based on configuration details specified in
-/// the given [options].
+/// the given [options].  If [options] is `null`, default values are applied.
 void configureContextOptions(
-        AnalysisContext context, Map<String, YamlNode> options) =>
+        AnalysisContext context, Map<String, Object> options) =>
     _processor.configure(context, options);
 
 /// `analyzer` analysis options constants.
 class AnalyzerOptions {
   static const String analyzer = 'analyzer';
   static const String enableGenericMethods = 'enableGenericMethods';
   static const String enableSuperMixins = 'enableSuperMixins';
   static const String errors = 'errors';
   static const String exclude = 'exclude';
   static const String language = 'language';
@@ skipping 331 matching lines @@
 
 /// An error-builder that knows about `true` and `false` legal values.
 class TrueOrFalseValueErrorBuilder extends ErrorBuilder {
   TrueOrFalseValueErrorBuilder() : super(AnalyzerOptions.trueOrFalse);
   @override
   AnalysisOptionsWarningCode get pluralProposalCode =>
       AnalysisOptionsWarningCode.UNSUPPORTED_VALUE;
 }
 
 class _OptionsProcessor {
-  void configure(AnalysisContext context, Map<String, YamlNode> options) {
+  static final Map<String, Object> defaults = {'analyzer': {}};
+
+  /// Configure [context] based on the given [options] (which can be `null`
+  /// to restore [defaults]).
+  void configure(AnalysisContext context, Map<String, Object> options) {
     if (options == null) {
-      return;
+      options = defaults;
     }
 
     var analyzer = options[AnalyzerOptions.analyzer];
     if (analyzer is! Map) {
       return;
     }
 
     // Set strong mode (default is false).
     var strongMode = analyzer[AnalyzerOptions.strong_mode];
     setStrongMode(context, strongMode);
 
     // Set filters.
     var filters = analyzer[AnalyzerOptions.errors];
     setFilters(context, filters);
 
     // Process language options.
     var language = analyzer[AnalyzerOptions.language];
     setLanguageOptions(context, language);
   }
 
+  ErrorFilter parseFilter(String code, Object enable) {
+    enable = toLowerCase(enable);
+    if (AnalyzerOptions.ignoreSynonyms.contains(enable)) {
+      // Case-insensitive.
+      code = toUpperCase(code);
+      return ((AnalysisError error) => error.errorCode.name == code);
+    }
+  }
+
   void setFilters(AnalysisContext context, Object codes) {
     List<ErrorFilter> filters = <ErrorFilter>[];
     // If codes are enumerated, collect them as filters; else leave filters
     // empty to overwrite previous value.
     if (codes is YamlMap) {
       String value;
+      // TODO(pq): stop traversing nodes and unify w/ standard map handling
       codes.nodes.forEach((k, v) {
         if (k is YamlScalar && v is YamlScalar) {
-          value = toLowerCase(v.value);
-          if (AnalyzerOptions.ignoreSynonyms.contains(value)) {
-            // Case-insensitive.
-            String code = toUpperCase(k.value);
-            filters.add((AnalysisError error) => error.errorCode.name == code);
+          ErrorFilter filter = parseFilter(k.value, v.value);
+          if (filter != null) {
+            filters.add(filter);
           }
         }
       });
+    } else if (codes is Map) {
+      codes.forEach((k, v) {
+        if (k is String) {
+          ErrorFilter filter = parseFilter(k, v);
+          if (filter != null) {
+            filters.add(filter);
+          }
+        }
+      });
     }
     context.setConfigurationData(CONFIGURED_ERROR_FILTERS, filters);
   }
 
   void setLanguageOption(
       AnalysisContext context, Object feature, Object value) {
     if (feature == AnalyzerOptions.enableSuperMixins) {
       if (isTrue(value)) {
         AnalysisOptionsImpl options =
             new AnalysisOptionsImpl.from(context.analysisOptions);
@@ skipping 27 matching lines @@
   void setStrongMode(AnalysisContext context, Object strongMode) {
     bool strong = strongMode is bool ? strongMode : false;
     if (context.analysisOptions.strongMode != strong) {
       AnalysisOptionsImpl options =
           new AnalysisOptionsImpl.from(context.analysisOptions);
       options.strongMode = strong;
       context.analysisOptions = options;
     }
   }
 }