support record and list patterns in prefer_final_locals (#4132)

* support record and list patterns in prefer_final_locals

* moar cases

* todo

* ++tests

Author: pq

lib/src/rules/prefer_final_locals.dart

@@ -3,6 +3,7 @@
 // BSD-style license that can be found in the LICENSE file.
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 
 import '../analyzer.dart';
@@ -67,6 +68,10 @@ class PreferFinalLocals extends LintRule {
   void registerNodeProcessors(
       NodeLintRegistry registry, LinterContext context) {
     var visitor = _Visitor(this);
+    registry.addListPattern(this, visitor);
+    registry.addMapPattern(this, visitor);
+    registry.addObjectPattern(this, visitor);
+    registry.addRecordPattern(this, visitor);
     registry.addVariableDeclarationList(this, visitor);
   }
 }
@@ -76,6 +81,101 @@ class _Visitor extends SimpleAstVisitor<void> {
 
   _Visitor(this.rule);
 
+  void checkPatternFields(DartPattern node) {
+    var function = node.thisOrAncestorOfType<FunctionBody>();
+    if (function == null) return;
+
+    late NodeList<PatternField> fields;
+    if (node is RecordPattern) fields = node.fields;
+    if (node is ObjectPattern) fields = node.fields;
+
+    var parent = node.unParenthesized.parent;
+    var inPatternVariableDeclaration = false;
+    if (parent is PatternVariableDeclaration) {
+      if (parent.keyword.keyword == Keyword.FINAL) return;
+      inPatternVariableDeclaration = true;
+    }
+
+    for (var field in fields) {
+      var pattern = field.pattern.declaredVariablePattern;
+      if (pattern is DeclaredVariablePattern) {
+        var element = pattern.declaredElement;
+        if (element == null) continue;
+        if (function.isPotentiallyMutatedInScope(element)) {
+          if (inPatternVariableDeclaration) {
+            return;
+          } else {
+            continue;
+          }
+        }
+        if (inPatternVariableDeclaration) {
+          rule.reportLint((parent! as PatternVariableDeclaration).expression);
+          return;
+        } else {
+          if (!pattern.keyword.isFinal) {
+            rule.reportLintForToken(pattern.name);
+          }
+        }
+      }
+    }
+  }
+
+  bool isDeclaredFinal(AstNode node) {
+    var declaration = node.thisOrAncestorOfType<PatternVariableDeclaration>();
+    if (declaration == null) return false; // To be safe.
+    return declaration.keyword.isFinal;
+  }
+
+  bool isPotentiallyMutated(AstNode pattern, FunctionBody function) {
+    if (pattern is DeclaredVariablePattern) {
+      var element = pattern.declaredElement;
+      if (element == null || function.isPotentiallyMutatedInScope(element)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  @override
+  void visitListPattern(ListPattern node) {
+    if (isDeclaredFinal(node)) return;
+
+    var function = node.thisOrAncestorOfType<FunctionBody>();
+    if (function == null) return;
+
+    for (var element in node.elements) {
+      if (isPotentiallyMutated(element, function)) return;
+    }
+
+    rule.reportLint(node);
+  }
+
+  @override
+  void visitMapPattern(MapPattern node) {
+    if (isDeclaredFinal(node)) return;
+
+    var function = node.thisOrAncestorOfType<FunctionBody>();
+    if (function == null) return;
+
+    for (var element in node.elements) {
+      if (element is MapPatternEntry) {
+        if (isPotentiallyMutated(element.value, function)) return;
+      }
+    }
+
+    rule.reportLint(node);
+  }
+
+  @override
+  void visitObjectPattern(ObjectPattern node) {
+    checkPatternFields(node);
+  }
+
+  @override
+  void visitRecordPattern(RecordPattern node) {
+    checkPatternFields(node);
+  }
+
   @override
   void visitVariableDeclarationList(VariableDeclarationList node) {
     if (node.isConst || node.isFinal) return;
@@ -100,3 +200,23 @@ class _Visitor extends SimpleAstVisitor<void> {
     }
   }
 }
+
+extension on Token? {
+  bool get isFinal {
+    var self = this;
+    if (self == null) return false;
+    return self.keyword == Keyword.FINAL;
+  }
+}
+
+extension on DartPattern {
+  DeclaredVariablePattern? get declaredVariablePattern {
+    var self = this;
+    if (self is DeclaredVariablePattern) return self;
+    // todo(pq): more cases?
+    if (self is LogicalAndPattern) {
+      return self.rightOperand.declaredVariablePattern;
+    }
+    return null;
+  }
+}

test/rules/all.dart

@@ -77,6 +77,7 @@ import 'prefer_constructors_over_static_methods_test.dart'
     as prefer_constructors_over_static_methods;
 import 'prefer_contains_test.dart' as prefer_contains;
 import 'prefer_final_fields_test.dart' as prefer_final_fields;
+import 'prefer_final_locals_test.dart' as prefer_final_locals;
 import 'prefer_final_parameters_test.dart' as prefer_final_parameters;
 import 'prefer_generic_function_type_aliases_test.dart'
     as prefer_generic_function_type_aliases;
@@ -169,6 +170,7 @@ void main() {
   prefer_constructors_over_static_methods.main();
   prefer_contains.main();
   prefer_final_fields.main();
+  prefer_final_locals.main();
   prefer_final_parameters.main();
   prefer_generic_function_type_aliases.main();
   prefer_relative_imports.main();