ErrorCode hashing for faster lookup in 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 'dart:collection';
+
 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/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';
@@ skipping 102 matching lines @@
   }
 }
 
 /// 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));
 
-  bool recognizedErrorCode(String name) =>
-      ErrorCode.values.any((ErrorCode code) => code.name == name) ||
-          StaticInfo.names.contains(name);
+  /// Lazily populated set of error codes (hashed for speedy lookup).
+  static HashSet<String> _errorCodes;
+
+  /// Legal error code names.
+  static Set<String> get errorCodes {
+    if (_errorCodes == null) {
+      _errorCodes = new HashSet<String>();
+      // Engine codes.
+      _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 (!recognizedErrorCode(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 (!AnalyzerOptions.ignoreSynonyms.contains(value) &&
               !AnalyzerOptions.includeSynonyms.contains(value)) {
@@ skipping 293 matching lines @@
   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;
     }
   }
 }