linter: Move tests for no_leading_underscores_for_local_identifiers

Cq-Include-Trybots: luci.dart.try:flutter-analyze-try,analyzer-win-release-try,pkg-win-release-try
Change-Id: Ia73b5e1e87e06980221faa935ec1c2bafc2b2070
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/380965
Commit-Queue: Phil Quitslund <[email protected]>
Auto-Submit: Samuel Rawlins <[email protected]>
Reviewed-by: Phil Quitslund <[email protected]>

Author: srawlins

pkg/linter/test/rules/no_leading_underscores_for_local_identifiers_test.dart

@@ -2,6 +2,7 @@
 // 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:analyzer/src/error/analyzer_error_code.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../rule_test_support.dart';
@@ -14,9 +15,112 @@ main() {
 
 @reflectiveTest
 class NoLeadingUnderscoresForLocalIdentifiersTest extends LintRuleTest {
+  @override
+  List<AnalyzerErrorCode> get ignoredErrorCodes => [
+        WarningCode.UNUSED_CATCH_STACK,
+        WarningCode.UNUSED_ELEMENT,
+        WarningCode.UNUSED_FIELD,
+        WarningCode.UNUSED_LOCAL_VARIABLE,
+      ];
+
   @override
   String get lintRule => 'no_leading_underscores_for_local_identifiers';
 
+  test_catchClause_error() async {
+    await assertDiagnostics(r'''
+void f() {
+  try {}
+  catch(_error) {}
+}
+''', [
+      lint(28, 6),
+    ]);
+  }
+
+  test_catchClause_error_justUnderscore() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  try {}
+  catch(_) {}
+}
+''');
+  }
+
+  test_catchClause_stackTrace() async {
+    await assertDiagnostics(r'''
+void f() {
+  try {}
+  catch(error, _stackTrace) {}
+}
+''', [
+      lint(35, 11),
+    ]);
+  }
+
+  test_field() async {
+    await assertNoDiagnostics(r'''
+class C {
+  var _foo = 0;
+}
+''');
+  }
+
+  test_fieldFormalParameter() async {
+    // https://github.com/dart-lang/linter/issues/3127
+    await assertNoDiagnostics(r'''
+class C {
+  final int _p;
+  C(this._p);
+}
+''');
+  }
+
+  test_forEach() async {
+    await assertDiagnostics(r'''
+void f() {
+  for(var _x in [1,2,3]) {}
+}
+''', [
+      lint(21, 2),
+    ]);
+  }
+
+  test_forEach_justUnderscore() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  for(var _ in [1,2,3]) {}
+}
+''');
+  }
+
+  test_forEach_noUnderscore() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  for(var x in [1,2,3]) {}
+}
+''');
+  }
+
+  test_forLoop_firstVariable() async {
+    await assertDiagnostics(r'''
+void f() {
+  for (var _i = 0;;) {}
+}
+''', [
+      lint(22, 2),
+    ]);
+  }
+
+  test_forLoop_multipleVariables() async {
+    await assertDiagnostics(r'''
+void f() {
+  for (var i = 0, _j = 0;;) {}
+}
+''', [
+      lint(29, 2),
+    ]);
+  }
+
   test_listPattern_ifCase() async {
     await assertDiagnostics(r'''
 f(Object o) {
@@ -51,6 +155,54 @@ f() {
     ]);
   }
 
+  test_localFunction() async {
+    await assertDiagnostics(r'''
+class C {
+  void m() {
+    int _f() => 10;
+  }
+}
+''', [
+      lint(31, 2),
+    ]);
+  }
+
+  test_localVariable() async {
+    await assertDiagnostics(r'''
+void f() {
+  var _foo = 0;
+}
+''', [
+      lint(17, 4),
+    ]);
+  }
+
+  test_localVariable_internalUnderscore() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  var p_p = 0;
+}
+''');
+  }
+
+  test_localVariable_justUnderscore() async {
+    await assertNoDiagnostics(r'''
+void f() {
+  var _ = 0;
+}
+''');
+  }
+
+  test_localVariable_multipleVariables() async {
+    await assertDiagnostics(r'''
+void f() {
+  var x = 1, _y = 2;
+}
+''', [
+      lint(24, 2),
+    ]);
+  }
+
   test_mapPattern_destructured() async {
     await assertDiagnostics(r'''
 f() {
@@ -83,6 +235,14 @@ f() {
     ]);
   }
 
+  test_method() async {
+    await assertNoDiagnostics(r'''
+class C {
+  void _m() {}
+}
+''');
+  }
+
   test_objectPattern_destructured() async {
     await assertDiagnostics(r'''
 class A {
@@ -159,6 +319,46 @@ f(A a) {
 ''');
   }
 
+  test_parameter() async {
+    await assertDiagnostics(r'''
+void f(int _p) {}
+''', [
+      lint(11, 2),
+    ]);
+  }
+
+  test_parameter_internalUnderscore() async {
+    await assertNoDiagnostics(r'''
+void f(int p_p) {}
+''');
+  }
+
+  test_parameter_justUnderscore() async {
+    await assertNoDiagnostics(r'''
+void f(int _) {}
+''');
+  }
+
+  test_parameter_named() async {
+    await assertNoDiagnostics(r'''
+// ignore: private_optional_parameter
+void f({int? _n}) {}
+''');
+  }
+
+  test_parameter_namedRequired() async {
+    await assertNoDiagnostics(r'''
+// ignore: private_optional_parameter
+void f({required int _n}) {}
+''');
+  }
+
+  test_parameter_noUnderscore() async {
+    await assertNoDiagnostics(r'''
+void f(int p) {}
+''');
+  }
+
   test_recordPattern_destructured() async {
     await assertDiagnostics(r'''
 f() {
@@ -210,4 +410,28 @@ f() {
       lint(40, 2),
     ]);
   }
+
+  test_superFormalParameter() async {
+    await assertNoDiagnostics(r'''
+class C {
+  int _i;
+  C(this._i);
+}
+class D extends C {
+  D(super._i);
+}
+''');
+  }
+
+  test_topLevelVariable() async {
+    await assertNoDiagnostics(r'''
+var _foo = 0;
+''');
+  }
+
+  test_typedef() async {
+    await assertNoDiagnostics(r'''
+typedef _T = void Function(String);
+''');
+  }
 }