declared variable pattern support for unnecessary_final

lib/src/rules/unnecessary_final.dart

@@ -71,6 +71,7 @@ class UnnecessaryFinal extends LintRule {
     registry
       ..addFormalParameterList(this, visitor)
       ..addForStatement(this, visitor)
+      ..addDeclaredVariablePattern(this, visitor)
       ..addVariableDeclarationStatement(this, visitor);
   }
 }
@@ -80,18 +81,29 @@ class _Visitor extends SimpleAstVisitor<void> {
 
   _Visitor(this.rule);
 
+  LintCode getErrorCode(Object? type) =>
+      type == null ? UnnecessaryFinal.withoutType : UnnecessaryFinal.withType;
+
+  @override
+  void visitDeclaredVariablePattern(DeclaredVariablePattern node) {
+    var keyword = node.keyword;
+    keyword ??=
+        node.thisOrAncestorOfType<PatternVariableDeclaration>()?.keyword;
+    if (keyword == null) return;
+
+    var errorCode = getErrorCode(node.matchedValueType);
+    rule.reportLintForToken(keyword, errorCode: errorCode);
+  }
+
   @override
   void visitFormalParameterList(FormalParameterList parameterList) {
     for (var node in parameterList.parameters) {
       if (node.isFinal) {
         var keyword = _getFinal(node);
-        if (keyword == null) {
-          continue;
-        }
+        if (keyword == null) continue;
+
         var type = _getType(node);
-        var errorCode = type == null
-            ? UnnecessaryFinal.withoutType
-            : UnnecessaryFinal.withType;
+        var errorCode = getErrorCode(type);
         rule.reportLintForToken(keyword, errorCode: errorCode);
       }
     }
@@ -106,11 +118,8 @@ class _Visitor extends SimpleAstVisitor<void> {
     // loop. `a` is a variable declared outside the loop.
     if (forLoopParts is ForEachPartsWithDeclaration) {
       var loopVariable = forLoopParts.loopVariable;
-
       if (loopVariable.isFinal) {
-        var errorCode = loopVariable.type == null
-            ? UnnecessaryFinal.withoutType
-            : UnnecessaryFinal.withType;
+        var errorCode = getErrorCode(loopVariable.type);
         rule.reportLintForToken(loopVariable.keyword, errorCode: errorCode);
       }
     }
@@ -119,9 +128,7 @@ class _Visitor extends SimpleAstVisitor<void> {
   @override
   void visitVariableDeclarationStatement(VariableDeclarationStatement node) {
     if (node.variables.isFinal) {
-      var errorCode = node.variables.type == null
-          ? UnnecessaryFinal.withoutType
-          : UnnecessaryFinal.withType;
+      var errorCode = getErrorCode(node.variables.type);
       rule.reportLintForToken(node.variables.keyword, errorCode: errorCode);
     }
   }

test/rules/all.dart

@@ -101,6 +101,7 @@ import 'unnecessary_brace_in_string_interps_test.dart'
     as unnecessary_brace_in_string_interps;
 import 'unnecessary_breaks_test.dart' as unnecessary_breaks;
 import 'unnecessary_const_test.dart' as unnecessary_const;
+import 'unnecessary_final_test.dart' as unnecessary_final;
 import 'unnecessary_lambdas_test.dart' as unnecessary_lambdas;
 import 'unnecessary_library_directive_test.dart'
     as unnecessary_library_directive;
@@ -194,6 +195,7 @@ void main() {
   unnecessary_brace_in_string_interps.main();
   unnecessary_breaks.main();
   unnecessary_const.main();
+  unnecessary_final.main();
   unnecessary_lambdas.main();
   unnecessary_library_directive.main();
   unnecessary_null_checks.main();

test/rules/unnecessary_final_test.dart

@@ -0,0 +1,72 @@
+// Copyright (c) 2023, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../rule_test_support.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(UnnecessaryFinalTestLanguage300);
+  });
+}
+
+@reflectiveTest
+class UnnecessaryFinalTestLanguage300 extends LintRuleTest
+    with LanguageVersion300Mixin {
+  @override
+  String get lintRule => 'unnecessary_final';
+
+  test_listPattern_destructured() async {
+    await assertDiagnostics(r'''
+f() {
+  final [a] = [1];
+  print('$a');
+}
+''', [
+      lint(8, 5),
+    ]);
+  }
+
+  test_mapPattern_destructured() async {
+    await assertDiagnostics(r'''
+f() {
+  final {'a': a} = {'a': 1};
+  print('$a');
+}
+''', [
+      lint(8, 5),
+    ]);
+  }
+
+  test_objectPattern_switch() async {
+    await assertDiagnostics(r'''
+class A {
+  int a;
+  A(this.a);
+}
+
+f() {
+  switch (A(1)) {
+    case A(a: >0 && final b): print('$b');
+  }
+}
+''', [
+      lint(79, 5),
+    ]);
+  }
+
+  test_recordPattern_switch() async {
+    await assertDiagnostics(r'''
+f() {
+  switch ((1, 2)) {
+    case (final a, final b): print('$a$b');
+  }
+}
+''', [
+      lint(36, 5),
+      lint(45, 5),
+    ]);
+  }
+}