Make types concrete when checking 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.
 
 // TODO(jmesserly): this file needs to be refactored, it's a port from
 // package:dev_compiler's tests
 /// General type checking tests
 library analyzer.test.src.task.strong.checker_test;
 
 import 'package:unittest/unittest.dart';
@@ skipping 211 matching lines @@
         await for (var s in new Stream<String>()) {}
 
         // Downcast.
         await for (int /*info:DOWN_CAST_IMPLICIT*/i in new Stream<num>()) {}
       }
     ''');
   });
 
   test('dynamic invocation', () {
     checkFile('''
-      class A {
-        dynamic call(dynamic x) => x;
-      }
-      class B extends A {
+      typedef dynamic A(dynamic x);
+      class B {
         int call(int x) => x;
         double col(double x) => x;
       }
       void main() {
         {
           B f = new B();
           int x;
           double y;
           x = f(3);
           x = /*warning:INVALID_ASSIGNMENT*/f.col(3.0);
@@ skipping 23 matching lines @@
           y = /*info:DYNAMIC_CAST, info:DYNAMIC_INVOKE*/f(3);
           /*info:DYNAMIC_INVOKE*/f(3.0);
         }
         {
           dynamic g = new B();
           /*info:DYNAMIC_INVOKE*/g.call(/*info:ARGUMENT_TYPE_NOT_ASSIGNABLE*/32.0);
           /*info:DYNAMIC_INVOKE*/g.col(42.0);
           /*info:DYNAMIC_INVOKE*/g.foo(42.0);
           /*info:DYNAMIC_INVOKE*/g./*info:UNDEFINED_GETTER*/x;
           A f = new B();
-          f.call(/*info:ARGUMENT_TYPE_NOT_ASSIGNABLE*/32.0);
           /*info:DYNAMIC_INVOKE*/f.col(42.0);
           /*info:DYNAMIC_INVOKE*/f.foo(42.0);
           /*info:DYNAMIC_INVOKE*/f./*warning:UNDEFINED_GETTER*/x;
         }
       }
     ''');
   });
 
   test('conversion and dynamic invoke', () {
     addFile(
@@ skipping 1705 matching lines @@
             /*severe:INVALID_METHOD_OVERRIDE*/A m1(A value) => null;
             /*severe:INVALID_METHOD_OVERRIDE*/C m2(C value) => null;
             /*severe:INVALID_METHOD_OVERRIDE*/A m3(C value) => null;
             C m4(A value) => null;
             m5(value) => null;
             /*severe:INVALID_METHOD_OVERRIDE*/dynamic m6(dynamic value) => null;
           }
        ''');
   });
 
+  test('method override, fuzzy arrows', () {
+    checkFile('''
+      abstract class A {
+        bool operator ==(Object object);
+      }
+
+      class B implements A {}
+
+
+      class F {
+        void f(x) {}
+        void g(int x) {}
+      }
+
+      class G extends F {
+        /*severe:INVALID_METHOD_OVERRIDE*/void f(int x) {}
+        void g(dynamic x) {}
+      }
+
+      class H implements F {
+        /*severe:INVALID_METHOD_OVERRIDE*/void f(int x) {}
+        void g(dynamic x) {}
+      }
+
+      ''');
+  });
+
+  test('getter override, fuzzy arrows', () {
+    checkFile('''
+      typedef void ToVoid<T>(T x);
+      class F {
+        ToVoid<dynamic> get f => null;
+        ToVoid<int> get g => null;
+      }
+
+      class G extends F {
+        ToVoid<int> get f => null;
+        /*severe:INVALID_METHOD_OVERRIDE*/ToVoid<dynamic> get g => null;
+      }
+
+      class H implements F {
+        ToVoid<int> get f => null;
+        /*severe:INVALID_METHOD_OVERRIDE*/ToVoid<dynamic> get g => null;
+      }
+       ''');
+  });
+
+  test('setter override, fuzzy arrows', () {
+    checkFile('''
+      typedef void ToVoid<T>(T x);
+      class F {
+        void set f(ToVoid<dynamic> x) {}
+        void set g(ToVoid<int> x) {} 
+        void set h(dynamic x) {}
+        void set i(int x) {}
+     }
+
+      class G extends F {
+        /*severe:INVALID_METHOD_OVERRIDE*/void set f(ToVoid<int> x) {}
+        void set g(ToVoid<dynamic> x) {}
+        void set h(int x) {}
+        /*severe:INVALID_METHOD_OVERRIDE*/void set i(dynamic x) {}
+      }
+
+      class H implements F {
+        /*severe:INVALID_METHOD_OVERRIDE*/void set f(ToVoid<int> x) {}
+        void set g(ToVoid<dynamic> x) {}
+        void set h(int x) {}
+        /*severe:INVALID_METHOD_OVERRIDE*/void set i(dynamic x) {}
+      }
+       ''');
+  });
+
+  test('field override, fuzzy arrows', () {
+    checkFile('''
+      typedef void ToVoid<T>(T x);
+      class F {
+        final ToVoid<dynamic> f = null;
+        final ToVoid<int> g = null;
+      }
+
+      class G extends F {
+        /*severe:INVALID_FIELD_OVERRIDE*/final ToVoid<int> f = null;
+        /*severe:INVALID_FIELD_OVERRIDE, severe:INVALID_METHOD_OVERRIDE*/final ToVoid<dynamic> g = null;
+      }
+
+      class H implements F {
+        final ToVoid<int> f = null;
+        /*severe:INVALID_METHOD_OVERRIDE*/final ToVoid<dynamic> g = null;
+      }
+       ''');
+  });
+
   test('generic class method override', () {
     checkFile('''
           class A {}
           class B extends A {}
 
           class Base<T extends B> {
             T foo() => null;
           }
 
           class Derived<S extends A> extends Base<B> {
@@ skipping 609 matching lines @@
 
             class I1 {
                 m(B a) {}
             }
 
             class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T1
                 /*severe:INVALID_METHOD_OVERRIDE*/extends Base
                 implements I1 {}
 
             class T2 extends Base implements I1 {
-                /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/m(a) {}
+                m(a) {}
             }
 
             class /*warning:INCONSISTENT_METHOD_INHERITANCE*/T3
                 extends Object with /*severe:INVALID_METHOD_OVERRIDE*/Base
                 implements I1 {}
 
             class T4 extends Object with Base implements I1 {
-                /*severe:INVALID_METHOD_OVERRIDE,severe:INVALID_METHOD_OVERRIDE*/m(a) {}
+                m(a) {}
             }
          ''');
     });
   });
 
   group('class override of grand interface', () {
     test('interface of interface of child', () {
       checkFile('''
               class A {}
               class B {}
@@ skipping 564 matching lines @@
 
         baz1() sync* { yield* /*info:DYNAMIC_CAST*/x; }
         Iterable baz2() sync* { yield* /*info:DYNAMIC_CAST*/x; }
         Iterable<int> baz3() sync* { yield* /*warning:DOWN_CAST_COMPOSITE*/x; }
         Iterable<int> baz4() sync* { yield* bar3(); }
         Iterable<int> baz5() sync* { yield* /*info:INFERRED_TYPE_ALLOCATION*/new List(); }
     ''');
     });
   });
 }