refactor: consolidate lint fix registration logic

lib/main.dart

@@ -3,38 +3,32 @@ import 'package:analysis_server_plugin/registry.dart';
 import 'package:solid_lints/src/common/parameter_parser/analysis_options_loader.dart';
 import 'package:solid_lints/src/lints/avoid_debug_print_in_release/avoid_debug_print_in_release_rule.dart';
 import 'package:solid_lints/src/lints/avoid_final_with_getter/avoid_final_with_getter_rule.dart';
-import 'package:solid_lints/src/lints/avoid_final_with_getter/fixes/avoid_final_with_getter_fix.dart';
 import 'package:solid_lints/src/lints/avoid_global_state/avoid_global_state_rule.dart';
+import 'package:solid_lints/src/lints/avoid_late_keyword/avoid_late_keyword_rule.dart';
 import 'package:solid_lints/src/lints/avoid_non_null_assertion/avoid_non_null_assertion_rule.dart';
 import 'package:solid_lints/src/lints/avoid_returning_widgets/avoid_returning_widgets_rule.dart';
 import 'package:solid_lints/src/lints/avoid_unnecessary_return_variable/avoid_unnecessary_return_variable_rule.dart';
 import 'package:solid_lints/src/lints/avoid_unnecessary_setstate/avoid_unnecessary_set_state_rule.dart';
 import 'package:solid_lints/src/lints/avoid_unnecessary_type_assertions/avoid_unnecessary_type_assertions_rule.dart';
-import 'package:solid_lints/src/lints/avoid_unnecessary_type_assertions/fixes/avoid_unnecessary_type_assertions_fix.dart';
 import 'package:solid_lints/src/lints/avoid_unrelated_type_assertions/avoid_unrelated_type_assertions_rule.dart';
 import 'package:solid_lints/src/lints/avoid_unused_parameters/avoid_unused_parameters_rule.dart';
 import 'package:solid_lints/src/lints/cyclomatic_complexity/cyclomatic_complexity_rule.dart';
 import 'package:solid_lints/src/lints/double_literal_format/double_literal_format_rule.dart';
-import 'package:solid_lints/src/lints/double_literal_format/fixes/double_literal_format_fix.dart';
 import 'package:solid_lints/src/lints/function_lines_of_code/function_lines_of_code_rule.dart';
 import 'package:solid_lints/src/lints/member_ordering/member_ordering_rule.dart';
-import 'package:solid_lints/src/lints/named_parameters_ordering/fixes/named_parameters_ordering_fix.dart';
 import 'package:solid_lints/src/lints/named_parameters_ordering/named_parameters_ordering_rule.dart';
 import 'package:solid_lints/src/lints/newline_before_return/newline_before_return_rule.dart';
 import 'package:solid_lints/src/lints/no_empty_block/no_empty_block_rule.dart';
 import 'package:solid_lints/src/lints/no_equal_then_else/no_equal_then_else_rule.dart';
 import 'package:solid_lints/src/lints/no_magic_number/no_magic_number_rule.dart';
 import 'package:solid_lints/src/lints/number_of_parameters/number_of_parameters_rule.dart';
-import 'package:solid_lints/src/lints/prefer_conditional_expressions/fixes/prefer_conditional_expressions_fix.dart';
 import 'package:solid_lints/src/lints/prefer_conditional_expressions/prefer_conditional_expressions_rule.dart';
 import 'package:solid_lints/src/lints/prefer_early_return/prefer_early_return_rule.dart';
-import 'package:solid_lints/src/lints/prefer_first/fixes/prefer_first_fix.dart';
 import 'package:solid_lints/src/lints/prefer_first/prefer_first_rule.dart';
-import 'package:solid_lints/src/lints/prefer_last/fixes/prefer_last_fix.dart';
 import 'package:solid_lints/src/lints/prefer_last/prefer_last_rule.dart';
 import 'package:solid_lints/src/lints/proper_super_calls/proper_super_calls_rule.dart';
-import 'package:solid_lints/src/lints/use_nearest_context/fixes/rename_nearest_context_parameter_fix.dart';
 import 'package:solid_lints/src/lints/use_nearest_context/use_nearest_context_rule.dart';
+import 'package:solid_lints/src/models/rule_with_fixes.dart';
 
 /// The entry point for the Solid Lints analyser server plugin.
 ///
@@ -54,88 +48,43 @@ class SolidLintsPlugin extends Plugin {
   void register(PluginRegistry registry) {
     final analysisLoader = AnalysisOptionsLoader();
 
-    final avoidUnnecessaryTypeAssertionsRule =
-        AvoidUnnecessaryTypeAssertionsRule();
-    final doubleLiteralFormatRule = DoubleLiteralFormatRule();
-    final preferFirstRule = PreferFirstRule();
-    final preferConditionalExpressionsRule = PreferConditionalExpressionsRule(
-      analysisOptionsLoader: analysisLoader,
-    );
-    final preferLastRule = PreferLastRule();
-
     final lintRules = [
+      AvoidDebugPrintInReleaseRule(),
       AvoidFinalWithGetterRule(),
       AvoidGlobalStateRule(),
+      AvoidLateKeywordRule(analysisOptionsLoader: analysisLoader),
       AvoidNonNullAssertionRule(analysisOptionsLoader: analysisLoader),
-      avoidUnnecessaryTypeAssertionsRule,
-      AvoidDebugPrintInReleaseRule(),
-      doubleLiteralFormatRule,
-      ProperSuperCallsRule(),
-      NamedParametersOrderingRule(analysisOptionsLoader: analysisLoader),
       AvoidReturningWidgetsRule(analysisOptionsLoader: analysisLoader),
-      MemberOrderingRule(analysisOptionsLoader: analysisLoader),
-      AvoidUnusedParametersRule(analysisOptionsLoader: analysisLoader),
-      NumberOfParametersRule(analysisOptionsLoader: analysisLoader),
-      FunctionLinesOfCodeRule(analysisOptionsLoader: analysisLoader),
-      CyclomaticComplexityRule(analysisOptionsLoader: analysisLoader),
-      NoEmptyBlockRule(analysisOptionsLoader: analysisLoader),
-      UseNearestContextRule(),
-      NoMagicNumberRule(analysisOptionsLoader: analysisLoader),
-      preferFirstRule,
-      preferConditionalExpressionsRule,
-      preferLastRule,
-      // TODO: Add more lint rules and use analysisLoader
-      // for rules that need parameters
-      // For example: `CyclomaticComplexityRule(analysisLoader)`
       AvoidUnnecessaryReturnVariableRule(),
       AvoidUnnecessarySetStateRule(),
+      AvoidUnnecessaryTypeAssertionsRule(),
       AvoidUnrelatedTypeAssertionsRule(),
+      AvoidUnusedParametersRule(analysisOptionsLoader: analysisLoader),
+      CyclomaticComplexityRule(analysisOptionsLoader: analysisLoader),
+      DoubleLiteralFormatRule(),
+      FunctionLinesOfCodeRule(analysisOptionsLoader: analysisLoader),
+      MemberOrderingRule(analysisOptionsLoader: analysisLoader),
+      NamedParametersOrderingRule(analysisOptionsLoader: analysisLoader),
       NewlineBeforeReturnRule(),
+      NoEmptyBlockRule(analysisOptionsLoader: analysisLoader),
       NoEqualThenElseRule(),
+      NoMagicNumberRule(analysisOptionsLoader: analysisLoader),
+      NumberOfParametersRule(analysisOptionsLoader: analysisLoader),
+      PreferConditionalExpressionsRule(analysisOptionsLoader: analysisLoader),
       PreferEarlyReturnRule(),
+      PreferFirstRule(),
+      PreferLastRule(),
+      ProperSuperCallsRule(),
+      UseNearestContextRule(),
     ];
 
     for (final lintRule in lintRules) {
       registry.registerLintRule(lintRule);
+      if (lintRule is RuleWithFixes) {
+        for (final entry in (lintRule as RuleWithFixes).fixesForCodes) {
+          registry.registerFixForRule(entry.key, entry.value);
+        }
+      }
     }
-
-    for (final code in doubleLiteralFormatRule.diagnosticCodes) {
-      registry.registerFixForRule(code, DoubleLiteralFormatFix.new);
-    }
-
-    registry.registerFixForRule(
-      AvoidFinalWithGetterRule.code,
-      AvoidFinalWithGetterFix.new,
-    );
-
-    registry.registerFixForRule(
-      avoidUnnecessaryTypeAssertionsRule.diagnosticCode,
-      AvoidUnnecessaryTypeAssertionsFix.new,
-    );
-
-    registry.registerFixForRule(
-      UseNearestContextRule.code,
-      RenameNearestContextParameterFix.new,
-    );
-
-    registry.registerFixForRule(
-      preferFirstRule.diagnosticCode,
-      PreferFirstFix.new,
-    );
-
-    registry.registerFixForRule(
-      preferLastRule.diagnosticCode,
-      PreferLastFix.new,
-    );
-
-    registry.registerFixForRule(
-      preferConditionalExpressionsRule.diagnosticCode,
-      PreferConditionalExpressionsFix.new,
-    );
-
-    registry.registerFixForRule(
-      NamedParametersOrderingRule.code,
-      NamedParametersOrderingFix.new,
-    );
   }
 }

lib/src/lints/avoid_final_with_getter/avoid_final_with_getter_rule.dart

@@ -2,7 +2,9 @@ import 'package:analyzer/analysis_rule/analysis_rule.dart';
 import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/error/error.dart';
+import 'package:solid_lints/src/lints/avoid_final_with_getter/fixes/avoid_final_with_getter_fix.dart';
 import 'package:solid_lints/src/lints/avoid_final_with_getter/visitors/avoid_final_with_getter_visitor.dart';
+import 'package:solid_lints/src/models/rule_with_fixes.dart';
 
 /// Avoid using final private fields with getters.
 ///
@@ -30,7 +32,7 @@ import 'package:solid_lints/src/lints/avoid_final_with_getter/visitors/avoid_fin
 /// }
 /// ```
 ///
-class AvoidFinalWithGetterRule extends AnalysisRule {
+class AvoidFinalWithGetterRule extends AnalysisRule implements RuleWithFixes {
   /// This lint rule represents
   /// the error whether we use final private fields with getters.
   static const lintName = 'avoid_final_with_getter';
@@ -44,11 +46,15 @@ class AvoidFinalWithGetterRule extends AnalysisRule {
 
   /// Creates a new instance of [AvoidFinalWithGetterRule]
   AvoidFinalWithGetterRule()
-      : super(name: lintName, description: code.problemMessage);
+    : super(name: lintName, description: code.problemMessage);
 
   @override
   LintCode get diagnosticCode => code;
 
+  @override
+  Iterable<MapEntry<DiagnosticCode, ProducerGenerator>> get fixesForCodes =>
+      const [MapEntry(code, AvoidFinalWithGetterFix.new)];
+
   @override
   void registerNodeProcessors(
     RuleVisitorRegistry registry,

lib/src/lints/avoid_unnecessary_type_assertions/avoid_unnecessary_type_assertions_rule.dart

@@ -2,15 +2,18 @@ import 'package:analyzer/analysis_rule/analysis_rule.dart';
 import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/error/error.dart';
+import 'package:solid_lints/src/lints/avoid_unnecessary_type_assertions/fixes/avoid_unnecessary_type_assertions_fix.dart';
 import 'package:solid_lints/src/lints/avoid_unnecessary_type_assertions/visitors/unnecessary_is_expression_visitor.dart';
 import 'package:solid_lints/src/lints/avoid_unnecessary_type_assertions/visitors/unnecessary_where_type_visitor.dart';
+import 'package:solid_lints/src/models/rule_with_fixes.dart';
 
 /// Warns about unnecessary usage of `is` and `whereType` operators.
 ///
 /// ### Example:
 /// {@macro solid_lints.avoid_unnecessary_type_assertions.example_is}
 /// {@macro solid_lints.avoid_unnecessary_type_assertions.example_where}
-class AvoidUnnecessaryTypeAssertionsRule extends AnalysisRule {
+class AvoidUnnecessaryTypeAssertionsRule extends AnalysisRule
+    implements RuleWithFixes {
   /// The name of 'is' operator
   static const operatorIsName = 'is';
 
@@ -26,16 +29,25 @@ class AvoidUnnecessaryTypeAssertionsRule extends AnalysisRule {
     "Unnecessary usage of the {0}.",
   );
 
-  @override
-  DiagnosticCode get diagnosticCode => _unnecessaryTypeAssertionsCode;
-
   /// Creates a new instance of [AvoidUnnecessaryTypeAssertionsRule]
   AvoidUnnecessaryTypeAssertionsRule()
     : super(
         name: lintName,
         description: "Unnecessary usage of typecast operators.",
       );
 
+  @override
+  DiagnosticCode get diagnosticCode => _unnecessaryTypeAssertionsCode;
+
+  @override
+  Iterable<MapEntry<DiagnosticCode, ProducerGenerator>> get fixesForCodes =>
+      const [
+        MapEntry(
+          _unnecessaryTypeAssertionsCode,
+          AvoidUnnecessaryTypeAssertionsFix.new,
+        ),
+      ];
+
   @override
   void registerNodeProcessors(
     RuleVisitorRegistry registry,

lib/src/lints/double_literal_format/double_literal_format_rule.dart

@@ -2,7 +2,9 @@ import 'package:analyzer/analysis_rule/analysis_rule.dart';
 import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/error/error.dart';
+import 'package:solid_lints/src/lints/double_literal_format/fixes/double_literal_format_fix.dart';
 import 'package:solid_lints/src/lints/double_literal_format/visitors/double_literal_format_visitor.dart';
+import 'package:solid_lints/src/models/rule_with_fixes.dart';
 
 /// A `double_literal_format` rule which
 /// checks that double literals should begin with 0. instead of just .,
@@ -23,7 +25,8 @@ import 'package:solid_lints/src/lints/double_literal_format/visitors/double_lite
 /// var a = 5.23, b = 0.16e+5, c = -0.25, d = -0.4e-5;
 /// ```
 /// {@endtemplate}
-class DoubleLiteralFormatRule extends MultiAnalysisRule {
+class DoubleLiteralFormatRule extends MultiAnalysisRule
+    implements RuleWithFixes {
   /// This lint rule represents
   /// the error whether we use bad formatted double literals.
   static const lintName = 'double_literal_format';
@@ -96,13 +99,6 @@ class DoubleLiteralFormatRule extends MultiAnalysisRule {
     uniqueName: 'trailingZero',
   );
 
-  @override
-  List<DiagnosticCode> get diagnosticCodes => [
-    leadingZeroCode,
-    leadingDecimalCode,
-    trailingZeroCode,
-  ];
-
   /// Creates a new instance of [DoubleLiteralFormatRule]
   DoubleLiteralFormatRule()
     : super(
@@ -113,6 +109,17 @@ class DoubleLiteralFormatRule extends MultiAnalysisRule {
             'should not start with a leading 0',
       );
 
+  @override
+  List<DiagnosticCode> get diagnosticCodes => [
+    leadingZeroCode,
+    leadingDecimalCode,
+    trailingZeroCode,
+  ];
+
+  @override
+  Iterable<MapEntry<DiagnosticCode, ProducerGenerator>> get fixesForCodes =>
+      diagnosticCodes.map((code) => MapEntry(code, DoubleLiteralFormatFix.new));
+
   @override
   void registerNodeProcessors(
     RuleVisitorRegistry registry,

lib/src/lints/named_parameters_ordering/named_parameters_ordering_rule.dart

@@ -1,9 +1,11 @@
 import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/error/error.dart';
+import 'package:solid_lints/src/lints/named_parameters_ordering/fixes/named_parameters_ordering_fix.dart';
 import 'package:solid_lints/src/lints/named_parameters_ordering/models/named_parameters_ordering_parameters.dart';
 import 'package:solid_lints/src/lints/named_parameters_ordering/models/parameter_type.dart';
 import 'package:solid_lints/src/lints/named_parameters_ordering/visitors/named_parameters_ordering_visitor.dart';
+import 'package:solid_lints/src/models/rule_with_fixes.dart';
 import 'package:solid_lints/src/models/solid_lint_rule.dart';
 
 /// A lint which allows to enforce a particular named parameter ordering
@@ -102,7 +104,8 @@ import 'package:solid_lints/src/models/solid_lint_rule.dart';
 /// }
 /// ```
 class NamedParametersOrderingRule
-    extends SolidLintRule<NamedParametersOrderingParameters> {
+    extends SolidLintRule<NamedParametersOrderingParameters>
+    implements RuleWithFixes {
   /// The name of this lint rule.
   static const lintName = 'named_parameters_ordering';
 
@@ -112,9 +115,6 @@ class NamedParametersOrderingRule
     '{0} named parameters should be before {1} named parameters.',
   );
 
-  @override
-  LintCode get diagnosticCode => code;
-
   /// Creates a new instance of [NamedParametersOrderingRule].
   NamedParametersOrderingRule({
     required super.analysisOptionsLoader,
@@ -126,6 +126,13 @@ class NamedParametersOrderingRule
          parametersParser: NamedParametersOrderingParameters.fromJson,
        );
 
+  @override
+  LintCode get diagnosticCode => code;
+
+  @override
+  Iterable<MapEntry<DiagnosticCode, ProducerGenerator>> get fixesForCodes =>
+      const [MapEntry(code, NamedParametersOrderingFix.new)];
+
   @override
   void registerNodeProcessors(
     RuleVisitorRegistry registry,

lib/src/lints/prefer_conditional_expressions/prefer_conditional_expressions_rule.dart

@@ -1,8 +1,10 @@
 import 'package:analyzer/analysis_rule/rule_context.dart';
 import 'package:analyzer/analysis_rule/rule_visitor_registry.dart';
 import 'package:analyzer/error/error.dart';
+import 'package:solid_lints/src/lints/prefer_conditional_expressions/fixes/prefer_conditional_expressions_fix.dart';
 import 'package:solid_lints/src/lints/prefer_conditional_expressions/models/prefer_conditional_expressions_parameters.dart';
 import 'package:solid_lints/src/lints/prefer_conditional_expressions/visitors/prefer_conditional_expressions_visitor.dart';
+import 'package:solid_lints/src/models/rule_with_fixes.dart';
 import 'package:solid_lints/src/models/solid_lint_rule.dart';
 
 // Inspired by TSLint (https://palantir.github.io/tslint/rules/prefer-conditional-expression/)
@@ -56,7 +58,8 @@ import 'package:solid_lints/src/models/solid_lint_rule.dart';
 /// }
 /// ```
 class PreferConditionalExpressionsRule
-    extends SolidLintRule<PreferConditionalExpressionsParameters> {
+    extends SolidLintRule<PreferConditionalExpressionsParameters>
+    implements RuleWithFixes {
   /// This lint rule represents the error when an if-else statement
   /// can be simplified to a conditional expression.
   static const lintName = 'prefer_conditional_expressions';
@@ -66,9 +69,6 @@ class PreferConditionalExpressionsRule
     'Prefer conditional expression.',
   );
 
-  @override
-  LintCode get diagnosticCode => _code;
-
   /// Creates a new instance of [PreferConditionalExpressionsRule]
   PreferConditionalExpressionsRule({
     required super.analysisOptionsLoader,
@@ -78,6 +78,13 @@ class PreferConditionalExpressionsRule
          parametersParser: PreferConditionalExpressionsParameters.fromJson,
        );
 
+  @override
+  LintCode get diagnosticCode => _code;
+
+  @override
+  Iterable<MapEntry<DiagnosticCode, ProducerGenerator>> get fixesForCodes =>
+      const [MapEntry(_code, PreferConditionalExpressionsFix.new)];
+
   @override
   void registerNodeProcessors(
     RuleVisitorRegistry registry,