Improves options validation type safety (#24885).

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 108 matching lines @@
 
 /// Validates `analyzer` error filter options.
 class ErrorFilterOptionValidator extends OptionsValidator {
   /// Pretty list of legal includes.
   static final String legalIncludes = StringUtilities.printListOfQuotedNames(
       new List.from(AnalyzerOptions.ignoreSynonyms)
         ..addAll(AnalyzerOptions.includeSynonyms));
 
   @override
   void validate(ErrorReporter reporter, Map<String, YamlNode> options) {
-    YamlMap analyzer = options[AnalyzerOptions.analyzer];
-    if (analyzer == null) {
+    YamlNode analyzer = options[AnalyzerOptions.analyzer];
+    if (analyzer is! YamlMap) {
       return;
     }
 
     YamlNode filters = analyzer[AnalyzerOptions.errors];
     if (filters is YamlMap) {
       String value;
       filters.nodes.forEach((k, v) {
         if (k is YamlScalar) {
           value = toUpperCase(k.value);
           if (!ErrorCode.values.any((ErrorCode code) => code.name == value)) {
@@ skipping 85 matching lines @@
       new GenerateOptionsErrorsTask(context, target);
 }
 
 /// 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) {
-    YamlMap analyzer = options[AnalyzerOptions.analyzer];
-    if (analyzer == null) {
+    YamlNode analyzer = options[AnalyzerOptions.analyzer];
+    if (analyzer is! YamlMap) {
       return;
     }
 
     YamlNode language = analyzer[AnalyzerOptions.language];
     if (language is YamlMap) {
       language.nodes.forEach((k, v) {
         String key, value;
         bool validKey = false;
         if (k is YamlScalar) {
           key = k.value?.toString();
@@ skipping 93 matching lines @@
   AnalysisOptionsWarningCode get pluralProposalCode =>
       AnalysisOptionsWarningCode.UNSUPPORTED_VALUE;
 }
 
 class _OptionsProcessor {
   void configure(AnalysisContext context, Map<String, YamlNode> options) {
     if (options == null) {
       return;
     }
 
-    YamlMap analyzer = options[AnalyzerOptions.analyzer];
-    if (analyzer == null) {
+    var analyzer = options[AnalyzerOptions.analyzer];
+    if (analyzer is! YamlMap) {
       return;
     }
 
     // Set strong mode (default is false).
-    bool strongMode = analyzer[AnalyzerOptions.strong_mode] ?? false;
+    var strongMode = analyzer[AnalyzerOptions.strong_mode];
     setStrongMode(context, strongMode);
 
     // Set filters.
-    YamlNode filters = analyzer[AnalyzerOptions.errors];
+    var filters = analyzer[AnalyzerOptions.errors];
     setFilters(context, filters);
 
     // Process language options.
-    YamlNode language = analyzer[AnalyzerOptions.language];
+    var language = analyzer[AnalyzerOptions.language];
     setLanguageOptions(context, language);
   }
 
-  void setFilters(AnalysisContext context, YamlNode codes) {
+  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;
       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);
           }
         }
       });
     }
     context.setConfigurationData(CONFIGURED_ERROR_FILTERS, filters);
   }
 
-  void setLanguageOptions(AnalysisContext context, YamlNode configs) {
+  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;
             }
           }
         }
       });
     }
   }
 
-  void setStrongMode(AnalysisContext context, bool strongMode) {
-    if (context.analysisOptions.strongMode != strongMode) {
+  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 = strongMode;
+      options.strongMode = strong;
       context.analysisOptions = options;
     }
   }
 }