More options file validation (and API iteration).

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/source/analysis_options_provider.dart';
 import 'package:analyzer/src/generated/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);
 
+/// Validates `analyzer` top-level options.
+class AnalyzerOptionsValidator extends TopLevelOptionValidator {
+  AnalyzerOptionsValidator()
+      : super('analyzer', const ['exclude', 'plugins', 'strong-mode']);
+}
+
 /// 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.
   static final TaskDescriptor DESCRIPTOR = new TaskDescriptor(
       'GenerateOptionsErrorsTask',
       createTask,
       buildInputs,
@@ skipping 40 matching lines @@
   /// given [target].
   static Map<String, TaskInput> buildInputs(Source source) =>
       <String, TaskInput>{CONTENT_INPUT_NAME: CONTENT.of(source)};
 
   /// Create a task based on the given [target] in the given [context].
   static GenerateOptionsErrorsTask createTask(
           AnalysisContext context, AnalysisTarget target) =>
       new GenerateOptionsErrorsTask(context, target);
 }
 
+/// Validates `linter` top-level options.
+/// TODO(pq): move into `linter` package and plugin.

[pquitslund, 2015/10/22 17:48:26]

Or maybe to a server-hosted linter plugin.  (In any event OUT of here!)

+class LinterOptionsValidator extends TopLevelOptionValidator {
+  LinterOptionsValidator() : super('linter', const ['rules']);
+}
+
 /// Validates options defined in an `.analysis_options` file.
 class OptionsFileValidator {
-  // TODO(pq): consider an extension point.
+  // TODO(pq): move to an extension point.
   static final List<OptionsValidator> _validators = [
-    new AnalyzerOptionsValidator()
+    new AnalyzerOptionsValidator(), new LinterOptionsValidator()
   ];
 
   final Source source;
   OptionsFileValidator(this.source);
 
   List<AnalysisError> validate(Map<String, YamlNode> options) {
-    List<AnalysisError> errors = <AnalysisError>[];
-    _validators.forEach(
-        (OptionsValidator v) => errors.addAll(v.validate(source, options)));
-    return errors;
+    RecordingErrorListener recorder = new RecordingErrorListener();
+    ErrorReporter reporter = new ErrorReporter(recorder, source);
+    _validators.forEach((OptionsValidator v) => v.validate(reporter, options));
+    return recorder.errors;
   }
 }
 
-AnalysisError _unsupportedOption(
-    Source source, YamlScalar key, String pluginName) {
-  SourceSpan span = key.span;
-  return new AnalysisError(source, span.start.column + 1, span.length,
-      AnalysisOptionsWarningCode.UNSUPPORTED_OPTION, [pluginName, key.value]);
-}
-
 /// Validates options.
 abstract class OptionsValidator {
-  List<AnalysisError> validate(Source source, Map<String, YamlNode> options);
+  /// Validate [options], reporting any errors to the given [reporter].
+  void validate(ErrorReporter reporter, Map<String, YamlNode> options);
 }
 
-/// Validates `analyzer` options.
-class AnalyzerOptionsValidator extends OptionsValidator {
-  static const List<String> _supportedOptions = const [
-    'exclude',
-    'strong-mode'
-  ];
+/// Validates top-level options. For example,
+///     plugin:
+///       top-level-option: true
+class TopLevelOptionValidator extends OptionsValidator {
+  final String pluginName;
+  final List<String> supportedOptions;

[Brian Wilkerson, 2015/10/22 20:00:15]

Might be interesting to eventually make this a map from option names to a
validator function/option to be applied to the value.

[pquitslund, 2015/10/22 20:19:26]

Good idea!

 
+  TopLevelOptionValidator(this.pluginName, this.supportedOptions);
   @override
-  List<AnalysisError> validate(Source source, Map<String, YamlNode> options) {
-    List<AnalysisError> errors = <AnalysisError>[];
-    YamlNode node = options['analyzer'];
+  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) {

[Brian Wilkerson, 2015/10/22 20:00:15]

Is it an error if the key is not a scalar value? (If so, a TODO to report the
error would be fine.)

[pquitslund, 2015/10/22 20:19:26]

Done.

-          if (!_supportedOptions.contains(k.value)) {
-            errors.add(_unsupportedOption(source, k, 'analyzer'));
+          if (!supportedOptions.contains(k.value)) {
+            reporter.reportErrorForSpan(
+                AnalysisOptionsWarningCode.UNSUPPORTED_OPTION,
+                k.span,
+                [pluginName, k.value]);
           }
         }
       });
     }
-    return errors;
   }
 }