[wildcards] support for prefer_final_locals

Fixes: https://github.com/dart-lang/linter/issues/5042

Change-Id: Icda56e0c8d9c5e0a55a3728311db5e7e3825fa57
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/378573
Reviewed-by: Brian Wilkerson <[email protected]>
Commit-Queue: Phil Quitslund <[email protected]>

Author: pq

pkg/linter/lib/src/rules/prefer_final_locals.dart

@@ -5,6 +5,7 @@
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/extensions.dart'; // ignore: implementation_imports
 
 import '../analyzer.dart';
 import '../extensions.dart';
@@ -151,6 +152,7 @@ class _Visitor extends SimpleAstVisitor<void> {
       }
     } else {
       if (!node.hasPotentiallyMutatedDeclaredVariableInScope(function)) {
+        if (node.pattern.containsJustWildcards) return;
         rule.reportLintForToken(node.keyword);
       }
     }
@@ -169,7 +171,8 @@ class _Visitor extends SimpleAstVisitor<void> {
       }
       var declaredElement = variable.declaredElement;
       if (declaredElement != null &&
-          function.isPotentiallyMutatedInScope(declaredElement)) {
+          (declaredElement.isWildcardVariable ||
+              function.isPotentiallyMutatedInScope(declaredElement))) {
         return;
       }
     }
@@ -181,6 +184,25 @@ class _Visitor extends SimpleAstVisitor<void> {
   }
 }
 
+extension on DartPattern {
+  bool get containsJustWildcards {
+    var pattern = this;
+    return switch (pattern) {
+      ListPattern() => pattern.elements
+          .every((e) => e is DartPattern && e.containsJustWildcards),
+      MapPattern() => pattern.elements
+          .every((e) => e is MapPatternEntry && e.value is WildcardPattern),
+      ObjectPattern() =>
+        pattern.fields.every((e) => e.pattern.containsJustWildcards),
+      ParenthesizedPattern() => pattern.pattern.containsJustWildcards,
+      RecordPattern() =>
+        pattern.fields.every((e) => e.pattern.containsJustWildcards),
+      WildcardPattern() => true,
+      _ => false,
+    };
+  }
+}
+
 extension on AstNode {
   bool get isDeclaredFinal {
     var self = this;

pkg/linter/test/rules/prefer_final_locals_test.dart

@@ -44,6 +44,42 @@ f() {
 ''');
   }
 
+  test_destructured_listPattern_wildcard() async {
+    await assertDiagnostics(r'''
+f() {
+  var [_, b] = ['a', 'b'];
+}
+''', [
+      lint(8, 3),
+    ]);
+  }
+
+  test_destructured_listPattern_wildcard_parenthesized() async {
+    await assertDiagnostics(r'''
+f() {
+  var [(_), b] = ['a', 'b'];
+}
+''', [
+      lint(8, 3),
+    ]);
+  }
+
+  test_destructured_listPattern_wildcard_single() async {
+    await assertNoDiagnostics(r'''
+f() {
+  var [_] = ['a'];
+}
+''');
+  }
+
+  test_destructured_listPattern_wildcard_single_parenthesized() async {
+    await assertNoDiagnostics(r'''
+f() {
+  var [(_)] = ['a'];
+}
+''');
+  }
+
   test_destructured_listPatternWithRest() async {
     await assertDiagnostics(r'''
 f() {
@@ -90,6 +126,24 @@ f() {
 ''');
   }
 
+  test_destructured_mapPattern_wildcard() async {
+    await assertDiagnostics(r'''
+f() {
+  var {'first': a, 'second': _} = {'first': 1, 'second': 2};
+}
+''', [
+      lint(8, 3),
+    ]);
+  }
+
+  test_destructured_mapPattern_wildcard_single() async {
+    await assertNoDiagnostics(r'''
+f() {
+  var {'first': _} = {'first': 1};
+}
+''');
+  }
+
   test_destructured_objectPattern() async {
     await assertDiagnostics(r'''
 class A {
@@ -129,6 +183,40 @@ f() {
 ''');
   }
 
+  test_destructured_objectPattern_wildcard() async {
+    await assertNoDiagnostics(r'''
+class A {
+  int a;
+  A(this.a);
+}
+f() {
+  var A(a: _) = A(1);
+}
+''');
+  }
+
+  test_destructured_objectPattern_wildcard_multipleFields() async {
+    await assertDiagnostics(r'''
+class A {
+  int a, b;
+  A(this.a, this.b);
+}
+f() {
+  var A(a: x, b: _) = A(1, 2);
+}
+''', [
+      lint(53, 3),
+    ]);
+  }
+
+  test_destructured_parenthesizedPattern_wildcard() async {
+    await assertNoDiagnostics(r'''
+f() {
+  var (_) = ('a');
+}
+''');
+  }
+
   test_destructured_recordPattern() async {
     await assertDiagnostics(r'''
 f() {
@@ -178,6 +266,16 @@ f() {
 ''');
   }
 
+  test_destructured_recordPattern_forLoop_wildcard() async {
+    await assertDiagnostics(r'''
+f() {
+  for (var (_, b) in [(1, 2)]) { }
+}
+''', [
+      lint(21, 1),
+    ]);
+  }
+
   test_destructured_recordPattern_mutated() async {
     await assertNoDiagnostics(r'''
 f() {
@@ -187,6 +285,24 @@ f() {
 ''');
   }
 
+  test_destructured_recordPattern_wildcard() async {
+    await assertDiagnostics(r'''
+f() {
+  var (_, b) = ('a', 'b');
+}
+''', [
+      lint(8, 3),
+    ]);
+  }
+
+  test_destructured_recordPattern_wildcard_multipleWildcards() async {
+    await assertNoDiagnostics(r'''
+f() {
+  var (_, _) = ('a', 'b');
+}
+''');
+  }
+
   test_destructured_recordPattern_withParenthesizedPattern() async {
     await assertDiagnostics(r'''
 f() {
@@ -223,6 +339,16 @@ f(Object o) {
 ''');
   }
 
+  test_ifPatternList_wildcard() async {
+    await assertDiagnostics(r'''
+f(Object o) {
+  if (o case [int x, int _]) x;
+}
+''', [
+      lint(28, 5),
+    ]);
+  }
+
   test_ifPatternMap() async {
     await assertDiagnostics(r'''
 f(Object o) {
@@ -241,6 +367,14 @@ f(Object o) {
 ''');
   }
 
+  test_ifPatternMap_wildcard() async {
+    await assertNoDiagnostics(r'''
+f(Object o) {
+  if (o case {'x': var _});
+}
+''');
+  }
+
   test_ifPatternObject() async {
     await assertDiagnostics(r'''
 class C {
@@ -269,6 +403,19 @@ f(Object o) {
 ''');
   }
 
+  test_ifPatternObject_wildcard() async {
+    await assertNoDiagnostics(r'''
+class C {
+  int c;
+  C(this.c);
+}
+
+f(Object o) {
+  if (o case C(c: var _));
+}
+''');
+  }
+
   test_ifPatternRecord() async {
     await assertDiagnostics(r'''
 f(Object o) {
@@ -288,6 +435,16 @@ f(Object o) {
 ''');
   }
 
+  test_ifPatternRecord_wildcard() async {
+    await assertDiagnostics(r'''
+f(Object o) {
+  if (o case (int x, int _)) x;
+}
+''', [
+      lint(28, 5),
+    ]);
+  }
+
   test_nonDeclaration_destructured_recordPattern() async {
     await assertNoDiagnostics(r'''
 f(String a, String b) {
@@ -340,6 +497,14 @@ void f() {
     ]);
   }
 
+  test_notReassigned_withVar_wildcard() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  var _ = '';
+}
+''');
+  }
+
   test_reassigned() async {
     await assertNoDiagnostics(r'''
 void f() {
@@ -405,6 +570,24 @@ f() {
 ''');
   }
 
+  test_switch_objectPattern_wildcard() async {
+    await assertDiagnostics(r'''
+class A {
+  int a;
+  A(this.a);
+}
+
+f() {
+  switch (A(1)) {
+    case A(a: >0 && var _): print('');
+  }
+}
+''', [
+      // No lint.
+      error(WarningCode.UNNECESSARY_WILDCARD_PATTERN, 83, 1),
+    ]);
+  }
+
   test_switch_recordPattern() async {
     await assertDiagnostics(r'''
 f() {
@@ -435,6 +618,26 @@ f() {
     case (var a, final int b): ++a;
   }
 }
+''');
+  }
+
+  test_switch_recordPattern_wildcard() async {
+    await assertDiagnostics(r'''
+f() {
+  switch ((1, 2)) {
+    case (var a, int _): a;
+  }
+}
+''', [
+      lint(36, 5),
+    ]);
+  }
+
+  test_wildcardLocal() async {
+    await assertNoDiagnostics(r'''
+f() {
+  var _ = 0;
+}
 ''');
   }
 }