Migrate newline before return rule and its tests

lib/src/lints/newline_before_return/newline_before_return_rule.dart

@@ -21,11 +21,11 @@
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 // SOFTWARE.
 
-import 'package:analyzer/error/listener.dart';
-import 'package:custom_lint_builder/custom_lint_builder.dart';
+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/newline_before_return/visitors/newline_before_return_visitor.dart';
-import 'package:solid_lints/src/models/rule_config.dart';
-import 'package:solid_lints/src/models/solid_lint_rule.dart';
 
 // Inspired by ESLint (https://eslint.org/docs/rules/newline-before-return)
 
@@ -72,38 +72,35 @@ import 'package:solid_lints/src/models/solid_lint_rule.dart';
 ///   }
 /// }
 /// ```
-class NewlineBeforeReturnRule extends SolidLintRule {
-  /// This lint rule represents the error if
-  /// newline is missing before return statement
-  static const String lintName = 'newline_before_return';
+class NewlineBeforeReturnRule extends AnalysisRule {
+  /// The name of the lint rule.
+  static const String _lintName = 'newline_before_return';
 
-  NewlineBeforeReturnRule._(super.config);
+  /// The message shown when the lint is triggered.
+  static const String _lintMessage = 'Missing blank line before return.';
 
-  /// Creates a new instance of [NewlineBeforeReturnRule]
-  /// based on the lint configuration.
-  factory NewlineBeforeReturnRule.createRule(CustomLintConfigs configs) {
-    final rule = RuleConfig(
-      configs: configs,
-      name: lintName,
-      problemMessage: (value) => "Missing blank line before return.",
-    );
+  /// Lint code for this rule.
+  static const LintCode _code = LintCode(
+    _lintName,
+    _lintMessage,
+  );
 
-    return NewlineBeforeReturnRule._(rule);
-  }
+  /// Creates a new instance of [NewlineBeforeReturnRule].
+  NewlineBeforeReturnRule()
+    : super(
+        name: _lintName,
+        description: _lintMessage,
+      );
 
   @override
-  void run(
-    CustomLintResolver resolver,
-    DiagnosticReporter reporter,
-    CustomLintContext context,
-  ) {
-    context.registry.addReturnStatement((node) {
-      final visitor = NewLineBeforeReturnVisitor(resolver.lineInfo);
-      visitor.visitReturnStatement(node);
+  LintCode get diagnosticCode => _code;
 
-      for (final element in visitor.statements) {
-        reporter.atNode(element, code);
-      }
-    });
+  @override
+  void registerNodeProcessors(
+    RuleVisitorRegistry registry,
+    RuleContext context,
+  ) {
+    final visitor = NewLineBeforeReturnVisitor(this);
+    registry.addReturnStatement(this, visitor);
   }
 }

lib/src/lints/newline_before_return/visitors/newline_before_return_visitor.dart

@@ -25,27 +25,24 @@ import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/source/line_info.dart';
+import 'package:solid_lints/src/lints/newline_before_return/newline_before_return_rule.dart';
 
-/// The AST visitor that will all return statements.
-class NewLineBeforeReturnVisitor extends RecursiveAstVisitor<void> {
-  final LineInfo _lineInfo;
-  final _statements = <ReturnStatement>[];
+/// Visitor for [NewlineBeforeReturnRule].
+class NewLineBeforeReturnVisitor extends SimpleAstVisitor<void> {
+  final NewlineBeforeReturnRule _rule;
 
   /// Creates instance of [NewLineBeforeReturnVisitor] with line info
-  NewLineBeforeReturnVisitor(this._lineInfo);
-
-  /// List of all return statements
-  Iterable<ReturnStatement> get statements => _statements;
+  NewLineBeforeReturnVisitor(this._rule);
 
   @override
   void visitReturnStatement(ReturnStatement node) {
     super.visitReturnStatement(node);
 
     if (!_statementIsInBlock(node)) return;
     if (_statementIsFirstInBlock(node)) return;
-    if (_statementHasNewLineBefore(node, _lineInfo)) return;
+    if (_statementHasNewLineBefore(node)) return;
 
-    _statements.add(node);
+    _rule.reportAtNode(node);
   }
 
   static bool _statementIsInBlock(ReturnStatement node) => node.parent is Block;
@@ -55,12 +52,18 @@ class NewLineBeforeReturnVisitor extends RecursiveAstVisitor<void> {
 
   static bool _statementHasNewLineBefore(
     ReturnStatement node,
-    LineInfo lineInfo,
   ) {
+    final root = node.root;
+    if (root is! CompilationUnit) return true;
+
+    final lineInfo = root.lineInfo;
+    final previousToken = node.returnKeyword.previous;
+
+    if (previousToken == null) return true;
+
     final previousTokenLineNumber = lineInfo
-        .getLocation(node.returnKeyword.previous!.end)
+        .getLocation(previousToken.end)
         .lineNumber;
-
     final lastNotEmptyLineToken = _optimalToken(node.returnKeyword, lineInfo);
     final tokenLineNumber = lineInfo
         .getLocation(lastNotEmptyLineToken.offset)

test/lints/newline_before_return/newline_before_return_rule_test.dart

@@ -0,0 +1,171 @@
+import 'package:analyzer_testing/analysis_rule/analysis_rule.dart';
+import 'package:solid_lints/src/lints/newline_before_return/newline_before_return_rule.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+void main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(NewlineBeforeReturnRuleTest);
+  });
+}
+
+@reflectiveTest
+class NewlineBeforeReturnRuleTest extends AnalysisRuleTest {
+  @override
+  void setUp() {
+    rule = NewlineBeforeReturnRule();
+    super.setUp();
+  }
+
+  @override
+  String get analysisRule => rule.name;
+
+  void test_reports_no_newline_before_return_value() async {
+    await assertDiagnostics(
+      r'''
+int method() {
+  final a = 0;
+  return 1;
+}
+  ''',
+      [lint(32, 9)],
+    );
+  }
+
+  void test_reports_no_newline_before_return() async {
+    await assertDiagnostics(
+      r'''
+void method() {
+  final a = 0;
+  return;
+}
+  ''',
+      [lint(33, 7)],
+    );
+  }
+
+  void test_reports_no_newline_before_return_with_comment() async {
+    await assertDiagnostics(
+      r'''
+void method() {
+  final a = 0;
+  // Comment
+  return;
+}
+  ''',
+      [lint(46, 7)],
+    );
+  }
+
+  void test_reports_no_newline_before_return_with_multiple_comments() async {
+    await assertDiagnostics(
+      r'''
+void method() {
+  final a = 0;
+  // Comment 1
+  // Comment 2
+  return;
+}
+  ''',
+      [lint(63, 7)],
+    );
+  }
+
+  void test_does_not_report_newline_before_return_with_comment() async {
+    await assertNoDiagnostics(r'''
+void method() {
+  final a = 0;
+
+  // Comment
+  return;
+}
+  ''');
+  }
+
+  void test_does_not_report_no_newline_before_single_statement_return() async {
+    await assertNoDiagnostics(r'''
+void method() {
+  return;
+}
+  ''');
+  }
+
+  void test_does_not_report_newline_before_return() async {
+    await assertNoDiagnostics(r'''
+void method() {
+  final a = 0;
+
+  return;
+}
+  ''');
+  }
+
+  void
+  test_does_not_report_no_newline_before_single_statement_return_value() async {
+    await assertNoDiagnostics(r'''
+int method() {
+  return 1;
+}
+  ''');
+  }
+
+  void
+  test_does_not_report_no_newline_before_single_statement_nested_return() async {
+    await assertNoDiagnostics(r'''
+class Foo{
+  void bar(void Function()) {
+    return;
+  }
+}
+
+void fun() {
+  final foo = Foo();
+  foo.bar(() {
+    return;
+  });
+}
+  ''');
+  }
+
+  void test_reports_no_newline_before_return_nested() async {
+    await assertDiagnostics(
+      r'''
+class Foo{
+  void bar(void Function()) {
+    return;
+  }
+}
+
+void fun() {
+  final foo = Foo();
+  foo.bar(() {
+    final a = 1;
+    return;
+  });
+}
+  ''',
+      [lint(130, 7)],
+    );
+  }
+
+  void test_reports_no_newline_before_two_return_nested() async {
+    await assertDiagnostics(
+      r'''
+class Foo{
+  void bar(void Function()) {
+    return;
+  }
+}
+
+void fun() {
+  final foo = Foo();
+  foo.bar(() {
+    final a = 1;
+    return;
+  });
+  return;
+}
+  ''',
+      [lint(130, 7), lint(146, 7)],
+    );
+  }
+}