From e685ff51319d79873267d439bbcc93ca30812dae Mon Sep 17 00:00:00 2001 From: Sam Rawlins Date: Wed, 22 Jan 2020 16:32:08 +0000 Subject: [PATCH] Move UNDEFINED_{GETTER,METHOD,OPERATOR,SETTER} tests to their own files Change-Id: Iaf5049efdbf887f84d7db1444d5ea7d835a2c967 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/132806 Commit-Queue: Samuel Rawlins Reviewed-by: Brian Wilkerson --- .../static_type_warning_code_test.dart | 351 +----------------- .../diagnostics/undefined_getter_test.dart | 70 ++++ .../diagnostics/undefined_method_test.dart | 45 +++ .../diagnostics/undefined_operator_test.dart | 81 ++++ .../diagnostics/undefined_setter_test.dart | 31 ++ .../wrong_number_of_type_arguments_test.dart | 96 +++++ 6 files changed, 330 insertions(+), 344 deletions(-) diff --git a/pkg/analyzer/test/generated/static_type_warning_code_test.dart b/pkg/analyzer/test/generated/static_type_warning_code_test.dart index 215da61b641..d388a8ad50f 100644 --- a/pkg/analyzer/test/generated/static_type_warning_code_test.dart +++ b/pkg/analyzer/test/generated/static_type_warning_code_test.dart @@ -1185,286 +1185,6 @@ E e() { ]); } - test_undefinedGetter() async { - await assertErrorsInCode(r''' -class T {} -f(T e) { return e.m; } -''', [ - error(StaticTypeWarningCode.UNDEFINED_GETTER, 29, 1), - ]); - } - - test_undefinedGetter_generic_function_call() async { - // Referencing `.call` on a `Function` type works similarly to referencing - // it on `dynamic`--the reference is accepted at compile time, and all type - // checking is deferred until runtime. - await assertErrorsInCode(''' -f(Function f) { - return f.call; -} -''', []); - } - - test_undefinedGetter_object_call() async { - await assertErrorsInCode(''' -f(Object o) { - return o.call; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_GETTER, 25, 4), - ]); - } - - test_undefinedGetter_proxy_annotation_fakeProxy() async { - await assertErrorsInCode(r''' -library L; -class Fake { - const Fake(); -} -const proxy = const Fake(); -@proxy class PrefixProxy {} -main() { - new PrefixProxy().foo; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_GETTER, 127, 3), - ]); - } - - test_undefinedGetter_static() async { - await assertErrorsInCode(r''' -class A {} -var a = A.B;''', [ - error(StaticTypeWarningCode.UNDEFINED_GETTER, 21, 1), - ]); - } - - test_undefinedGetter_typeLiteral_cascadeTarget() async { - await assertErrorsInCode(r''' -class T { - static int get foo => 42; -} -main() { - T..foo; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_GETTER, 54, 3), - ]); - } - - test_undefinedGetter_typeLiteral_conditionalAccess() async { - // When applied to a type literal, the conditional access operator '?.' - // cannot be used to access instance getters of Type. - await assertErrorsInCode(''' -class A {} -f() => A?.hashCode; -''', [ - error(StaticTypeWarningCode.UNDEFINED_GETTER, 21, 8), - ]); - } - - test_undefinedGetter_wrongNumberOfTypeArguments_tooLittle() async { - await assertErrorsInCode(r''' -class A { - K element; -} -main(A a) { - a.element.anyGetterExistsInDynamic; -} -''', [ - error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 36, 6), - ]); - } - - test_undefinedGetter_wrongNumberOfTypeArguments_tooMany() async { - await assertErrorsInCode(r''' -class A { - E element; -} -main(A a) { - a.element.anyGetterExistsInDynamic; -} -''', [ - error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 33, 10), - ]); - } - - test_undefinedGetter_wrongOfTypeArgument() async { - await assertErrorsInCode(r''' -class A { - E element; -} -main(A a) { - a.element.anyGetterExistsInDynamic; -} -''', [ - error(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, 35, 10), - ]); - } - - test_undefinedMethod_assignmentExpression() async { - await assertErrorsInCode(r''' -class A {} -class B { - f(A a) { - A a2 = new A(); - a += a2; - } -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 58, 2), - ]); - } - - test_undefinedMethod_ignoreTypePropagation() async { - await assertErrorsInCode(r''' -class A {} -class B extends A { - m() {} -} -class C { - f() { - A a = new B(); - a.m(); - } -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_METHOD, 85, 1), - ]); - } - - test_undefinedMethod_leastUpperBoundWithNull() async { - await assertErrorsInCode(''' -f(bool b, int i) => (b ? null : i).foo(); -''', [ - error(StaticTypeWarningCode.UNDEFINED_METHOD, 35, 3), - ]); - } - - test_undefinedMethod_ofNull() async { - // TODO(scheglov) Track https://github.com/dart-lang/sdk/issues/28430 to - // decide whether a warning should be reported here. - await assertErrorsInCode(r''' -Null f(int x) => null; -main() { - f(42).abs(); -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_METHOD, 40, 3), - ]); - } - - test_undefinedMethodWithConstructor() async { - await assertErrorsInCode(r''' -class C { - C.m(); -} -f() { - C c = C.m(); -} -''', [ - error(HintCode.UNUSED_LOCAL_VARIABLE, 31, 1), - ]); - } - - test_undefinedOperator_indexBoth() async { - await assertErrorsInCode(r''' -class A {} -f(A a) { - a[0]++; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 3), - error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 3), - ]); - } - - test_undefinedOperator_indexGetter() async { - await assertErrorsInCode(r''' -class A {} -f(A a) { - a[0]; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 3), - ]); - } - - test_undefinedOperator_indexSetter() async { - await assertErrorsInCode(r''' -class A {} -f(A a) { - a[0] = 1; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 3), - ]); - } - - test_undefinedOperator_plus() async { - await assertErrorsInCode(r''' -class A {} -f(A a) { - a + 1; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 24, 1), - ]); - } - - test_undefinedOperator_postfixExpression() async { - await assertErrorsInCode(r''' -class A {} -f(A a) { - a++; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 2), - ]); - } - - test_undefinedOperator_prefixExpression() async { - await assertErrorsInCode(r''' -class A {} -f(A a) { - ++a; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 22, 2), - ]); - } - - test_undefinedSetter() async { - await assertErrorsInCode(r''' -class T {} -f(T e1) { e1.m = 0; } -''', [ - error(StaticTypeWarningCode.UNDEFINED_SETTER, 24, 1), - ]); - } - - test_undefinedSetter_static() async { - await assertErrorsInCode(r''' -class A {} -f() { A.B = 0;} -''', [ - error(StaticTypeWarningCode.UNDEFINED_SETTER, 19, 1), - ]); - } - - test_undefinedSetter_typeLiteral_cascadeTarget() async { - await assertErrorsInCode(r''' -class T { - static void set foo(_) {} -} -main() { - T..foo = 42; -} -''', [ - error(StaticTypeWarningCode.UNDEFINED_SETTER, 54, 3), - ]); - } - test_unqualifiedReferenceToNonLocalStaticMember_getter() async { await assertErrorsInCode(r''' class A { @@ -1523,73 +1243,16 @@ class B extends A { ]); } - test_wrongNumberOfTypeArguments_class_tooFew() async { + test_wrongNumberOfTypeArguments() async { await assertErrorsInCode(r''' -class A {} -A a = null; -''', [ - error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 17, 4), - ]); - } - - test_wrongNumberOfTypeArguments_class_tooMany() async { - await assertErrorsInCode(r''' -class A {} -A a = null; -''', [ - error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 14, 7), - ]); - } - - test_wrongNumberOfTypeArguments_classAlias() async { - await assertErrorsInCode(r''' -class A {} -class M {} -class B = A with M; -''', [ - error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 47, 4), - ]); - } - - test_wrongNumberOfTypeArguments_dynamic() async { - await assertErrorsInCode(r''' -dynamic v; -''', [ - error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 0, 12), - ]); - } - - test_wrongNumberOfTypeArguments_typeParameter() async { - await assertErrorsInCode(r''' -class C { - T f; +class A { + E element; +} +main(A a) { + a.element.anyGetterExistsInDynamic; } ''', [ - error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 15, 6), - ]); - } - - test_wrongNumberOfTypeArguments_typeTest_tooFew() async { - await assertErrorsInCode(r''' -class A {} -class C {} -f(p) { - return p is C; -} -''', [ - error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 49, 4), - ]); - } - - test_wrongNumberOfTypeArguments_typeTest_tooMany() async { - await assertErrorsInCode(r''' -class A {} -class C {} -f(p) { - return p is C; -} -''', [ - error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 46, 7), + error(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, 35, 10), ]); } diff --git a/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart b/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart index f91af0a536d..177bd1f6b4e 100644 --- a/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart +++ b/pkg/analyzer/test/src/diagnostics/undefined_getter_test.dart @@ -46,6 +46,17 @@ f() { ]); } + test_generic_function_call() async { + // Referencing `.call` on a `Function` type works similarly to referencing + // it on `dynamic`--the reference is accepted at compile time, and all type + // checking is deferred until runtime. + await assertErrorsInCode(''' +f(Function f) { + return f.call; +} +''', []); + } + test_ifElement_inList_notPromoted() async { await assertErrorsInCode(''' f(int x) { @@ -122,6 +133,15 @@ f(Object x) { '''); } + test_instance_undefined() async { + await assertErrorsInCode(r''' +class T {} +f(T e) { return e.m; } +''', [ + error(StaticTypeWarningCode.UNDEFINED_GETTER, 29, 1), + ]); + } + test_nullMember_undefined() async { await assertErrorsInCode(r''' m() { @@ -133,6 +153,16 @@ m() { ]); } + test_object_call() async { + await assertErrorsInCode(''' +f(Object o) { + return o.call; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_GETTER, 25, 4), + ]); + } + test_promotedTypeParameter_regress35305() async { await assertErrorsInCode(r''' void f(Y y) { @@ -145,6 +175,22 @@ void f(Y y) { ]); } + test_proxy_annotation_fakeProxy() async { + await assertErrorsInCode(r''' +library L; +class Fake { + const Fake(); +} +const proxy = const Fake(); +@proxy class PrefixProxy {} +main() { + new PrefixProxy().foo; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_GETTER, 127, 3), + ]); + } + test_static_conditionalAcces_defined() async { // The conditional access operator '?.' can be used to access static // fields. @@ -179,6 +225,30 @@ f(var p) { ]); } + test_typeLiteral_cascadeTarget() async { + await assertErrorsInCode(r''' +class T { + static int get foo => 42; +} +main() { + T..foo; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_GETTER, 54, 3), + ]); + } + + test_typeLiteral_conditionalAccess() async { + // When applied to a type literal, the conditional access operator '?.' + // cannot be used to access instance getters of Type. + await assertErrorsInCode(''' +class A {} +f() => A?.hashCode; +''', [ + error(StaticTypeWarningCode.UNDEFINED_GETTER, 21, 8), + ]); + } + test_typeSubstitution_defined() async { await assertNoErrorsInCode(r''' class A { diff --git a/pkg/analyzer/test/src/diagnostics/undefined_method_test.dart b/pkg/analyzer/test/src/diagnostics/undefined_method_test.dart index 61a5b1e75f1..97943adcdfb 100644 --- a/pkg/analyzer/test/src/diagnostics/undefined_method_test.dart +++ b/pkg/analyzer/test/src/diagnostics/undefined_method_test.dart @@ -18,6 +18,15 @@ main() { @reflectiveTest class UndefinedMethodTest extends DriverResolutionTest { + test_constructor_defined() async { + await assertNoErrorsInCode(r''' +class C { + C.m(); +} +C c = C.m(); +'''); + } + test_functionExpression_callMethod_defined() async { await assertNoErrorsInCode(r''' main() { @@ -34,6 +43,42 @@ main() { '''); } + test_ignoreTypePropagation() async { + await assertErrorsInCode(r''' +class A {} +class B extends A { + m() {} +} +class C { + f() { + A a = new B(); + a.m(); + } +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_METHOD, 85, 1), + ]); + } + + test_leastUpperBoundWithNull() async { + await assertErrorsInCode(''' +f(bool b, int i) => (b ? null : i).foo(); +''', [ + error(StaticTypeWarningCode.UNDEFINED_METHOD, 35, 3), + ]); + } + + test_method_undefined_onNull() async { + await assertErrorsInCode(r''' +Null f(int x) => null; +main() { + f(42).abs(); +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_METHOD, 40, 3), + ]); + } + test_static_conditionalAccess_defined() async { // The conditional access operator '?.' can be used to access static // methods. diff --git a/pkg/analyzer/test/src/diagnostics/undefined_operator_test.dart b/pkg/analyzer/test/src/diagnostics/undefined_operator_test.dart index fb7ebc453b0..02ea2374e9d 100644 --- a/pkg/analyzer/test/src/diagnostics/undefined_operator_test.dart +++ b/pkg/analyzer/test/src/diagnostics/undefined_operator_test.dart @@ -18,6 +18,20 @@ main() { @reflectiveTest class UndefinedOperatorTest extends DriverResolutionTest { + test_assignmentExpression_undefined() async { + await assertErrorsInCode(r''' +class A {} +class B { + f(A a) { + A a2 = new A(); + a += a2; + } +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 58, 2), + ]); + } + test_binaryExpression() async { await assertErrorsInCode(r''' class A {} @@ -107,6 +121,40 @@ f(A a) { ]); } + test_indexBoth_undefined() async { + await assertErrorsInCode(r''' +class A {} +f(A a) { + a[0]++; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 3), + error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 3), + ]); + } + + test_indexGetter_undefined() async { + await assertErrorsInCode(r''' +class A {} +f(A a) { + a[0]; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 3), + ]); + } + + test_indexSetter_undefined() async { + await assertErrorsInCode(r''' +class A {} +f(A a) { + a[0] = 1; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 3), + ]); + } + test_minus_null() async { await assertErrorsInCode(r''' m() { @@ -141,6 +189,17 @@ m() { ]); } + test_plus_undefined() async { + await assertErrorsInCode(r''' +class A {} +f(A a) { + a + 1; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 24, 1), + ]); + } + test_plusEq_null() async { await assertErrorsInCode(r''' m() { @@ -190,6 +249,17 @@ f(var a) { '''); } + test_postfixExpression_undefined() async { + await assertErrorsInCode(r''' +class A {} +f(A a) { + a++; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 23, 2), + ]); + } + test_postfixInc_null() async { await assertErrorsInCode(r''' m() { @@ -239,6 +309,17 @@ f(var a) { '''); } + test_prefixExpression_undefined() async { + await assertErrorsInCode(r''' +class A {} +f(A a) { + ++a; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_OPERATOR, 22, 2), + ]); + } + test_prefixInc_null() async { await assertErrorsInCode(r''' m() { diff --git a/pkg/analyzer/test/src/diagnostics/undefined_setter_test.dart b/pkg/analyzer/test/src/diagnostics/undefined_setter_test.dart index 533395bdc66..38e017a62ed 100644 --- a/pkg/analyzer/test/src/diagnostics/undefined_setter_test.dart +++ b/pkg/analyzer/test/src/diagnostics/undefined_setter_test.dart @@ -31,6 +31,15 @@ main() { '''); } + test_instance_undefined() async { + await assertErrorsInCode(r''' +class T {} +f(T e1) { e1.m = 0; } +''', [ + error(StaticTypeWarningCode.UNDEFINED_SETTER, 24, 1), + ]); + } + test_inSubtype() async { await assertErrorsInCode(r''' class A {} @@ -83,6 +92,28 @@ f(var p) { error(StaticTypeWarningCode.UNDEFINED_SETTER, 75, 1), ]); } + + test_static_undefined() async { + await assertErrorsInCode(r''' +class A {} +f() { A.B = 0;} +''', [ + error(StaticTypeWarningCode.UNDEFINED_SETTER, 19, 1), + ]); + } + + test_typeLiteral_cascadeTarget() async { + await assertErrorsInCode(r''' +class T { + static void set foo(_) {} +} +main() { + T..foo = 42; +} +''', [ + error(StaticTypeWarningCode.UNDEFINED_SETTER, 54, 3), + ]); + } } @reflectiveTest diff --git a/pkg/analyzer/test/src/diagnostics/wrong_number_of_type_arguments_test.dart b/pkg/analyzer/test/src/diagnostics/wrong_number_of_type_arguments_test.dart index 745c468b44e..83954f25c77 100644 --- a/pkg/analyzer/test/src/diagnostics/wrong_number_of_type_arguments_test.dart +++ b/pkg/analyzer/test/src/diagnostics/wrong_number_of_type_arguments_test.dart @@ -15,6 +15,34 @@ main() { @reflectiveTest class WrongNumberOfTypeArgumentsTest extends DriverResolutionTest { + test_class_tooFew() async { + await assertErrorsInCode(r''' +class A {} +A a = null; +''', [ + error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 17, 4), + ]); + } + + test_class_tooMany() async { + await assertErrorsInCode(r''' +class A {} +A a = null; +''', [ + error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 14, 7), + ]); + } + + test_classAlias() async { + await assertErrorsInCode(r''' +class A {} +class M {} +class B = A with M; +''', [ + error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 47, 4), + ]); + } + test_const_nonGeneric() async { await assertErrorsInCode(''' class C { @@ -57,6 +85,14 @@ f() { ]); } + test_dynamic() async { + await assertErrorsInCode(r''' +dynamic v; +''', [ + error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 0, 12), + ]); + } + test_new_nonGeneric() async { await assertErrorsInCode(''' class C {} @@ -92,4 +128,64 @@ f() { error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 34, 11), ]); } + + test_type_tooFew() async { + await assertErrorsInCode(r''' +class A { + K element; +} +main(A a) { + a.element.anyGetterExistsInDynamic; +} +''', [ + error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 36, 6), + ]); + } + + test_type_tooMany() async { + await assertErrorsInCode(r''' +class A { + E element; +} +main(A a) { + a.element.anyGetterExistsInDynamic; +} +''', [ + error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 33, 10), + ]); + } + + test_typeParameter() async { + await assertErrorsInCode(r''' +class C { + T f; +} +''', [ + error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 15, 6), + ]); + } + + test_typeTest_tooFew() async { + await assertErrorsInCode(r''' +class A {} +class C {} +f(p) { + return p is C; +} +''', [ + error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 49, 4), + ]); + } + + test_typeTest_tooMany() async { + await assertErrorsInCode(r''' +class A {} +class C {} +f(p) { + return p is C; +} +''', [ + error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 46, 7), + ]); + } }