[messages] Make lint name matching case insensitive.

Adjusts the logic in the lint `Registry` class so that lint names are
matched in case-insensitive fashion. For the most part this is
accomplished by adding calls to `.toLowerCase()` inside the `Registry`
class, preserving its API.

For the `enabled` method, preserving the API would have been a pain (I
would have had to translate the keys in the `ruleConfigs` parameter to
lower case). So instead I added an assertion to verify that the keys
were lower case, and pushed the responsibility to the callers to
create lower case keys.

This paves the way for a follow-up CL that will translate diagnostic
codes to `lower_snake_case` conventions.

It also solves a longstanding problem with the mixed case lint rules
`no_runtimeType_toString`, `prefer_for_elements_to_map_fromIterable`,
`prefer_iterable_whereType`. Previously, the user had to carefully
imitate the capitalization of the lint rules when specifying them in
the `analysis_options.yaml` file, even though `// ignore:` comments
for the lints matched in case insensitive fashion. With this CL, the
lint rule names in `analysis_options.yaml` are matched in case
insensitive fashion as well.

Change-Id: I6a6a6964d83241e49878bbf96ef9b94cbb12098b
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/465964
Reviewed-by: Brian Wilkerson <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>

Author: stereotype441

pkg/analysis_server_plugin/lib/src/plugin_server.dart

@@ -439,9 +439,10 @@ class PluginServer {
     for (var configuration in analysisOptions.pluginConfigurations) {
       if (!configuration.isEnabled) continue;
       // TODO(srawlins): Namespace rules by their plugin, to avoid collisions.
-      var rules = Registry.ruleRegistry.enabled(
-        configuration.diagnosticConfigs,
-      );
+      var rules = Registry.ruleRegistry.enabled({
+        for (var entry in configuration.diagnosticConfigs.entries)
+          entry.key.toLowerCase(): entry.value,
+      });
 
       for (var code in rules.expand((r) => r.diagnosticCodes)) {
         pluginCodeMapping.putIfAbsent(code, () => configuration.name);

pkg/analyzer/lib/src/lint/config.dart

@@ -70,7 +70,11 @@ Map<String, RuleConfig>? parseLinterSection(YamlMap optionsMap) {
   // Quick check of basic contract.
   if (options is YamlMap) {
     var rulesNode = options.valueAt(AnalysisOptionsFile.rules);
-    return {if (rulesNode != null) ...parseDiagnosticsSection(rulesNode)};
+    return {
+      if (rulesNode != null)
+        for (var entry in parseDiagnosticsSection(rulesNode).entries)
+          entry.key.toLowerCase(): entry.value,
+    };
   }
 
   return null;

pkg/analyzer/lib/src/lint/registry.dart

@@ -13,13 +13,13 @@ class Registry with IterableMixin<AbstractAnalysisRule> {
   /// The default registry to be used by clients.
   static final Registry ruleRegistry = Registry();
 
-  /// A table mapping lint rule names to rules.
+  /// A table mapping lower case lint rule names to rules.
   final Map<String, AbstractAnalysisRule> _lintRules = {};
 
-  /// A table mapping warning rule names to rules.
+  /// A table mapping lower case warning rule names to rules.
   final Map<String, AbstractAnalysisRule> _warningRules = {};
 
-  /// A table mapping unique names to lint codes.
+  /// A table mapping lower case unique names to lint codes.
   final Map<String, DiagnosticCode> _codeMap = {};
 
   @override
@@ -36,10 +36,15 @@ class Registry with IterableMixin<AbstractAnalysisRule> {
   };
 
   /// Returns the rule with the given [name].
-  AbstractAnalysisRule? operator [](String name) => _rules[name];
+  ///
+  /// The name is matched disregarding case.
+  AbstractAnalysisRule? operator [](String name) => _rules[name.toLowerCase()];
 
   /// Returns the lint code that has the given [uniqueName].
-  DiagnosticCode? codeForUniqueName(String uniqueName) => _codeMap[uniqueName];
+  ///
+  /// The name is matched disregarding case.
+  DiagnosticCode? codeForUniqueName(String uniqueName) =>
+      _codeMap[uniqueName.toLowerCase()];
 
   /// Returns a list of the enabled rules.
   ///
@@ -51,50 +56,56 @@ class Registry with IterableMixin<AbstractAnalysisRule> {
   ///     my_rule: true
   ///
   /// enables `my_rule`.
-  Iterable<AbstractAnalysisRule> enabled(Map<String, RuleConfig> ruleConfigs) =>
-      [
-        // All warning rules that haven't explicitly been disabled.
-        ..._warningRules.values.where(
-          (rule) => ruleConfigs[rule.name]?.isEnabled ?? true,
-        ),
-        // All lint rules that have explicitly been enabled.
-        ..._lintRules.values.where(
-          (rule) => ruleConfigs[rule.name]?.isEnabled ?? false,
-        ),
-      ];
+  ///
+  /// Every key in [ruleConfigs] should be all lower case.
+  Iterable<AbstractAnalysisRule> enabled(Map<String, RuleConfig> ruleConfigs) {
+    assert(ruleConfigs.keys.every((key) => key == key.toLowerCase()));
+    return [
+      // All warning rules that haven't explicitly been disabled.
+      ..._warningRules.values.where(
+        (rule) => ruleConfigs[rule.name.toLowerCase()]?.isEnabled ?? true,
+      ),
+      // All lint rules that have explicitly been enabled.
+      ..._lintRules.values.where(
+        (rule) => ruleConfigs[rule.name.toLowerCase()]?.isEnabled ?? false,
+      ),
+    ];
+  }
 
   /// Returns the rule with the given [name].
-  AbstractAnalysisRule? getRule(String name) => _rules[name];
+  ///
+  /// The name is matched disregarding case.
+  AbstractAnalysisRule? getRule(String name) => _rules[name.toLowerCase()];
 
   /// Adds the given lint [rule] to this registry.
   void registerLintRule(AbstractAnalysisRule rule) {
-    _lintRules[rule.name] = rule;
+    _lintRules[rule.name.toLowerCase()] = rule;
     for (var code in rule.diagnosticCodes) {
-      _codeMap[code.uniqueName] = code;
+      _codeMap[code.uniqueName.toLowerCase()] = code;
     }
   }
 
   /// Adds the given warning [rule] to this registry.
   void registerWarningRule(AbstractAnalysisRule rule) {
-    _warningRules[rule.name] = rule;
+    _warningRules[rule.name.toLowerCase()] = rule;
     for (var code in rule.diagnosticCodes) {
-      _codeMap[code.uniqueName] = code;
+      _codeMap[code.uniqueName.toLowerCase()] = code;
     }
   }
 
   /// Removes the given lint [rule] from this registry.
   void unregisterLintRule(AbstractAnalysisRule rule) {
-    _lintRules.remove(rule.name);
+    _lintRules.remove(rule.name.toLowerCase());
     for (var code in rule.diagnosticCodes) {
-      _codeMap.remove(code.uniqueName);
+      _codeMap.remove(code.uniqueName.toLowerCase());
     }
   }
 
   /// Removes the given warning [rule] from this registry.
   void unregisterWarningRule(AbstractAnalysisRule rule) {
-    _warningRules.remove(rule.name);
+    _warningRules.remove(rule.name.toLowerCase());
     for (var code in rule.diagnosticCodes) {
-      _codeMap.remove(code.uniqueName);
+      _codeMap.remove(code.uniqueName.toLowerCase());
     }
   }
 }

pkg/analyzer_testing/lib/src/analysis_rule/pub_package_resolution.dart

@@ -192,7 +192,9 @@ final class ExpectedLint extends ExpectedDiagnostic {
     super.correctionContains,
     super.contextMessages,
   }) : super(
-         (diagnostic) => diagnostic.diagnosticCode.name == _lintName,
+         (diagnostic) =>
+             diagnostic.diagnosticCode.name.toLowerCase() ==
+             _lintName.toLowerCase(),
          offset,
          length,
        );