Fix more strong mode errors in analyzer

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 150 matching lines @@
       _errorCodes.addAll(ErrorCode.values.map((ErrorCode code) => code.name));
       // Strong-mode codes.
       _errorCodes.addAll(StaticInfo.names);
     }
     return _errorCodes;
   }
 
   @override
   void validate(ErrorReporter reporter, Map<String, YamlNode> options) {
     var analyzer = options[AnalyzerOptions.analyzer];
-    if (analyzer is! YamlMap) {
-      return;
-    }
-
-    var filters = analyzer[AnalyzerOptions.errors];
-    if (filters is YamlMap) {
-      String value;
-      filters.nodes.forEach((k, v) {
-        if (k is YamlScalar) {
-          value = toUpperCase(k.value);
-          if (!errorCodes.contains(value)) {
-            reporter.reportErrorForSpan(
-                AnalysisOptionsWarningCode.UNRECOGNIZED_ERROR_CODE,
-                k.span,
-                [k.value?.toString()]);
+    if (analyzer is YamlMap) {
+      var filters = analyzer[AnalyzerOptions.errors];
+      if (filters is YamlMap) {
+        String value;
+        filters.nodes.forEach((k, v) {
+          if (k is YamlScalar) {
+            value = toUpperCase(k.value);
+            if (!errorCodes.contains(value)) {
+              reporter.reportErrorForSpan(
+                  AnalysisOptionsWarningCode.UNRECOGNIZED_ERROR_CODE,
+                  k.span,
+                  [k.value?.toString()]);
+            }
           }
-        }
-        if (v is YamlScalar) {
-          value = toLowerCase(v.value);
-          if (!legalValues.contains(value)) {
-            reporter.reportErrorForSpan(
-                AnalysisOptionsWarningCode.UNSUPPORTED_OPTION_WITH_LEGAL_VALUES,
-                v.span, [
-              AnalyzerOptions.errors,
-              v.value?.toString(),
-              legalValueString
-            ]);
+          if (v is YamlScalar) {
+            value = toLowerCase(v.value);
+            if (!legalValues.contains(value)) {
+              reporter.reportErrorForSpan(
+                  AnalysisOptionsWarningCode
+                      .UNSUPPORTED_OPTION_WITH_LEGAL_VALUES,
+                  v.span,
+                  [
+                    AnalyzerOptions.errors,
+                    v.value?.toString(),
+                    legalValueString
+                  ]);
+            }
           }
-        }
-      });
+        });
+      }
     }
   }
 }
 
 /// A task that generates errors for an `.analysis_options` file.
 class GenerateOptionsErrorsTask extends SourceBasedAnalysisTask {
   /// The name of the input whose value is the content of the file.
   static const String CONTENT_INPUT_NAME = 'CONTENT_INPUT_NAME';
 
   /// The task descriptor describing this kind of task.
@@ skipping 37 matching lines @@
     outputs[ANALYSIS_OPTIONS_ERRORS] = errors;
     outputs[LINE_INFO] = computeLineInfo(content);
   }
 
   List<AnalysisError> _validate(Map<String, YamlNode> options) =>
       new OptionsFileValidator(source).validate(options);
 
   /// Return a map from the names of the inputs of this kind of task to the
   /// task input descriptors describing those inputs for a task with the
   /// given [target].
-  static Map<String, TaskInput> buildInputs(Source source) =>
+  static Map<String, TaskInput> buildInputs(AnalysisTarget source) =>
       <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.of(source)};
 
   /// Compute [LineInfo] for the given [content].
   static LineInfo computeLineInfo(String content) {
     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(
@@ skipping 13 matching lines @@
 }
 
 /// 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;
-    }
-
-    var 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();
-          if (!AnalyzerOptions.languageOptions.contains(key)) {
-            builder.reportError(reporter, AnalyzerOptions.language, k);
-          } else {
-            // If we have a valid key, go on and check the value.
-            validKey = true;
+    if (analyzer is YamlMap) {
+      var 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();
+            if (!AnalyzerOptions.languageOptions.contains(key)) {
+              builder.reportError(reporter, AnalyzerOptions.language, k);
+            } else {
+              // If we have a valid key, go on and check the value.
+              validKey = true;
+            }
           }
-        }
-        if (validKey && v is YamlScalar) {
-          value = toLowerCase(v.value);
-          if (!AnalyzerOptions.trueOrFalse.contains(value)) {
-            trueOrFalseBuilder.reportError(reporter, key, v);
+          if (validKey && v is YamlScalar) {
+            value = toLowerCase(v.value);
+            if (!AnalyzerOptions.trueOrFalse.contains(value)) {
+              trueOrFalseBuilder.reportError(reporter, key, v);
+            }
           }
-        }
-      });
+        });
+      }
     }
   }
 }
 
 /// Validates `linter` top-level options.
 /// TODO(pq): move into `linter` package and plugin.
 class LinterOptionsValidator extends TopLevelOptionValidator {
   LinterOptionsValidator() : super('linter', const ['rules']);
 }
 
@@ skipping 18 matching lines @@
   }
 }
 
 /// 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);
+    if (analyzer is YamlMap) {
+      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);
 }
@@ skipping 49 matching lines @@
 
   /**
    * Apply the options in the given [optionMap] to the given analysis [options].
    */
   void applyToAnalysisOptions(
       AnalysisOptionsImpl options, Map<String, Object> optionMap) {
     if (optionMap == null) {
       return;
     }
     var analyzer = optionMap[AnalyzerOptions.analyzer];
-    if (analyzer is! Map) {
-      return;
+    if (analyzer is Map) {
+      // Process strong mode option.
+      var strongMode = analyzer[AnalyzerOptions.strong_mode];
+      if (strongMode is bool) {
+        options.strongMode = strongMode;
+      }
+      // Process language options.
+      var language = analyzer[AnalyzerOptions.language];
+      _applyLanguageOptions(options, language);
     }
-    // Process strong mode option.
-    var strongMode = analyzer[AnalyzerOptions.strong_mode];
-    if (strongMode is bool) {
-      options.strongMode = strongMode;
-    }
-    // Process language options.
-    var language = analyzer[AnalyzerOptions.language];
-    _applyLanguageOptions(options, language);
   }
 
   /// 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) {
       options = defaults;
     }
 
     var analyzer = options[AnalyzerOptions.analyzer];
-    if (analyzer is! Map) {
-      return;
+    if (analyzer is Map) {
+      // Set strong mode (default is false).
+      var strongMode = analyzer[AnalyzerOptions.strong_mode];
+      setStrongMode(context, strongMode);
+
+      // Set filters.
+      var filters = analyzer[AnalyzerOptions.errors];
+      setProcessors(context, filters);
+
+      // Process language options.
+      var language = analyzer[AnalyzerOptions.language];
+      setLanguageOptions(context, language);
     }
-
-    // Set strong mode (default is false).
-    var strongMode = analyzer[AnalyzerOptions.strong_mode];
-    setStrongMode(context, strongMode);
-
-    // Set filters.
-    var filters = analyzer[AnalyzerOptions.errors];
-    setProcessors(context, filters);
-
-    // Process language options.
-    var language = analyzer[AnalyzerOptions.language];
-    setLanguageOptions(context, language);
   }
 
   void setLanguageOption(
       AnalysisContext context, Object feature, Object value) {
     if (feature == AnalyzerOptions.enableAsync) {
       if (isFalse(value)) {
         AnalysisOptionsImpl options =
             new AnalysisOptionsImpl.from(context.analysisOptions);
         options.enableAsync = false;
         context.analysisOptions = options;
@@ skipping 85 matching lines @@
           String feature = key.value?.toString();
           _applyLanguageOption(options, feature, value.value);
         }
       });
     } else if (configs is Map) {
       configs
           .forEach((key, value) => _applyLanguageOption(options, key, value));
     }
   }
 }