remove duplicate checking for overrides

pkg/analyzer/test/src/task/strong/checker_test.dart

 // Copyright (c) 2015, 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.
 
 library analyzer.test.src.task.strong.checker_test;
 
 import '../../../reflective_tests.dart';
 import 'strong_test_helper.dart';
 
 void main() {
@@ skipping 146 matching lines @@
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class Base implements I1 {}
 
 class T1 extends Base {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_classOverrideOfGrandInterface_interfaceOfConcreteSuperclass() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/Base
     implements I1 {}
 
 class T1 extends Base {
     // not reported technically because if the class is concrete,
     // it should implement all its interfaces and hence it is
     // sufficient to check overrides against it.
-    m(/*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+    m(B a) {}
 }
 ''');
   }
 
   void test_classOverrideOfGrandInterface_interfaceOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 implements I1 {}
 
 class T1 implements I2 {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_classOverrideOfGrandInterface_mixinOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class M1 {
     m(A a);
 }
 abstract class I2 extends Object with M1 {}
 
 class T1 implements I2 {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_classOverrideOfGrandInterface_superclassOfInterfaceOfChild() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 extends I1 {}
 
 class T1 implements I2 {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_compoundAssignments() {
     checkFile('''
 class A {
   A operator *(B b) => null;
   A operator /(B b) => null;
   A operator ~/(B b) => null;
@@ skipping 1529 matching lines @@
   void test_genericClassMethodOverride() {
     checkFile('''
 class A {}
 class B extends A {}
 
 class Base<T extends B> {
   T foo() => null;
 }
 
 class Derived<S extends A> extends Base<B> {
-  /*error:INVALID_METHOD_OVERRIDE*/S
-      /*error:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/foo() => null;
+  /*error:INVALID_METHOD_OVERRIDE*/S foo() => null;
 }
 
 class Derived2<S extends B> extends Base<B> {
   S foo() => null;
 }
 ''');
   }
 
   void test_genericFunctionWrongNumberOfArguments() {
     checkFile(r'''
@@ skipping 444 matching lines @@
   void test_invalidOverrides_childOverride() {
     checkFile('''
 class A {}
 class B {}
 
 class Base {
     A f;
 }
 
 class T1 extends Base {
-  /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B get
-      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null;
+  /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B get f => null;
 }
 
 class T2 extends Base {
   /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/set f(
-      /*error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null;
+      B b) => null;
 }
 
 class T3 extends Base {
   /*error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/final B
-      /*warning:FINAL_NOT_INITIALIZED, error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f;
+      /*warning:FINAL_NOT_INITIALIZED*/f;
 }
 class T4 extends Base {
   // two: one for the getter one for the setter.
-  /*error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B
-      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE, error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/f;
+  /*error:INVALID_FIELD_OVERRIDE, error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B f;
 }
 
 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T5 implements Base {
-  /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_METHOD_OVERRIDE*/B get
-      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f => null;
+  /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_METHOD_OVERRIDE*/B get f => null;
 }
 
 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T6 implements Base {
-  /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_METHOD_OVERRIDE*/set f(
-      /*error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/B b) => null;
+  /*warning:MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE, error:INVALID_METHOD_OVERRIDE*/set f(B b) => null;
 }
 
 class /*error:NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE*/T7 implements Base {
-  /*error:INVALID_METHOD_OVERRIDE*/final B
-      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE*/f = null;
+  /*error:INVALID_METHOD_OVERRIDE*/final B f = null;
 }
 class T8 implements Base {
   // two: one for the getter one for the setter.
-  /*error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B
-      /*error:INVALID_GETTER_OVERRIDE_RETURN_TYPE, error:INVALID_SETTER_OVERRIDE_NORMAL_PARAM_TYPE*/f;
+  /*error:INVALID_METHOD_OVERRIDE, error:INVALID_METHOD_OVERRIDE*/B f;
 }
 ''');
   }
 
   void test_invalidOverrides_childOverride2() {
     checkFile('''
 class A {}
 class B {}
 
 class Base {
     m(A a) {}
 }
 
 class Test extends Base {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-        /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_invalidOverrides_classOverrideOfInterface() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I {
     m(A a);
 }
 
 class T1 implements I {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_invalidOverrides_doubleOverride() {
     checkFile('''
 class A {}
 class B {}
 
 class Grandparent {
     m(A a) {}
 }
 class Parent extends Grandparent {
     m(A a) {}
 }
 
 class Test extends Parent {
     // Reported only once
-    /*error:INVALID_METHOD_OVERRIDE*/m(
-        /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+    /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_invalidOverrides_doubleOverride2() {
     checkFile('''
 class A {}
 class B {}
 
 class Grandparent {
     m(A a) {}
 }
 class Parent extends Grandparent {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 
 class Test extends Parent {
     m(B a) {}
 }
 ''');
   }
 
   void test_invalidOverrides_grandChildOverride() {
     checkFile('''
 class A {}
 class B {}
 
 class Grandparent {
     m(A a) {}
     int x;
 }
 class Parent extends Grandparent {
 }
 
 class Test extends Parent {
-    /*error:INVALID_METHOD_OVERRIDE*/m(
-          /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+    /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
     /*error:INVALID_FIELD_OVERRIDE*/int x;
 }
 ''');
   }
 
   void test_invalidOverrides_mixinOverrideOfInterface() {
     checkFile('''
 class A {}
 class B {}
 
@@ skipping 510 matching lines @@
     m(A a);
 }
 
 class Base {
     m(B a) {}
 }
 
 // Note: no error reported in `extends Base` to avoid duplicating
 // the error in T1.
 class T1 extends Base implements I1 {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 
 // If there is no error in the class, we do report the error at
 // the base class:
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
     /*error:INVALID_METHOD_OVERRIDE_FROM_BASE*/extends Base
     implements I1 {}
 ''');
   }
 
   void
       test_noDuplicateReportsFromOverridingInterfaces_typeAndMixinOverrideSameMethodInInterface() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class M {
     m(B a) {}
 }
 
 class T1 extends Object with M implements I1 {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 
 class /*error:INCONSISTENT_METHOD_INHERITANCE*/T2
     extends Object with /*error:INVALID_METHOD_OVERRIDE_FROM_MIXIN*/M
     implements I1 {}
 ''');
   }
 
   void
       test_noDuplicateReportsFromOverridingInterfaces_typeOverridesSomeMethodInMultipleInterfaces() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 abstract class I2 implements I1 {
     m(A a);
 }
 
 class Base {}
 
 class T1 implements I2 {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_nullCoalescingOperator() {
     checkFile('''
 class A {}
 class C<T> {}
 main() {
   A a, b;
@@ skipping 34 matching lines @@
   void test_overrideNarrowsType() {
     addFile(r'''
 class A {}
 class B extends A {}
 
 abstract class C {
   m(A a);
   n(B b);
 }
 abstract class D extends C {
-  /*error:INVALID_METHOD_OVERRIDE*/m(/*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B b);
+  /*error:INVALID_METHOD_OVERRIDE*/m(B b);
   n(A a);
 }
     ''');
     check(implicitCasts: false);
   }
 
   void test_privateOverride() {
     addFile(
         '''
 import 'main.dart' as main;
 
 class Base {
   var f1;
   var _f2;
   var _f3;
   get _f4 => null;
 
   int _m1() => null;
 }
 
 class GrandChild extends main.Child {
   /*error:INVALID_FIELD_OVERRIDE*/var _f2;
   /*error:INVALID_FIELD_OVERRIDE*/var _f3;
   var _f4;
 
-  /*error:INVALID_METHOD_OVERRIDE*/String
-      /*error:INVALID_METHOD_OVERRIDE_RETURN_TYPE*/_m1() => null;
+  /*error:INVALID_METHOD_OVERRIDE*/String _m1() => null;
 }
 ''',
         name: '/helper.dart');
     checkFile('''
 import 'helper.dart' as helper;
 
 class Child extends helper.Base {
   /*error:INVALID_FIELD_OVERRIDE*/var f1;
   var _f2;
   var _f4;
@@ skipping 237 matching lines @@
   void test_superclassOverrideOfGrandInterface_interfaceOfAbstractSuperclass() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 abstract class Base implements I1 {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 
 class T1 extends Base {
     // we consider the base class incomplete because it is
     // abstract, so we report the error here too.
     // TODO(sigmund): consider tracking overrides in a fine-grain
     // manner, then this and the double-overrides would not be
     // reported.
     /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 ''');
   }
 
   void test_superclassOverrideOfGrandInterface_interfaceOfConcreteSuperclass() {
     checkFile('''
 class A {}
 class B {}
 
 abstract class I1 {
     m(A a);
 }
 
 class Base implements I1 {
-  /*error:INVALID_METHOD_OVERRIDE*/m(
-      /*error:INVALID_METHOD_OVERRIDE_NORMAL_PARAM_TYPE*/B a) {}
+  /*error:INVALID_METHOD_OVERRIDE*/m(B a) {}
 }
 
 class T1 extends Base {
     m(B a) {}
 }
 ''');
   }
 
   void test_superclassOverrideOfGrandInterface_interfaceOfInterfaceOfChild() {
     checkFile('''
@@ skipping 403 matching lines @@
     // Regression test for https://github.com/dart-lang/sdk/issues/25069
     checkFile('''
 typedef int Foo();
 void foo() {}
 void main () {
   Foo x = /*error:INVALID_ASSIGNMENT,info:USE_OF_VOID_RESULT*/foo();
 }
 ''');
   }
 }