feat: handle cascade & null aware expressions

Author: andrew-bekhiet-solid

lib/src/lints/prefer_last/visitors/prefer_last_visitor.dart

@@ -7,6 +7,8 @@ import 'package:solid_lints/src/utils/types_utils.dart';
 /// The AST visitor that will collect all Iterable access expressions
 /// which can be replaced with .last
 class PreferLastVisitor extends RecursiveAstVisitor<void> {
+  static const _lengthGetterName = 'length';
+
   final PreferLastRule _rule;
 
   /// Creates a new instance of [PreferLastVisitor]
@@ -24,8 +26,7 @@ class PreferLastVisitor extends RecursiveAstVisitor<void> {
 
     final arg = node.argumentList.arguments.firstOrNull;
 
-    if (arg is BinaryExpression &&
-        _isLastElementAccess(arg, target.toString())) {
+    if (arg is BinaryExpression && _isLastElementAccess(arg, target)) {
       _rule.reportAtNode(node);
     }
   }
@@ -40,38 +41,72 @@ class PreferLastVisitor extends RecursiveAstVisitor<void> {
 
     final index = node.index;
 
-    if (index is BinaryExpression &&
-        _isLastElementAccess(index, target.toString())) {
+    if (index is BinaryExpression && _isLastElementAccess(index, target)) {
       _rule.reportAtNode(node);
     }
   }
 
-  bool _isLastElementAccess(BinaryExpression expression, String targetName) {
+  bool _isLastElementAccess(BinaryExpression expression, Expression? target) {
     final right = expression.rightOperand;
     if (right is! IntegerLiteral || right.value != 1) return false;
 
-    final isMinusExpression = expression.operator.type == TokenType.MINUS;
-    if (!isMinusExpression) return false;
+    if (expression.operator.type != TokenType.MINUS) return false;
+    if (target == null) return false;
 
-    final left = expression.leftOperand;
-    final leftName = _getLeftOperandName(left);
+    return _isLengthOfTarget(expression.leftOperand, target);
+  }
 
-    return leftName == '$targetName.length';
+  bool _isLengthOfTarget(Expression expression, Expression target) {
+    final lengthReceiver = switch (expression) {
+      PropertyAccess(
+        propertyName: SimpleIdentifier(name: _lengthGetterName),
+        operator: Token(type: TokenType.PERIOD),
+        :final target,
+      ) =>
+        target,
+      PrefixedIdentifier(
+        prefix: final prefix,
+        identifier: SimpleIdentifier(name: _lengthGetterName),
+      ) =>
+        prefix,
+      _ => null,
+    };
+
+    if (lengthReceiver == null) return false;
+
+    return _referencesSameTarget(lengthReceiver, target);
   }
 
-  String? _getLeftOperandName(Expression expression) {
-    if (expression is PrefixedIdentifier) {
-      return expression.name;
+  bool _referencesSameTarget(
+    Expression lengthReceiver,
+    Expression accessTarget,
+  ) {
+    final normalizedLengthReceiver = _unwrapExpression(lengthReceiver);
+    final normalizedAccessTarget = _unwrapExpression(accessTarget);
+
+    if (normalizedLengthReceiver is Identifier &&
+        normalizedAccessTarget is Identifier) {
+      return normalizedLengthReceiver.element?.id ==
+          normalizedAccessTarget.element?.id;
     }
 
-    /// Access target like map.keys.length is being reported as PropertyAccess
-    /// expression this case will handle such cases
-    if (expression is PropertyAccess) {
-      if (expression.operator.type != TokenType.PERIOD) return null;
+    return normalizedLengthReceiver.toString() ==
+        normalizedAccessTarget.toString();
+  }
+
+  Expression _unwrapExpression(Expression expression) {
+    switch (expression) {
+      case PostfixExpression(
+        :final operand,
+        operator: Token(type: TokenType.BANG),
+      ):
+        return _unwrapExpression(operand);
 
-      return expression.toString();
-    }
+      case ParenthesizedExpression(:final expression):
+        return _unwrapExpression(expression);
 
-    return null;
+      default:
+        return expression;
+    }
   }
 }

test/prefer_last/prefer_last_rule_test.dart

@@ -102,4 +102,47 @@ void main () {
       [lint(104, 39), lint(234, 29), lint(267, 39), lint(310, 43)],
     );
   }
+
+  void test_reports_on_cascade_element_at_access_with_length_minus_one() async {
+    await assertDiagnostics(
+      r'''
+void main () {
+  final list2 = [1, 0, 2, 3];
+  list2..elementAt(list2.length - 1);
+}
+''',
+      [lint(52, 29)],
+    );
+  }
+
+  void test_reports_on_null_aware_index_access_with_length_minus_one() async {
+    await assertDiagnostics(
+      r'''
+List<int>? list1 = [0, 1, 2, 3];
+var a = list1?[list1!.length - 1];
+
+void test(List<int>? list2) {
+  list1?[list1!.length - 1];
+  list2?[list2.length - 1];
+}
+''',
+      [lint(41, 25), lint(101, 25), lint(130, 24)],
+    );
+  }
+
+  void
+  test_reports_on_null_aware_element_at_access_with_length_minus_one() async {
+    await assertDiagnostics(
+      r'''
+List<int>? list1 = [0, 1, 2, 3];
+var a = list1?.elementAt(list1!.length - 1);
+
+void test(List<int>? list2) {
+  list1?.elementAt(list1!.length - 1);
+  list2?.elementAt(list2.length - 1);
+}
+''',
+      [lint(41, 35), lint(111, 35), lint(150, 34)],
+    );
+  }
 }