Server custom error severity support (#24452).

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';
 import 'package:analyzer/source/analysis_options_provider.dart';
+import 'package:analyzer/source/error_processor.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/generated/utilities_general.dart';
 import 'package:analyzer/src/task/general.dart';
 import 'package:analyzer/src/task/strong/info.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';
@@ skipping 20 matching lines @@
   static const String enableSuperMixins = 'enableSuperMixins';
   static const String errors = 'errors';
   static const String exclude = 'exclude';
   static const String language = 'language';
   static const String plugins = 'plugins';
   static const String strong_mode = 'strong-mode';
 
   /// Ways to say `ignore`.
   static const List<String> ignoreSynonyms = const ['ignore', 'false'];
 
+  /// Valid error `severity`s.
+  static final List<String> severities =
+      ErrorSeverity.values.map((s) => s.name).toList();
+
   /// Ways to say `include`.
   static const List<String> includeSynonyms = const ['include', 'true'];
 
   /// Ways to say `true` or `false`.
   static const List<String> trueOrFalse = const ['true', 'false'];
 
   /// Supported top-level `analyzer` options.
   static const List<String> topLevel = const [
     errors,
     exclude,
@@ skipping 335 matching lines @@
     if (analyzer is! Map) {
       return;
     }
 
     // Set strong mode (default is false).
     var strongMode = analyzer[AnalyzerOptions.strong_mode];
     setStrongMode(context, strongMode);
 
     // Set filters.
     var filters = analyzer[AnalyzerOptions.errors];
-    setFilters(context, filters);
+    setProcessors(context, filters);
 
     // Process language options.
     var language = analyzer[AnalyzerOptions.language];
     setLanguageOptions(context, language);
   }
 
-  ErrorFilter parseFilter(String code, Object enable) {
-    enable = toLowerCase(enable);
-    if (AnalyzerOptions.ignoreSynonyms.contains(enable)) {
-      // Case-insensitive.
-      code = toUpperCase(code);
-      return ((AnalysisError error) => error.errorCode.name == code);
-    }
-  }
-
-  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;
-      // TODO(pq): stop traversing nodes and unify w/ standard map handling
-      codes.nodes.forEach((k, v) {
-        if (k is YamlScalar && v is YamlScalar) {
-          ErrorFilter filter = parseFilter(k.value, v.value);
-          if (filter != null) {
-            filters.add(filter);
-          }
-        }
-      });
-    } else if (codes is Map) {
-      codes.forEach((k, v) {
-        if (k is String) {
-          ErrorFilter filter = parseFilter(k, v);
-          if (filter != null) {
-            filters.add(filter);
-          }
-        }
-      });
-    }
-    context.setConfigurationData(CONFIGURED_ERROR_FILTERS, filters);
-  }
-
   void setLanguageOption(
       AnalysisContext context, Object feature, Object value) {
     if (feature == AnalyzerOptions.enableSuperMixins) {
       if (isTrue(value)) {
         AnalysisOptionsImpl options =
             new AnalysisOptionsImpl.from(context.analysisOptions);
         options.enableSuperMixins = true;
         context.analysisOptions = options;
       }
     }
@@ skipping 13 matching lines @@
         if (k is YamlScalar && v is YamlScalar) {
           String feature = k.value?.toString();
           setLanguageOption(context, feature, v.value);
         }
       });
     } else if (configs is Map) {
       configs.forEach((k, v) => setLanguageOption(context, k, v));
     }
   }
 
+  void setProcessors(AnalysisContext context, Object codes) {
+    ErrorConfig config = new ErrorConfig(codes);
+    context.setConfigurationData(CONFIGURED_ERROR_PROCESSORS, config.processors);
+  }
+
   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;
     }
   }
 }