Move unnecessary_getters_setters tests (dart-lang/linter#4549)

lib/src/ast.dart

@@ -251,19 +251,21 @@ bool isSimpleGetter(MethodDeclaration declaration) {
 /// A simple setter takes this basic form:
 ///
 /// ```dart
-/// var _x;
-/// set(x) {
+/// int _x;
+/// set(int x) {
 ///   _x = x;
 /// }
 /// ```
 ///
 /// or:
 ///
 /// ```dart
-/// set(x) => _x = x;
+/// int _x;
+/// set(int x) => _x = x;
 /// ```
 ///
-/// where the static type of the left and right hand sides must be the same.
+/// where the static type of the left and right hand sides of the assignment
+/// expression are the same.
 bool isSimpleSetter(MethodDeclaration setter) {
   var body = setter.body;
   if (body is ExpressionFunctionBody) {

test/rules/all.dart

@@ -138,6 +138,7 @@ import 'unnecessary_breaks_test.dart' as unnecessary_breaks;
 import 'unnecessary_const_test.dart' as unnecessary_const;
 import 'unnecessary_constructor_name_test.dart' as unnecessary_constructor_name;
 import 'unnecessary_final_test.dart' as unnecessary_final;
+import 'unnecessary_getters_setters_test.dart' as unnecessary_getters_setters;
 import 'unnecessary_lambdas_test.dart' as unnecessary_lambdas;
 import 'unnecessary_late_test.dart' as unnecessary_late;
 import 'unnecessary_library_directive_test.dart'
@@ -283,6 +284,7 @@ void main() {
   unnecessary_const.main();
   unnecessary_constructor_name.main();
   unnecessary_final.main();
+  unnecessary_getters_setters.main();
   unnecessary_lambdas.main();
   unnecessary_late.main();
   unnecessary_library_directive.main();

test/rules/unnecessary_getters_setters_test.dart

@@ -0,0 +1,126 @@
+// 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(UnnecessaryGettersSettersTest);
+  });
+}
+
+@reflectiveTest
+class UnnecessaryGettersSettersTest extends LintRuleTest {
+  @override
+  String get lintRule => 'unnecessary_getters_setters';
+
+  test_necessary_differentType() async {
+    await assertNoDiagnostics(r'''
+class C {
+  String? _x;
+
+  dynamic get x {
+    return _x;
+  }
+  set x(dynamic value) {
+    _x = value;
+  }
+}
+''');
+  }
+
+  test_necessary_hasAnnotation() async {
+    await assertNoDiagnostics(r'''
+class C {
+  String? _x;
+
+  @Annotation()
+  String? get x => _x;
+  set x(String? value) {
+    _x = value;
+  }
+}
+
+class Annotation {
+  const Annotation();
+}
+''');
+  }
+
+  test_necessary_nonTrivialSetter() async {
+    await assertNoDiagnostics(r'''
+class C {
+  String? _x;
+
+  String? get x => _x;
+  set x(String? value) {
+    _x = value?.toLowerCase();
+  }
+}
+''');
+  }
+
+  test_necessary_nullAwareAssignment() async {
+    await assertNoDiagnostics(r'''
+class C {
+  String? _x;
+
+  String? get x => _x;
+  set x(String? value) {
+    _x ??= value;
+  }
+}
+''');
+  }
+
+  test_unnecessary_getterAndSetterHaveBlockBody() async {
+    await assertDiagnostics(r'''
+class C {
+  String? _x;
+
+  String? get x {
+    return _x;
+  }
+  set x(String? value) {
+    _x = value;
+  }
+}
+''', [
+      lint(39, 1),
+    ]);
+  }
+
+  test_unnecessary_getterHasExpressionBody() async {
+    await assertDiagnostics(r'''
+class C {
+  String? _x;
+
+  String? get x => _x;
+  set x(String? value)
+  {
+    _x = value;
+  }
+}
+''', [
+      lint(39, 1),
+    ]);
+  }
+
+  test_unnecessary_setterHasExpressionBody() async {
+    await assertDiagnostics(r'''
+class C {
+  String? _x;
+
+  String? get x {
+    return _x;
+  }
+  set x(String? value) => _x = value;
+}
+''', [
+      lint(39, 1),
+    ]);
+  }
+}