Embedded options discovery (#24943).

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 'package:analyzer/analyzer.dart';
 import 'package:analyzer/plugin/options.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/src/generated/engine.dart';
@@ skipping 209 matching lines @@
     List<int> lineStarts = StringUtilities.computeLineStarts(content);
     return new LineInfo(lineStarts);
   }
 
   /// Create a task based on the given [target] in the given [context].
   static GenerateOptionsErrorsTask createTask(
           AnalysisContext context, AnalysisTarget target) =>
       new GenerateOptionsErrorsTask(context, target);
 }
 
-/// Validates `analyzer` strong-mode value configuration options.
-class StrongModeOptionValueValidator extends OptionsValidator {
-  ErrorBuilder trueOrFalseBuilder = new TrueOrFalseValueErrorBuilder();
-
-  @override
-  void validate(ErrorReporter reporter, Map<String, YamlNode> options) {
-    var analyzer = options[AnalyzerOptions.analyzer];
-    if (analyzer is! YamlMap) {
-      return;
-    }
-
-    var v = analyzer.nodes[AnalyzerOptions.strong_mode];
-    if (v is YamlScalar) {
-      var value = toLowerCase(v.value);
-      if (!AnalyzerOptions.trueOrFalse.contains(value)) {
-        trueOrFalseBuilder.reportError(
-            reporter, AnalyzerOptions.strong_mode, v);
-      }
-    }
-  }
-}
-
 /// Validates `analyzer` language configuration options.
 class LanguageOptionValidator extends OptionsValidator {
   ErrorBuilder builder = new ErrorBuilder(AnalyzerOptions.languageOptions);
   ErrorBuilder trueOrFalseBuilder = new TrueOrFalseValueErrorBuilder();
 
   @override
   void validate(ErrorReporter reporter, Map<String, YamlNode> options) {
     var analyzer = options[AnalyzerOptions.analyzer];
     if (analyzer is! YamlMap) {
       return;
@@ skipping 44 matching lines @@
   }
 
   List<AnalysisError> validate(Map<String, YamlNode> options) {
     RecordingErrorListener recorder = new RecordingErrorListener();
     ErrorReporter reporter = new ErrorReporter(recorder, source);
     _validators.forEach((OptionsValidator v) => v.validate(reporter, options));
     return recorder.errors;
   }
 }
 
+/// Validates `analyzer` strong-mode value configuration options.
+class StrongModeOptionValueValidator extends OptionsValidator {
+  ErrorBuilder trueOrFalseBuilder = new TrueOrFalseValueErrorBuilder();
+
+  @override
+  void validate(ErrorReporter reporter, Map<String, YamlNode> options) {
+    var analyzer = options[AnalyzerOptions.analyzer];
+    if (analyzer is! YamlMap) {
+      return;
+    }
+
+    var v = analyzer.nodes[AnalyzerOptions.strong_mode];
+    if (v is YamlScalar) {
+      var value = toLowerCase(v.value);
+      if (!AnalyzerOptions.trueOrFalse.contains(value)) {
+        trueOrFalseBuilder.reportError(
+            reporter, AnalyzerOptions.strong_mode, v);
+      }
+    }
+  }
+}
+
 /// Validates `analyzer` top-level options.
 class TopLevelAnalyzerOptionsValidator extends TopLevelOptionValidator {
   TopLevelAnalyzerOptionsValidator()
       : super(AnalyzerOptions.analyzer, AnalyzerOptions.topLevel);
 }
 
 /// Validates top-level options. For example,
 ///     plugin:
 ///       top-level-option: true
 class TopLevelOptionValidator extends OptionsValidator {
@@ skipping 39 matching lines @@
       AnalysisOptionsWarningCode.UNSUPPORTED_VALUE;
 }
 
 class _OptionsProcessor {
   void configure(AnalysisContext context, Map<String, YamlNode> options) {
     if (options == null) {
       return;
     }
 
     var analyzer = options[AnalyzerOptions.analyzer];
-    if (analyzer is! YamlMap) {
+    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);
@@ skipping 16 matching lines @@
             // Case-insensitive.
             String code = toUpperCase(k.value);
             filters.add((AnalysisError error) => error.errorCode.name == code);
           }
         }
       });
     }
     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);
+        options.enableSuperMixins = true;
+        context.analysisOptions = options;
+      }
+    }
+    if (feature == AnalyzerOptions.enableGenericMethods) {
+      if (isTrue(value)) {
+        AnalysisOptionsImpl options =
+            new AnalysisOptionsImpl.from(context.analysisOptions);
+        options.enableGenericMethods = true;
+        context.analysisOptions = options;
+      }
+    }
+  }
+
   void setLanguageOptions(AnalysisContext context, Object configs) {
     if (configs is YamlMap) {
       configs.nodes.forEach((k, v) {
-        String feature;
         if (k is YamlScalar && v is YamlScalar) {
-          feature = k.value?.toString();
-          if (feature == AnalyzerOptions.enableSuperMixins) {
-            if (isTrue(v.value)) {
-              AnalysisOptionsImpl options =
-                  new AnalysisOptionsImpl.from(context.analysisOptions);
-              options.enableSuperMixins = true;
-              context.analysisOptions = options;
-            }
-          }
-          if (feature == AnalyzerOptions.enableGenericMethods) {
-            if (isTrue(v.value)) {
-              AnalysisOptionsImpl options =
-                  new AnalysisOptionsImpl.from(context.analysisOptions);
-              options.enableGenericMethods = true;
-              context.analysisOptions = options;
-            }
-          }
+          String feature = k.value?.toString();
+          setLanguageOption(context, feature, v.value);
         }
       });
+    } else if (configs is Map) {
+      configs.forEach((k, v) => setLanguageOption(context, k, v));
     }
   }
 
   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;
     }
   }
 }