Error code validation for error filters.

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';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/general.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:source_span/source_span.dart';
 import 'package:yaml/yaml.dart';
 
 /// 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);
 
 /// `analyzer` analysis options constants.
 class AnalyzerOptions {
+  static const String analyzer = 'analyzer';
   static const String errors = 'errors';
   static const String exclude = 'exclude';
   static const String plugins = 'plugins';
   static const String strong_mode = 'strong-mode';
 
   /// Ways to say `ignore`.
   static const List<String> ignoreSynonyms = const ['ignore', 'false'];
 
+  /// Ways to say `include`.
+  static const List<String> includeSynonyms = const ['include', 'true'];
+
   /// Supported top-level `analyzer` options.
   static const List<String> top_level = const [
     errors,
     exclude,
     plugins,
     strong_mode
   ];
 }
 
+/// 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) {
+      // No options for analyzer.
+      return;
+    }
+
+    YamlNode filters = analyzer[AnalyzerOptions.errors];
+
+    if (filters is YamlMap) {
+      String value;
+      filters.nodes.forEach((k, v) {
+        if (k is YamlScalar) {
+          value = k.value?.toString()?.toUpperCase();
+          if (!ErrorCode.values.any((ErrorCode code) => code.name == value)) {
+            reporter.reportErrorForSpan(
+                AnalysisOptionsWarningCode.UNRECOGNIZED_ERROR_CODE,
+                k.span,
+                [k.value?.toString()]);
+          }
+        }
+        if (v is YamlScalar) {
+          value = v.value?.toString()?.toLowerCase();
+          if (!AnalyzerOptions.ignoreSynonyms.contains(value) &&
+              !AnalyzerOptions.includeSynonyms.contains(value)) {
+            reporter.reportErrorForSpan(
+                AnalysisOptionsWarningCode.UNSUPPORTED_OPTION_WITH_LEGAL_VALUES,
+                v.span,
+                [AnalyzerOptions.errors, v.value?.toString(), legalIncludes]);
+          }
+
+          value = v.value?.toString()?.toLowerCase();
+        }
+      });
+    }
+  }
+}
+
 /// Validates `analyzer` top-level options.
-class AnalyzerOptionsValidator extends TopLevelOptionValidator {
-  AnalyzerOptionsValidator() : super('analyzer', AnalyzerOptions.top_level);
+class TopLevelAnalyzerOptionsValidator extends TopLevelOptionValidator {
+  TopLevelAnalyzerOptionsValidator()
+      : super(AnalyzerOptions.analyzer, AnalyzerOptions.top_level);
+}
+
+/// Validates `analyzer` options.
+class AnalyzerOptionsValidator extends CompositeValidator {
+  AnalyzerOptionsValidator()
+      : super([
+          new TopLevelAnalyzerOptionsValidator(),
+          new ErrorFilterOptionValidator()
+        ]);
 }
 
 /// Convenience class for composing validators.
 class CompositeValidator extends OptionsValidator {
   final List<OptionsValidator> validators;
   CompositeValidator(this.validators);
 
   @override
   void validate(ErrorReporter reporter, Map<String, YamlNode> options) =>
       validators.forEach((v) => v.validate(reporter, options));
@@ skipping 92 matching lines @@
     return recorder.errors;
   }
 }
 
 /// Validates top-level options. For example,
 ///     plugin:
 ///       top-level-option: true
 class TopLevelOptionValidator extends OptionsValidator {
   final String pluginName;
   final List<String> supportedOptions;
+  String _valueProposal;
+  AnalysisOptionsWarningCode _warningCode;
+  TopLevelOptionValidator(this.pluginName, this.supportedOptions) {
+    assert(supportedOptions != null && !supportedOptions.isEmpty);
+    if (supportedOptions.length > 1) {
+      _valueProposal = StringUtilities.printListOfQuotedNames(supportedOptions);
+      _warningCode =
+          AnalysisOptionsWarningCode.UNSUPPORTED_OPTION_WITH_LEGAL_VALUES;
+    } else {
+      _valueProposal = "'${supportedOptions.join()}'";
+      _warningCode =
+          AnalysisOptionsWarningCode.UNSUPPORTED_OPTION_WITH_LEGAL_VALUE;
+    }
+  }
 
-  TopLevelOptionValidator(this.pluginName, this.supportedOptions);
   @override
   void validate(ErrorReporter reporter, Map<String, YamlNode> options) {
     YamlNode node = options[pluginName];
     if (node is YamlMap) {
       node.nodes.forEach((k, v) {
         if (k is YamlScalar) {
           if (!supportedOptions.contains(k.value)) {
             reporter.reportErrorForSpan(
-                AnalysisOptionsWarningCode.UNSUPPORTED_OPTION,
-                k.span,
-                [pluginName, k.value]);
+                _warningCode, k.span, [pluginName, k.value, _valueProposal]);
           }
         }
         //TODO(pq): consider an error if the node is not a Scalar.
       });
     }
   }
 }