Issue #92, new rule dont_create_a_return_var:

- added rule class (no rule implementation)
- added test cases

Author: tozpeak

lib/solid_lints.dart

@@ -14,6 +14,7 @@ import 'package:solid_lints/src/lints/avoid_unrelated_type_assertions/avoid_unre
 import 'package:solid_lints/src/lints/avoid_unused_parameters/avoid_unused_parameters_rule.dart';
 import 'package:solid_lints/src/lints/avoid_using_api/avoid_using_api_rule.dart';
 import 'package:solid_lints/src/lints/cyclomatic_complexity/cyclomatic_complexity_rule.dart';
+import 'package:solid_lints/src/lints/dont_create_a_return_var/dont_create_a_return_var_rule.dart';
 import 'package:solid_lints/src/lints/double_literal_format/double_literal_format_rule.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';
@@ -67,6 +68,7 @@ class _SolidLints extends PluginBase {
       PreferEarlyReturnRule.createRule(configs),
       AvoidFinalWithGetterRule.createRule(configs),
       NamedParametersOrderingRule.createRule(configs),
+      DontCreateAReturnVarRule.createRule(configs),
     ];
 
     // Return only enabled rules

lib/src/lints/dont_create_a_return_var/dont_create_a_return_var_rule.dart

@@ -0,0 +1,62 @@
+import 'package:analyzer/error/listener.dart';
+import 'package:custom_lint_builder/custom_lint_builder.dart';
+import 'package:solid_lints/src/models/rule_config.dart';
+import 'package:solid_lints/src/models/solid_lint_rule.dart';
+
+/// A `dont_create_a_return_var` rule which forbids returning an immutable
+/// variable if it can be rewritten in return statement itself.
+///
+/// See more here: https://github.com/solid-software/solid_lints/issues/92
+///
+/// ### Example
+///
+/// #### BAD:
+/// 
+/// ```dart
+/// void x() {
+///   final y = 1;
+/// 
+///   return y;
+/// }
+/// ```
+/// 
+/// #### GOOD:
+/// 
+/// ```dart
+/// void x() {
+///   return 1;
+/// }
+/// ```
+///
+class DontCreateAReturnVarRule extends SolidLintRule {
+  /// This lint rule represents the error
+  /// when unnecessary return variable statement is found
+  static const lintName = 'dont_create_a_return_var';
+  
+  DontCreateAReturnVarRule._(super.config);
+
+  /// Creates a new instance of [DontCreateAReturnVarRule]
+  /// based on the lint configuration.
+  factory DontCreateAReturnVarRule.createRule(CustomLintConfigs configs) {
+    final rule = RuleConfig(
+      configs: configs,
+      name: lintName,
+      problemMessage: (_) => """
+Avoid creating unnecessary variable only for return.
+Rewrite the variable evaluation into return statement instead.""",
+    );
+
+    return DontCreateAReturnVarRule._(rule);
+  }
+
+
+  @override
+  void run(
+    CustomLintResolver resolver,
+    ErrorReporter reporter,
+    CustomLintContext context,
+  ) {
+    // TODO: implement run
+  }
+  
+}

lint_test/dont_create_a_return_var_test.dart

@@ -0,0 +1,110 @@
+// ignore_for_file: unused_local_variable
+
+/// Test the dont_create_a_return_var.
+/// Good code, trivial case.
+int returnVarTestGoodTrivial() {
+  return 1;
+}
+
+/// Test the dont_create_a_return_var.
+/// Returning mutable variable should not trigger the lint.
+int returnVarTestReturnMutable() {
+  var a = 1;
+  a++;
+
+  return a;
+}
+
+/// Test the dont_create_a_return_var.
+/// Caching mutable variable value.
+/// Unpredictable: may be useful to cache value
+/// before operation can change it.
+int returnVarTestCachedMutable() {
+  var a = 1;
+  final result = a;
+  _doNothing();
+  
+  return result;
+}
+
+/// Test the dont_create_a_return_var.
+/// Caching another method result.
+/// Unpredictable: may be useful to cache value
+/// before operation can change it.
+int returnVarTestCachedAnotherMethodResult() {
+  var a = 1;
+  final result = _testValueEval();
+  _doNothing();
+  
+  return result;
+}
+
+/// Test the dont_create_a_return_var.
+/// Caching value of object's field.
+/// Unpredictable: may be useful to cache value
+/// before operation can change it.
+int returnVarTestCachedObjectField() {
+  final obj = _TestClass();
+  final result = obj.varField;
+  _doNothing();
+  
+  return result;
+}
+
+/// Test the dont_create_a_return_var.
+/// Good: variable is created not only for return
+/// but is used in following expressions as well.
+int returnVarTestUsedVariable() {
+  var a = 1;
+  final result = 2;
+  a += result;
+  
+  return result;
+}
+
+/// Test the dont_create_a_return_var.
+/// Bad code, trivial example.
+int returnVarTestBadTrivial() {
+  final result = 1;
+  
+  //expect_lint: dont_create_a_return_var
+  return result;
+}
+
+/// Test the dont_create_a_return_var.
+/// Bad code: result expression is immutable,
+/// so can be written in return statement directly.
+int returnVarTestBadImmutableExpression() {
+  const constLocal = 1;
+  final finalLocal = 1;
+  final testObj = _TestClass();
+  final result =
+    constLocal
+    + finalLocal
+    + 1 //const literal
+    + _TestClass.constValue
+    + _TestClass.finalValue
+    + testObj.finalField;
+  _doNothing();
+  
+  //expect_lint: dont_create_a_return_var
+  return result;
+}
+
+int _testValueEval() {
+  return 1;
+}
+
+/// This method is a placeholder for unpredictable behaviour
+/// which can potentially change any mutable variables
+//ignore: no_empty_block
+void _doNothing() { }
+
+//ignore: prefer_match_file_name
+class _TestClass {
+  static const constValue = 1;
+  static final finalValue = 1;
+  //ignore: member_ordering
+  final finalField = 1;
+  var varField = 1;
+}