Address PR suggestions

Author: daria-trusca-solid

lib/src/lints/avoid_unnecessary_return_variable/avoid_unnecessary_return_variable_rule.dart

@@ -31,25 +31,25 @@ import 'package:solid_lints/src/lints/avoid_unnecessary_return_variable/visitors
 ///
 class AvoidUnnecessaryReturnVariableRule extends AnalysisRule {
   /// The name of the lint rule.
-  static const lintName = 'avoid_unnecessary_return_variable';
+  static const _lintName = 'avoid_unnecessary_return_variable';
 
   /// The message shown when the lint is triggered.
-  static const String lintMessage = """
+  static const String _lintMessage = """
 Avoid creating unnecessary variable only for return.
 Rewrite the variable evaluation into return statement instead.""";
 
   /// Lint code.
   static const LintCode _code = LintCode(
-    lintName,
-    lintMessage,
+    _lintName,
+    _lintMessage,
   );
 
   /// Creates a new instance of [AvoidUnnecessaryReturnVariableRule]
   AvoidUnnecessaryReturnVariableRule()
-      : super(
-          name: lintName,
-          description: lintMessage,
-        );
+    : super(
+        name: _lintName,
+        description: _lintMessage,
+      );
 
   @override
   LintCode get diagnosticCode => _code;

lib/src/lints/avoid_unnecessary_return_variable/visitors/avoid_unnecessary_return_variable_visitor.dart

@@ -16,27 +16,23 @@ class AvoidUnnecessaryReturnVariableVisitor extends SimpleAstVisitor<void> {
   @override
   void visitReturnStatement(ReturnStatement node) {
     final expr = node.expression;
-    if (expr is! SimpleIdentifier) {
-      return;
-    }
+    if (expr is! SimpleIdentifier) return;
 
     final element = expr.element;
-    if (element is! LocalVariableElement) {
-      return;
-    }
+    if (element is! LocalVariableElement) return;
 
-    if (!element.isFinal && !element.isConst) {
-      return;
-    }
+    if (!element.isFinal && !element.isConst) return;
 
     final block = node.parent;
     if (block == null) return;
 
-    final returnVariableUsageVisitor =
-        ReturnVariableUsageVisitor(node, element);
+    final returnVariableUsageVisitor = ReturnVariableUsageVisitor(
+      node,
+      element,
+    );
 
     block.visitChildren(returnVariableUsageVisitor);
-    if (!returnVariableUsageVisitor.hasBadStatementCount()) return;
+    if (!returnVariableUsageVisitor.hasBadStatementCount) return;
 
     //it is 100% bad if return statement follows declaration
     if (!returnVariableUsageVisitor.foundTokensBetweenDeclarationAndReturn) {
@@ -63,17 +59,12 @@ class AvoidUnnecessaryReturnVariableVisitor extends SimpleAstVisitor<void> {
   }
 
   bool _isSimpleIdentifierImmutable(SimpleIdentifier identifier) {
-    switch (identifier.element) {
-      case final VariableElement variable:
-        return variable.isFinal || variable.isConst;
-
-      case ClassElement _:
-        return true;
-
-      case GetterElement(:final PropertyInducingElement variable):
-        return variable.isFinal || variable.isConst;
-    }
-
-    return false;
+    return switch (identifier.element) {
+      ClassElement _ => true,
+      final VariableElement variable => variable.isFinal || variable.isConst,
+      GetterElement(:final PropertyInducingElement variable) =>
+        variable.isFinal || variable.isConst,
+      _ => false,
+    };
   }
 }

lib/src/lints/avoid_unnecessary_return_variable/visitors/return_variable_usage_visitor.dart

@@ -8,6 +8,12 @@ import 'package:solid_lints/src/lints/avoid_unnecessary_return_variable/avoid_un
 /// return variable is used somewhere except return statement and
 /// whether it is immutable.
 class ReturnVariableUsageVisitor extends RecursiveAstVisitor<void> {
+  /// The problem expects that exactly 1 mention of return variable.
+  /// VariableDeclarationStatement doesn't count when visiting SimpleIdentifier.
+  /// Any other amount of variable mentions implies that it is used somewhere
+  /// except return, so its existence is justified.
+  static const _badStatementCount = 1;
+
   final ReturnStatement _returnStatement;
   final LocalVariableElement _returnVariableElement;
 
@@ -17,16 +23,10 @@ class ReturnVariableUsageVisitor extends RecursiveAstVisitor<void> {
   /// After visiting holds info about whether there are any tokens
   bool foundTokensBetweenDeclarationAndReturn = false;
 
-  /// The problem expects that exactly 1 mention of return variable.
-  /// VariableDeclarationStatement doesn't count when visiting SimpleIdentifier.
-  /// Any other amount of variable mentions implies that it is used somewhere
-  /// except return, so its existence is justified.
-  static const _badStatementCount = 1;
-
   int _variableStatementCounter = 0;
 
   /// Defines whether the variables is used in return statement only.
-  bool hasBadStatementCount() =>
+  bool get hasBadStatementCount =>
       _variableStatementCounter == _badStatementCount;
 
   /// Creates a new instance of [ReturnVariableUsageVisitor].
@@ -66,8 +66,9 @@ class ReturnVariableUsageVisitor extends RecursiveAstVisitor<void> {
     VariableDeclarationStatement variableDeclaration,
     ReturnStatement returnStatement,
   ) {
-    final tokenBeforeReturn =
-        _returnStatement.findPrevious(_returnStatement.beginToken);
+    final tokenBeforeReturn = _returnStatement.findPrevious(
+      _returnStatement.beginToken,
+    );
 
     if (tokenBeforeReturn != variableDeclaration.endToken) {
       foundTokensBetweenDeclarationAndReturn = true;

pubspec.yaml

@@ -8,7 +8,7 @@ documentation: https://solid-software.github.io/solid_lints/docs/intro
 topics: [lints, linter, lint, analysis, analyzer]
 
 environment:
-  sdk: ">=3.5.0 <4.0.0"
+  sdk: ">=3.9.0 <4.0.0"
 
 dependencies:
   analyzer: ^10.0.1

test/lints/avoid_unnecessary_return_variable/avoid_unnecessary_return_variable_rule_test.dart

@@ -17,44 +17,37 @@ class AvoidUnnecessaryReturnVariableTest extends AnalysisRuleTest {
   }
 
   @override
-  String get analysisRule => AvoidUnnecessaryReturnVariableRule.lintName;
+  String get analysisRule => rule.name;
 
   void test_does_not_report_if_return_good_trivial() async {
-    await assertNoDiagnostics(
-      r'''
+    await assertNoDiagnostics(r'''
 int returnVarTestTrivial() {
   return 1;
 }
-  ''',
-    );
+  ''');
   }
 
   void test_does_not_report_if_return_is_mutable() async {
-    await assertNoDiagnostics(
-      r'''
+    await assertNoDiagnostics(r'''
 int returnVarTestMutable() {
   var a = 1;
   a++;
 
   return a;
 }
-  ''',
-    );
+  ''');
   }
 
   void test_does_not_report_if_returns_parameter() async {
-    await assertNoDiagnostics(
-      r'''
+    await assertNoDiagnostics(r'''
 int returnVarTestReturnParameter(int param) {
   return param;
 }
-  ''',
-    );
+  ''');
   }
 
   void test_does_not_report_if_return_is_cached_mutable() async {
-    await assertNoDiagnostics(
-      r'''
+    await assertNoDiagnostics(r'''
 int returnVarTestCachedMutable() {
   var a = 1;
   final result = a;
@@ -64,12 +57,12 @@ int returnVarTestCachedMutable() {
 }
 
 void _doNothing() {}
-  ''',
-    );
+  ''');
   }
 
   void test_reports_if_return_follows_declaration() async {
-    await assertDiagnostics(r'''
+    await assertDiagnostics(
+      r'''
 int returnVarTestReturnFollowsDeclaration() {
   var a = 1;
   final result = a;
@@ -78,12 +71,13 @@ int returnVarTestReturnFollowsDeclaration() {
 
   return result;
 }
-  ''', [lint(105, 14)]);
+  ''',
+      [lint(105, 14)],
+    );
   }
 
   void test_does_not_report_if_return_is_cached_another_method_result() async {
-    await assertNoDiagnostics(
-      r'''
+    await assertNoDiagnostics(r'''
 int returnVarTestCachedAnotherMethodResult() {
   var a = 1;
   final result = _testValueEval();
@@ -97,13 +91,11 @@ int _testValueEval() {
 }
 
 void _doNothing() {}
-''',
-    );
+''');
   }
 
   void test_does_not_report_if_return_is_cached_object_field() async {
-    await assertNoDiagnostics(
-      r'''
+    await assertNoDiagnostics(r'''
 int returnVarTestCachedObjectField() {
   final obj = _TestClass();
   final result = obj.varField;
@@ -121,36 +113,37 @@ class _TestClass {
 }
 
 void _doNothing() {}
-''',
-    );
+''');
   }
 
   void test_does_not_report_if_return_used_variable() async {
-    await assertNoDiagnostics(
-      r'''
+    await assertNoDiagnostics(r'''
 int returnVarTestUsedVariable() {
   var a = 1;
   final result = 2;
   a += result;
 
   return result;
 }
-''',
-    );
+''');
   }
 
   void test_reports_if_return_is_bad_trivial() async {
-    await assertDiagnostics(r'''
+    await assertDiagnostics(
+      r'''
 int returnVarTestBadTrivial() {
   final result = 1;
 
   return result;
 }
-''', [lint(55, 14)]);
+''',
+      [lint(55, 14)],
+    );
   }
 
   void test_reports_if_return_is_bad_immutable_expression() async {
-    await assertDiagnostics(r'''
+    await assertDiagnostics(
+      r'''
 int returnVarTestBadImmutableExpression() {
   const constLocal = 1;
   final finalLocal = 1;
@@ -175,6 +168,8 @@ class _TestClass {
 }
 
 void _doNothing() {}
-''', [lint(304, 14)]);
+''',
+      [lint(304, 14)],
+    );
   }
 }