Strong Mode option value validation.

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 55 matching lines @@
     enableGenericMethods,
     enableSuperMixins
   ];
 }
 
 /// Validates `analyzer` options.
 class AnalyzerOptionsValidator extends CompositeValidator {
   AnalyzerOptionsValidator()
       : super([
           new TopLevelAnalyzerOptionsValidator(),
+          new StrongModeOptionValueValidator(),
           new ErrorFilterOptionValidator(),
           new LanguageOptionValidator()
         ]);
 }
 
 /// Convenience class for composing validators.
 class CompositeValidator extends OptionsValidator {
   final List<OptionsValidator> validators;
   CompositeValidator(this.validators);
 
@@ skipping 133 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 149 matching lines @@
 
   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);
+                  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);
+                  new AnalysisOptionsImpl.from(context.analysisOptions);
               options.enableGenericMethods = true;
               context.analysisOptions = options;
             }
           }
         }
       });
     }
   }
 
   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;
     }
   }
 }