Migrate avoid_late_keyword rule (default behavior) and tests

lib/main.dart

@@ -1,5 +1,6 @@
 import 'package:analysis_server_plugin/plugin.dart';
 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_global_state/avoid_global_state_rule.dart';
 import 'package:solid_lints/src/lints/avoid_non_null_assertion/avoid_non_null_assertion_rule.dart';
@@ -23,21 +24,24 @@ class SolidLintsPlugin extends Plugin {
 
   @override
   void register(PluginRegistry registry) {
-    registry.registerLintRule(
+    final analysisLoader = AnalysisOptionsLoader();
+
+    final doubleLiteralFormatRule = DoubleLiteralFormatRule();
+    final lintRules = [
       AvoidGlobalStateRule(),
-    );
-    registry.registerLintRule(
       AvoidNonNullAssertionRule(),
-    );
-    registry.registerLintRule(
       AvoidDebugPrintInReleaseRule(),
-    );
-    registry.registerLintRule(
+      doubleLiteralFormatRule,
       ProperSuperCallsRule(),
-    );
+      // TODO: Add more lint rules and use analysisLoader
+      // for rules that need parameters
+      // For example: `CyclomaticComplexityRule(analysisLoader)`
+    ];
+
+    for (final lintRule in lintRules) {
+      registry.registerLintRule(lintRule);
+    }
 
-    final doubleLiteralFormatRule = DoubleLiteralFormatRule();
-    registry.registerLintRule(doubleLiteralFormatRule);
     for (final code in doubleLiteralFormatRule.diagnosticCodes) {
       registry.registerFixForRule(code, DoubleLiteralFormatFix.new);
     }

lib/src/common/parameter_parser/analysis_options_loader.dart

@@ -0,0 +1,109 @@
+import 'package:analyzer/analysis_rule/rule_context.dart';
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/file_system/physical_file_system.dart';
+import 'package:solid_lints/src/common/parameter_parser/cached_package_rules.dart';
+import 'package:yaml/yaml.dart';
+
+/// Loads and parses analysis options from a Dart project's YAML file.
+class AnalysisOptionsLoader {
+  final ResourceProvider _resourceProvider;
+  final Map<String, CachedPackageRules> _rulesCache = {};
+
+  /// Creates an instance of [AnalysisOptionsLoader]
+  AnalysisOptionsLoader({ResourceProvider? resourceProvider})
+      : _resourceProvider =
+            resourceProvider ?? PhysicalResourceProvider.INSTANCE;
+
+  /// Gets the options for a specific rule by its name.
+  Map<String, Object?>? getRuleOptions(RuleContext context, String ruleName) =>
+      _withNearestAnalysisOptionsFilePathForContext<Map<String, Object?>?>(
+        context,
+        (path) => _rulesCache[path]?.rules[ruleName],
+      );
+
+  /// Loads lint rules from the analysis options file for all rules
+  /// using the provided [RuleContext].
+  void loadRulesOptionsFromContext(RuleContext context) =>
+      _withNearestAnalysisOptionsFilePathForContext(
+        context,
+        _loadRulesOptionsIfNewer,
+      );
+
+  T? _withNearestAnalysisOptionsFilePathForContext<T>(
+    RuleContext context,
+    T Function(String) f,
+  ) {
+    final packageRootPath = context.package?.root.path;
+    if (packageRootPath == null) return null;
+
+    final yamlPath = _findNearestAnalysisOptionsFilePath(packageRootPath);
+    if (yamlPath == null) return null;
+
+    return f(yamlPath);
+  }
+
+  void _loadRulesOptionsIfNewer(String yamlPath) {
+    final analysisOptionsFile = _resourceProvider.getFile(yamlPath);
+    final modificationStamp = analysisOptionsFile.modificationStamp;
+    final cachedRules = _rulesCache[yamlPath];
+
+    if (cachedRules?.modificationStamp == modificationStamp) {
+      return;
+    }
+
+    final rules = _getRules(analysisOptionsFile);
+    _rulesCache[yamlPath] = CachedPackageRules(
+      modificationStamp: modificationStamp,
+      rules: rules,
+    );
+  }
+
+  String? _findNearestAnalysisOptionsFilePath(String packageRootPath) {
+    final pathContext = _resourceProvider.pathContext;
+    String currentDirectoryPath = packageRootPath;
+
+    while (pathContext.dirname(currentDirectoryPath) != currentDirectoryPath) {
+      final candidatePath =
+          pathContext.join(currentDirectoryPath, 'analysis_options.yaml');
+      final candidateFile = _resourceProvider.getFile(candidatePath);
+
+      if (candidateFile.exists) {
+        return candidatePath;
+      }
+
+      final parentDir = pathContext.dirname(currentDirectoryPath);
+      currentDirectoryPath = parentDir;
+    }
+
+    return null;
+  }
+
+  Map<String, Map<String, Object?>> _getRules(File? analysisOptionsFile) {
+    if (analysisOptionsFile == null || !analysisOptionsFile.exists) {
+      return {};
+    }
+
+    final optionsString = analysisOptionsFile.readAsStringSync();
+    Object? yaml;
+    try {
+      yaml = loadYaml(optionsString) as Object?;
+    } catch (err) {
+      return {};
+    }
+
+    if (yaml
+        case {'plugins': {'solid_lints': {'diagnostics': final diagnostics?}}}
+        when diagnostics is Map) {
+      return Map.fromEntries(
+        diagnostics.entries.where((e) => e.key is String && e.value is Map).map(
+              (e) => MapEntry(
+                e.key as String,
+                Map<String, Object?>.from(e.value as Map),
+              ),
+            ),
+      );
+    }
+
+    return {};
+  }
+}

lib/src/common/parameter_parser/cached_package_rules.dart

@@ -0,0 +1,14 @@
+/// Cached rules for a dart package
+class CachedPackageRules {
+  /// The last modification stamp of the analysis options file
+  final int modificationStamp;
+
+  /// Cached rules options by rule name for the package
+  final Map<String, Map<String, Object?>> rules;
+
+  /// Creates an instance of [CachedPackageRules]
+  const CachedPackageRules({
+    required this.modificationStamp,
+    required this.rules,
+  });
+}

lib/src/lints/avoid_late_keyword/avoid_late_keyword_rule.dart

@@ -1,10 +1,9 @@
-import 'package:analyzer/dart/ast/ast.dart';
-import 'package:analyzer/error/listener.dart';
-import 'package:custom_lint_builder/custom_lint_builder.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_late_keyword/models/avoid_late_keyword_parameters.dart';
-import 'package:solid_lints/src/models/rule_config.dart';
+import 'package:solid_lints/src/lints/avoid_late_keyword/visitors/avoid_late_keyword_visitor.dart';
 import 'package:solid_lints/src/models/solid_lint_rule.dart';
-import 'package:solid_lints/src/utils/types_utils.dart';
 
 /// Avoid `late` keyword
 ///
@@ -48,62 +47,37 @@ import 'package:solid_lints/src/utils/types_utils.dart';
 /// }
 /// ```
 class AvoidLateKeywordRule extends SolidLintRule<AvoidLateKeywordParameters> {
-  /// This lint rule represents
-  /// the error whether we use `late` keyword.
-  static const lintName = 'avoid_late_keyword';
+  static const String _lintName = 'avoid_late_keyword';
 
-  AvoidLateKeywordRule._(super.config);
+  static const LintCode _code = LintCode(
+    _lintName,
+    'Avoid using the "late" keyword. It may result in runtime exceptions.',
+  );
 
-  /// Creates a new instance of [AvoidLateKeywordRule]
-  /// based on the lint configuration.
-  factory AvoidLateKeywordRule.createRule(CustomLintConfigs configs) {
-    final rule = RuleConfig(
-      configs: configs,
-      name: lintName,
-      paramsParser: AvoidLateKeywordParameters.fromJson,
-      problemMessage: (_) => 'Avoid using the "late" keyword. '
-          'It may result in runtime exceptions.',
-    );
+  /// Creates an instance of [AvoidLateKeywordRule].
+  AvoidLateKeywordRule({required super.analysisOptionsLoader})
+      : super.withParameters(
+          name: _lintName,
+          description: 'Warns against using the late keyword.',
+          parametersParser: AvoidLateKeywordParameters.fromJson,
+        );
 
-    return AvoidLateKeywordRule._(rule);
-  }
+  @override
+  LintCode get diagnosticCode => _code;
 
   @override
-  void run(
-    CustomLintResolver resolver,
-    DiagnosticReporter reporter,
-    CustomLintContext context,
+  void registerNodeProcessors(
+    RuleVisitorRegistry registry,
+    RuleContext context,
   ) {
-    context.registry.addVariableDeclaration((node) {
-      if (_shouldLint(node)) {
-        reporter.atNode(node, code);
-      }
-    });
-  }
-
-  bool _shouldLint(VariableDeclaration node) {
-    final isLateDeclaration = node.isLate;
-    if (!isLateDeclaration) return false;
-
-    final hasIgnoredType = _hasIgnoredType(node);
-    if (hasIgnoredType) return false;
-
-    final allowInitialized = config.parameters.allowInitialized;
-    if (!allowInitialized) return true;
-
-    final hasInitializer = node.initializer != null;
-    return !hasInitializer;
-  }
-
-  bool _hasIgnoredType(VariableDeclaration node) {
-    final ignoredTypes = config.parameters.ignoredTypes.toSet();
-    if (ignoredTypes.isEmpty) return false;
+    final parameters =
+        getParametersForContext(context) ?? const AvoidLateKeywordParameters();
 
-    final variableType = node.declaredFragment?.element.type;
-    if (variableType == null) return false;
+    final visitor = AvoidLateKeywordVisitor(this, parameters);
 
-    return variableType.hasIgnoredType(
-      ignoredTypes: ignoredTypes,
+    registry.addVariableDeclaration(
+      this,
+      visitor,
     );
   }
 }

lib/src/lints/avoid_late_keyword/visitors/avoid_late_keyword_visitor.dart

@@ -0,0 +1,48 @@
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:solid_lints/src/lints/avoid_late_keyword/avoid_late_keyword_rule.dart';
+import 'package:solid_lints/src/lints/avoid_late_keyword/models/avoid_late_keyword_parameters.dart';
+import 'package:solid_lints/src/utils/types_utils.dart';
+
+/// Visitor for [AvoidLateKeywordRule].
+class AvoidLateKeywordVisitor extends SimpleAstVisitor<void> {
+  final AvoidLateKeywordRule _rule;
+
+  final AvoidLateKeywordParameters _parameters;
+
+  /// Creates an instance of [AvoidLateKeywordVisitor].
+  AvoidLateKeywordVisitor(this._rule, this._parameters);
+
+  @override
+  void visitVariableDeclaration(VariableDeclaration node) {
+    if (!_shouldReport(node)) return;
+
+    _rule.reportAtNode(node);
+  }
+
+  bool _shouldReport(VariableDeclaration node) {
+    final isLateDeclaration = node.isLate;
+    if (!isLateDeclaration) return false;
+
+    final hasIgnoredType = _hasIgnoredType(node);
+    if (hasIgnoredType) return false;
+
+    final allowInitialized = _parameters.allowInitialized;
+    if (!allowInitialized) return true;
+
+    final hasInitializer = node.initializer != null;
+    return !hasInitializer;
+  }
+
+  bool _hasIgnoredType(VariableDeclaration node) {
+    final ignoredTypes = _parameters.ignoredTypes.toSet();
+    if (ignoredTypes.isEmpty) return false;
+
+    final variableType = node.declaredFragment?.element.type;
+    if (variableType == null) return false;
+
+    return variableType.hasIgnoredType(
+      ignoredTypes: ignoredTypes,
+    );
+  }
+}