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 <srawlins@google.com>
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>

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, V> {
-  K element;
-}
-main(A<int> a) {
-  a.element.anyGetterExistsInDynamic;
-}
-''', [
-      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 36, 6),
-    ]);
-  }
-
-  test_undefinedGetter_wrongNumberOfTypeArguments_tooMany() async {
-    await assertErrorsInCode(r'''
-class A<E> {
-  E element;
-}
-main(A<int,int> a) {
-  a.element.anyGetterExistsInDynamic;
-}
-''', [
-      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 33, 10),
-    ]);
-  }
-
-  test_undefinedGetter_wrongOfTypeArgument() async {
-    await assertErrorsInCode(r'''
-class A<E> {
-  E element;
-}
-main(A<NoSuchType> 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<E, F> {}
-A<A> a = null;
-''', [
-      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 17, 4),
-    ]);
-  }
-
-  test_wrongNumberOfTypeArguments_class_tooMany() async {
-    await assertErrorsInCode(r'''
-class A<E> {}
-A<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<F extends num> = A<F> with M;
-''', [
-      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 47, 4),
-    ]);
-  }
-
-  test_wrongNumberOfTypeArguments_dynamic() async {
-    await assertErrorsInCode(r'''
-dynamic<int> v;
-''', [
-      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 0, 12),
-    ]);
-  }
-
-  test_wrongNumberOfTypeArguments_typeParameter() async {
-    await assertErrorsInCode(r'''
-class C<T> {
-  T<int> f;
+class A<E> {
+  E element;
+}
+main(A<NoSuchType> 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<K, V> {}
-f(p) {
-  return p is C<A>;
-}
-''', [
-      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 49, 4),
-    ]);
-  }
-
-  test_wrongNumberOfTypeArguments_typeTest_tooMany() async {
-    await assertErrorsInCode(r'''
-class A {}
-class C<E> {}
-f(p) {
-  return p is C<A, A>;
-}
-''', [
-      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 46, 7),
+      error(StaticTypeWarningCode.NON_TYPE_AS_TYPE_ARGUMENT, 35, 10),
     ]);
   }
 

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<X extends num, Y extends X>(Y y) {
@@ -145,6 +175,22 @@ void f<X extends num, Y extends X>(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<E> {

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.

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() {

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

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<E, F> {}
+A<A> a = null;
+''', [
+      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 17, 4),
+    ]);
+  }
+
+  test_class_tooMany() async {
+    await assertErrorsInCode(r'''
+class A<E> {}
+A<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<F extends num> = A<F> 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<int> 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, V> {
+  K element;
+}
+main(A<int> a) {
+  a.element.anyGetterExistsInDynamic;
+}
+''', [
+      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 36, 6),
+    ]);
+  }
+
+  test_type_tooMany() async {
+    await assertErrorsInCode(r'''
+class A<E> {
+  E element;
+}
+main(A<int,int> a) {
+  a.element.anyGetterExistsInDynamic;
+}
+''', [
+      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 33, 10),
+    ]);
+  }
+
+  test_typeParameter() async {
+    await assertErrorsInCode(r'''
+class C<T> {
+  T<int> f;
+}
+''', [
+      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 15, 6),
+    ]);
+  }
+
+  test_typeTest_tooFew() async {
+    await assertErrorsInCode(r'''
+class A {}
+class C<K, V> {}
+f(p) {
+  return p is C<A>;
+}
+''', [
+      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 49, 4),
+    ]);
+  }
+
+  test_typeTest_tooMany() async {
+    await assertErrorsInCode(r'''
+class A {}
+class C<E> {}
+f(p) {
+  return p is C<A, A>;
+}
+''', [
+      error(StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS, 46, 7),
+    ]);
+  }
 }