lint rules: Migrate prefer_void_to_null tests
Change-Id: Id02e094fd71d2c6e6326431f865cf19babcbdd40
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/398505
Auto-Submit: Samuel Rawlins <srawlins@google.com>
Reviewed-by: Phil Quitslund <pquitslund@google.com>
Commit-Queue: Phil Quitslund <pquitslund@google.com>
diff --git a/pkg/linter/test/rules/prefer_void_to_null_test.dart b/pkg/linter/test/rules/prefer_void_to_null_test.dart
index 1a63e7f..05636c9 100644
--- a/pkg/linter/test/rules/prefer_void_to_null_test.dart
+++ b/pkg/linter/test/rules/prefer_void_to_null_test.dart
@@ -8,6 +8,8 @@
main() {
defineReflectiveSuite(() {
+ // TODO(mfairhurst): test void with a prefix, except that causes bugs.
+ // TODO(mfairhurst): test defining a class named Null (requires a 2nd file).
defineReflectiveTests(PreferVoidToNullTest);
});
}
@@ -149,6 +151,99 @@
''');
}
+ test_instanceField_futureOfNull() async {
+ await assertDiagnostics(r'''
+class C {
+ Future<Null>? x;
+}
+''', [
+ lint(19, 4),
+ ]);
+ }
+
+ test_instanceField_null() async {
+ await assertDiagnostics(r'''
+class C {
+ Null x;
+}
+''', [
+ lint(12, 4),
+ ]);
+ }
+
+ test_instanceField_null_prefixed() async {
+ await assertDiagnostics(r'''
+import 'dart:core' as core;
+class C {
+ core.Null x;
+}
+''', [
+ lint(45, 4),
+ ]);
+ }
+
+ test_instanceGetter_overrideChangingType() async {
+ // https://github.com/dart-lang/linter/issues/1523
+ await assertNoDiagnostics(r'''
+abstract class C {
+ Object? get foo;
+}
+
+class D extends C {
+ @override
+ Null get foo => null;
+}
+''');
+ }
+
+ test_instanceMethod_returnType_overrideChangingType() async {
+ await assertDiagnostics(r'''
+import 'dart:async';
+abstract class C {
+ FutureOr<void>? m();
+}
+
+class D implements C {
+ @override
+ Null m() {}
+}
+''', [
+ lint(103, 4),
+ ]);
+ }
+
+ test_instanceMethod_returnType_overrideChangingType_generic() async {
+ // https://github.com/dart-lang/linter/issues/2792
+ await assertNoDiagnostics(r'''
+abstract class C<T> {
+ Future<T>? m();
+}
+
+class D<T> implements C<T> {
+ @override
+ Null m() {}
+}
+''');
+ }
+
+ test_listLiteralTypeArg_null_empty() async {
+ await assertNoDiagnostics(r'''
+void f() {
+ <Null>[];
+}
+''');
+ }
+
+ test_listLiteralTypeArg_null_nonEmpty() async {
+ await assertDiagnostics(r'''
+void f() {
+ <Null>[null];
+}
+''', [
+ lint(14, 4),
+ ]);
+ }
+
test_localVariable() async {
await assertNoDiagnostics(r'''
void f() {
@@ -157,9 +252,172 @@
''');
}
+ test_localVariable_futureOfNull() async {
+ await assertDiagnostics(r'''
+void f() {
+ Future<Null> x;
+}
+''', [
+ lint(20, 4),
+ ]);
+ }
+
+ test_mapLiteralTypeArg_nullKey_empty() async {
+ await assertNoDiagnostics(r'''
+void f() {
+ <Null, String>{};
+}
+''');
+ }
+
+ test_mapLiteralTypeArg_nullKey_nonEmpty() async {
+ await assertDiagnostics(r'''
+void f() {
+ <Null, String>{null: "foo"};
+}
+''', [
+ lint(14, 4),
+ ]);
+ }
+
+ test_mapLiteralTypeArg_nullValue_empty() async {
+ await assertNoDiagnostics(r'''
+void f() {
+ <String, Null>{};
+}
+''');
+ }
+
+ test_mapLiteralTypeArg_nullValue_nonEmpty() async {
+ await assertDiagnostics(r'''
+void f() {
+ <String, Null>{"foo": null};
+}
+''', [
+ lint(22, 4),
+ ]);
+ }
+
+ test_methodInvocation_typeArgument() async {
+ await assertDiagnostics(r'''
+void f(Future<void> p) {
+ p.then<Null>((_) {});
+}
+''', [
+ lint(34, 4),
+ ]);
+ }
+
+ test_methodParameter_null() async {
+ await assertDiagnostics(r'''
+class C {
+ void m(Null x) {}
+}
+''', [
+ lint(19, 4),
+ ]);
+ }
+
+ test_methodReturnType_null() async {
+ await assertDiagnostics(r'''
+class C {
+ Null m() {}
+}
+''', [
+ lint(12, 4),
+ ]);
+ }
+
+ test_methodReturnType_null_prefixed() async {
+ await assertDiagnostics(r'''
+import 'dart:core' as core;
+class C {
+ core.Null m() {}
+}
+''', [
+ lint(45, 4),
+ ]);
+ }
+
+ test_topLevelFunction_parameterType_null() async {
+ await assertDiagnostics(r'''
+void f(Null x) {}
+''', [
+ lint(7, 4),
+ ]);
+ }
+
+ test_topLevelFunction_parameterType_null_prefixed() async {
+ await assertDiagnostics(r'''
+import 'dart:core' as core;
+void f(core.Null x) {}
+''', [
+ lint(40, 4),
+ ]);
+ }
+
+ test_topLevelFunction_returnType_null() async {
+ await assertDiagnostics(r'''
+Null f() {}
+''', [
+ lint(0, 4),
+ ]);
+ }
+
+ test_topLevelFunction_returnType_null_prefixed() async {
+ await assertDiagnostics(r'''
+import 'dart:core' as core;
+core.Null f() {}
+''', [
+ lint(33, 4),
+ ]);
+ }
+
test_topLevelVariable() async {
await assertNoDiagnostics(r'''
Null a;
''');
}
+
+ test_topLevelVariable_functionReturnType_functionParameterType_futureOfNull() async {
+ await assertDiagnostics(r'''
+void Function(Future<Null>)? f;
+''', [
+ lint(21, 4),
+ ]);
+ }
+
+ test_topLevelVariable_functionReturnType_functionParameterType_null() async {
+ await assertNoDiagnostics(r'''
+void Function(Null)? f;
+''');
+ }
+
+ test_topLevelVariable_functionReturnType_functionReturnType_futureOfNull() async {
+ await assertDiagnostics(r'''
+Future<Null> Function()? f;
+''', [
+ lint(7, 4),
+ ]);
+ }
+
+ test_topLevelVariable_functionReturnType_functionReturnType_null() async {
+ await assertNoDiagnostics(r'''
+Null Function()? f;
+''');
+ }
+
+ test_topLevelVariable_futureOfNull() async {
+ await assertDiagnostics(r'''
+Future<Null>? x;
+''', [
+ lint(7, 4),
+ ]);
+ }
+
+ test_topLevelVariable_null() async {
+ await assertNoDiagnostics(r'''
+Null x;
+''');
+ }
}
diff --git a/pkg/linter/test_data/rules/prefer_void_to_null.dart b/pkg/linter/test_data/rules/prefer_void_to_null.dart
deleted file mode 100644
index 6c2d59a..0000000
--- a/pkg/linter/test_data/rules/prefer_void_to_null.dart
+++ /dev/null
@@ -1,169 +0,0 @@
-// Copyright (c) 2018, 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.
-
-// TODO(mfairhurst) test void with a prefix, except that causes bugs.
-// TODO(mfairhurst) test defining a class named Null (requires a 2nd file)
-
-// ignore_for_file: unused_local_variable
-
-import 'dart:async';
-import 'dart:core';
-import 'dart:core' as core;
-
-abstract class X {
- dynamic get foo;
-}
-
-/// https://github.com/dart-lang/linter/issues/1523
-class Y extends X {
- @override
- Null get foo => null; // OK
-}
-
-/// https://github.com/dart-lang/linter/issues/2792
-class A<T> {
- Future<T>? something() {}
-}
-
-class B<T> implements A<T> {
- @override
- Null something() {} // OK
-}
-
-class C {
- FutureOr<void>? something() {}
-}
-
-class D implements C {
- @override
- Null something() {} // LINT
-}
-
-class E {
- Never? something() {} // LINT
-}
-
-class F implements E {
- @override
- Null something() {} // OK
-}
-
-void void_; // OK
-Future<void>? future_void; // OK
-Future<Null>? future_null; // LINT
-Future<core.Null>? future_core_null; // LINT
-
-void void_f() {} // OK
-Null null_f() {} // LINT
-core.Null core_null_f() {} // LINT
-f_void(void x) {} // OK
-f_null(Null x) {} // LINT
-f_core_null(core.Null x) {} // LINT
-
-void Function(Null)? voidFunctionNull; // OK
-Null Function()? nullFunctionVoid; // OK
-Future<Null> Function()? FutureNullFunction; // LINT
-void Function(Future<Null>)? voidFunctionFutureNull; // LINT
-
-usage() {
- void void_; // OK
- Future<void>? future_void; // OK
- Future<Null> future_null; // LINT
- Future<core.Null> future_core_null; // LINT
-
- future_void?.then<Null>((_) {}); // LINT
- future_void?.then<void>((_) {}); // OK
-}
-
-void inference() {
- final _null = null; // OK
- final nullReturnInferred = () {}; // OK
- final nullInferred = nullReturnInferred(); // OK
-}
-
-void emptyLiterals() {
- <Null>[]; // OK
- <Null>[null]; // LINT
- <void>[]; // OK
- <void>[null]; // OK
- <int, Null>{}; // OK
- <String, Null>{}; // OK
- <Object, Null>{}; // OK
- <Null, int>{}; // OK
- <Null, String>{}; // OK
- <Null, Object>{}; // OK
- <Null, Null>{}; // OK
- <int, Null>{1: null}; // LINT
- <String, Null>{"foo": null}; // LINT
- <Object?, Null>{null: null}; // LINT
- <Null, int>{null: 1}; // LINT
- <Null, String>{null: "foo"}; // LINT
- <Null, Object?>{null: null}; // LINT
- <Null, // LINT
- Null>{null: null}; // LINT
- <int, void>{}; // OK
- <String, void>{}; // OK
- <Object, void>{}; // OK
- <void, int>{}; // OK
- <void, String>{}; // OK
- <void, Object>{}; // OK
- <void, void>{}; // OK
- <int, void>{1: null}; // OK
- <String, void>{"foo": null}; // OK
- <Object?, void>{null: null}; // OK
- <void, int>{null: 1}; // OK
- <void, String>{null: "foo"}; // OK
- <void, Object?>{null: null}; // OK
- <void, void>{null: null}; // OK
-
- // TODO(mfairhurst): is it worth handling more complex literals?
-}
-
-variableNamedNull() {
- var Null; // OK
- return Null; // OK
-}
-
-parameterNamedNull(Object Null) {
- Null; // OK
-}
-
-class AsMembers {
- void void_; // OK
- Null null_; // LINT
- core.Null core_null; // LINT
- Future<void>? future_void; // OK
- Future<Null>? future_null; // LINT
- Future<core.Null>? future_core_null; // LINT
-
- void void_f() {} // OK
- Null null_f() {} // LINT
- core.Null core_null_f() {} // LINT
- f_void(void x) {} // OK
- f_null(Null x) {} // LINT
- f_core_null(core.Null x) {} // LINT
-
- void usage() {
- void void_; // OK
- Future<void>? future_void; // OK
- Future<Null> future_null; // LINT
- Future<core.Null> future_core_null; // LINT
-
- future_void?.then<Null>((_) {}); // LINT
- future_void?.then<void>((_) {}); // OK
- }
-
- parameterNamedNull(Object Null) {
- Null; // OK
- }
-
- variableNamedNull() {
- var Null; // OK
- return Null; // OK
- }
-}
-
-class MemberNamedNull {
- final Null = null; // OK
-}
