feat: add support for configuration error severities in analysis_options.yaml

README.md

@@ -227,6 +227,19 @@ custom_lint:
       some_parameter: "some value"
 ```
 
+#### Overriding lint error severities
+
+You can also override the severity of lint rules in the `analysis_options.yaml` file.
+This allows you to change INFO level lints to WARNING or ERROR, or vice versa:
+
+```yaml
+custom_lint:
+  errors:
+    my_lint_rule: error
+```
+
+The available severity levels are: `error`, `warning`, `info`, and `ignore`.
+
 ### Obtaining the list of lints in the CI
 
 Unfortunately, running `dart analyze` does not pick up our newly defined lints.

packages/custom_lint/example/analysis_options.yaml

@@ -8,4 +8,4 @@ linter:
   rules:
     public_member_api_docs: false
     avoid_print: false
-    unreachable_from_main: false
+    unreachable_from_main: false

packages/custom_lint/test/analysis_options_test.dart

@@ -0,0 +1,148 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:analyzer/error/error.dart';
+import 'package:test/test.dart';
+
+import 'cli_process_test.dart';
+import 'create_project.dart';
+import 'peer_project_meta.dart';
+
+void main() {
+  group('Errors severities override', () {
+    Future<ProcessResult> runProcess(String workingDirectoryPath) async =>
+        Process.run(
+          'dart',
+          [customLintBinPath],
+          workingDirectory: workingDirectoryPath,
+          stdoutEncoding: utf8,
+          stderrEncoding: utf8,
+        );
+
+    Directory createLintUsageWith({
+      required Uri pluginUri,
+      required String analysisOptions,
+    }) =>
+        createLintUsage(
+          name: 'test_app',
+          source: {'lib/main.dart': 'void fn() {}'},
+          plugins: {'test_lint': pluginUri},
+          analysisOptions: analysisOptions,
+        );
+
+    Directory createTestPlugin({
+      ErrorSeverity errorSeverity = ErrorSeverity.INFO,
+    }) =>
+        createPlugin(
+          name: 'test_lint',
+          main: createPluginSource([
+            TestLintRule(
+              code: 'test_lint',
+              message: 'Test lint message',
+              errorSeverity: errorSeverity,
+            ),
+          ]),
+        );
+    test('correctly applies error severity from analysis_options.yaml',
+        () async {
+      final plugin = createTestPlugin();
+
+      final app = createLintUsageWith(
+        pluginUri: plugin.uri,
+        analysisOptions: '''
+custom_lint:
+  errors:
+    test_lint: error
+''',
+      );
+
+      final process = await runProcess(app.path);
+
+      expect(trimDependencyOverridesWarning(process.stderr), isEmpty);
+      expect(process.stdout, '''
+Analyzing...
+
+  lib/main.dart:1:6 • Test lint message • test_lint • ERROR
+
+1 issue found.
+''');
+      expect(process.exitCode, 1);
+    });
+
+    test('correctly applies warning severity from analysis_options.yaml',
+        () async {
+      final plugin = createTestPlugin();
+
+      final app = createLintUsageWith(
+        pluginUri: plugin.uri,
+        analysisOptions: '''
+custom_lint:
+  errors:
+    test_lint: warning
+''',
+      );
+
+      final process = await runProcess(app.path);
+
+      expect(trimDependencyOverridesWarning(process.stderr), isEmpty);
+      expect(process.stdout, '''
+Analyzing...
+
+  lib/main.dart:1:6 • Test lint message • test_lint • WARNING
+
+1 issue found.
+''');
+      expect(process.exitCode, 1);
+    });
+
+    test('correctly applies info severity from analysis_options.yaml',
+        () async {
+      final plugin = createTestPlugin();
+
+      final app = createLintUsageWith(
+        pluginUri: plugin.uri,
+        analysisOptions: '''
+custom_lint:
+  errors:
+    test_lint: info
+''',
+      );
+
+      final process = await runProcess(app.path);
+
+      expect(trimDependencyOverridesWarning(process.stderr), isEmpty);
+      expect(process.stdout, '''
+Analyzing...
+
+  lib/main.dart:1:6 • Test lint message • test_lint • INFO
+
+1 issue found.
+''');
+      expect(process.exitCode, 1);
+    });
+
+    test('correctly applies ignore severity from analysis_options.yaml',
+        () async {
+      final plugin = createTestPlugin();
+
+      final app = createLintUsageWith(
+        pluginUri: plugin.uri,
+        analysisOptions: '''
+custom_lint:
+  errors:
+    test_lint: ignore
+''',
+      );
+
+      final process = await runProcess(app.path);
+
+      expect(trimDependencyOverridesWarning(process.stderr), isEmpty);
+      expect(process.stdout, '''
+Analyzing...
+
+No issues found!
+''');
+      expect(process.exitCode, 0);
+    });
+  });
+}

packages/custom_lint/test/create_project.dart

@@ -219,6 +219,7 @@ Directory createLintUsage({
   Directory? parent,
   Map<String, Uri> plugins = const {},
   Map<String, String> source = const {},
+  String? analysisOptions,
   Map<String, Uri> extraPackageConfig = const {},
   bool installAsDevDependency = true,
   required String name,
@@ -239,6 +240,7 @@ analyzer:
   plugins:
     - custom_lint
 
+${analysisOptions ?? ''}
 ''',
     pubspec: '''
 name: $name

packages/custom_lint_builder/lib/src/client.dart

@@ -991,11 +991,27 @@ class _ClientAnalyzerPlugin extends analyzer_plugin.ServerPlugin {
         CustomLintEvent.analyzerPluginNotification(
           analyzer_plugin.AnalysisErrorsParams(
             path,
-            CustomAnalyzerConverter().convertAnalysisErrors(
-              allAnalysisErrors,
-              lineInfo: resolver.lineInfo,
-              options: analysisContext.getAnalysisOptionsForFile(file),
-            ),
+            CustomAnalyzerConverter()
+                .convertAnalysisErrors(
+                  allAnalysisErrors,
+                  lineInfo: resolver.lineInfo,
+                  options: analysisContext.getAnalysisOptionsForFile(file),
+                )
+                // Filter out lints with severity: ignore
+                .whereNot(
+                  (error) =>
+                      configs.configs.errors[error.code] == ErrorSeverity.NONE,
+                )
+                // Override severities from analysis_options.yaml
+                .map((error) {
+              var severity = error.severity;
+              if (configs.configs.errors[error.code]
+                  case final ErrorSeverity errorSeverity) {
+                severity = CustomAnalyzerConverter()
+                    .convertErrorSeverity(errorSeverity);
+              }
+              return error.copyWith(severity: severity);
+            }).toList(),
           ).toNotification(),
         ),
       );
@@ -1240,3 +1256,29 @@ extension on ChangeReporterBuilder {
     );
   }
 }
+
+extension on analyzer_plugin.AnalysisError {
+  analyzer_plugin.AnalysisError copyWith({
+    analyzer_plugin.AnalysisErrorSeverity? severity,
+    String? correction,
+    analyzer_plugin.Location? location,
+    String? message,
+    analyzer_plugin.AnalysisErrorType? type,
+    String? code,
+    String? url,
+    List<analyzer_plugin.DiagnosticMessage>? contextMessages,
+    bool? hasFix,
+  }) {
+    return analyzer_plugin.AnalysisError(
+      severity ?? this.severity,
+      type ?? this.type,
+      location ?? this.location,
+      message ?? this.message,
+      code ?? this.code,
+      correction: correction ?? this.correction,
+      url: url ?? this.url,
+      contextMessages: contextMessages ?? this.contextMessages,
+      hasFix: hasFix ?? this.hasFix,
+    );
+  }
+}

packages/custom_lint_core/lib/src/configs.dart

@@ -1,3 +1,4 @@
+import 'package:analyzer/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:collection/collection.dart';
 import 'package:meta/meta.dart';
@@ -17,6 +18,7 @@ class CustomLintConfigs {
     required this.verbose,
     required this.debug,
     required this.rules,
+    required this.errors,
   });
 
   /// Decode a [CustomLintConfigs] from a file.
@@ -108,11 +110,30 @@ class CustomLintConfigs {
       }
     }
 
+    final errors = <String, ErrorSeverity>{...includedOptions.errors};
+
+    if (customLint['errors'] case final YamlMap errorsYaml) {
+      for (final entry in errorsYaml.entries) {
+        if (entry.key case final String key) {
+          errors[key] = switch (entry.value) {
+            'info' => ErrorSeverity.INFO,
+            'warning' => ErrorSeverity.WARNING,
+            'error' => ErrorSeverity.ERROR,
+            'ignore' => ErrorSeverity.NONE,
+            _ => throw UnsupportedError(
+                'Unsupported severity ${entry.value} for key: ${entry.key}',
+              ),
+          };
+        }
+      }
+    }
+
     return CustomLintConfigs(
       enableAllLintRules: enableAllLintRules,
       verbose: verbose,
       debug: debug,
       rules: UnmodifiableMapView(rules),
+      errors: UnmodifiableMapView(errors),
     );
   }
 
@@ -123,6 +144,7 @@ class CustomLintConfigs {
     verbose: false,
     debug: false,
     rules: {},
+    errors: {},
   );
 
   /// A field representing whether to enable/disable lint rules that are not
@@ -147,20 +169,26 @@ class CustomLintConfigs {
   /// Whether enable hot-reload and log the VM-service URI.
   final bool debug;
 
+  /// A map of lint rules to their severity. This is used to override the severity
+  /// of a lint rule for a specific lint.
+  final Map<String, ErrorSeverity> errors;
+
   @override
   bool operator ==(Object other) =>
       other is CustomLintConfigs &&
       other.enableAllLintRules == enableAllLintRules &&
       other.verbose == verbose &&
       other.debug == debug &&
-      const MapEquality<String, LintOptions>().equals(other.rules, rules);
+      const MapEquality<String, LintOptions>().equals(other.rules, rules) &&
+      const MapEquality<String, ErrorSeverity>().equals(other.errors, errors);
 
   @override
   int get hashCode => Object.hash(
         enableAllLintRules,
         verbose,
         debug,
         const MapEquality<String, LintOptions>().hash(rules),
+        const MapEquality<String, ErrorSeverity>().hash(errors),
       );
 }