Allow S->T <: dynamic->T

test/checker/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.
 
 /// General type checking tests
 library dev_compiler.test.checker_test;
 
 import 'package:unittest/unittest.dart';
 
 import 'package:dev_compiler/src/testing.dart';
 
 import '../test_util.dart';
 
 void main() {
   configureTest();
 
   test('conversion and dynamic invoke', () {
     testChecker({
       '/main.dart': '''
       class A {
         String x = "hello world";
+
+        void baz1(y) => x + y;
+        static baz2(y) => y + y;
       }
 
       void foo(String str) {
         print(str);
       }
 
       void bar(a) {
         foo(/*info:DownCast,warning:DynamicInvoke*/a.x);
       }
 
-      void main() => bar(new A());
+      typedef DynFun(x);
+      typedef StrFun(String x);
+
+      var bar1 = bar;
+
+      void main() {
+        var a = new A();
+        bar(a);
+        (/*warning:DynamicInvoke*/bar1(a));
+        var b = bar;
+        (/*warning:DynamicInvoke*/b(a));
+        var f1 = foo;
+        f1("hello");
+        dynamic f2 = foo;
+        (/*warning:DynamicInvoke*/f2("hello"));
+        DynFun f3 = foo;
+        (/*warning:DynamicInvoke*/f3("hello"));
+        (/*warning:DynamicInvoke*/f3(42));
+        StrFun f4 = foo;
+        f4("hello");
+        a.baz1("hello");
+        var b1 = a.baz1;
+        (/*warning:DynamicInvoke*/b1("hello"));
+        A.baz2("hello");
+        var b2 = A.baz2;
+        (/*warning:DynamicInvoke*/b2("hello"));
     '''
     });
   });
 
   test('Primitives', () {
     testChecker({
       '/main.dart': '''
         int /*severe:InvalidVariableDeclaration*/a;
         double /*severe:InvalidVariableDeclaration*/b;
         num c;
@@ skipping 407 matching lines @@
    '''
     });
   });
 
   test('Function typing and subtyping: dynamic', () {
     testChecker({
       '/main.dart': '''
 
       class A {}
 
-      typedef dynamic Top(A x);         // Top of the lattice
-      typedef A Left(A x);              // Left branch
-      typedef dynamic Right(dynamic x); // Right branch
-      typedef A Bot(dynamic x);         // Bottom of the lattice
+      // Note: because we allow A->B <: dynamic->B, we have circularity

[Leaf, 2015/03/18 22:57:26]

This comment is no longer true, I think?

[vsm, 2015/03/18 23:40:32]

Removed

+      // in the subtyping here, and it's not a true lattice.  In addition
+      // to the below, we also have Top <: Right.
+      typedef dynamic Left(A x);         // Real left

[Leaf, 2015/03/18 22:57:26]

Nit: Sorting Top -> Left, Right -> Bottom makes this a little easier to read.  

[vsm, 2015/03/18 23:40:32]

Done.

+      typedef A Bottom(A x);              // Real bottom
+      typedef dynamic Top(dynamic x); // Real top
+      typedef A Right(dynamic x);         // Real right
 
-      dynamic top(A x) => x;
-      A left(A x) => x;
-      dynamic right(dynamic x) => x;
-      A bot(dynamic x) => /*info:DownCast*/x;
+      dynamic left(A x) => x;
+      A bot(A x) => x;
+      dynamic top(dynamic x) => x;
+      A right(dynamic x) => /*info:DownCast*/x;
 
       void main() {
         {
           Top f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Left f;
           f = /*warning:ClosureWrap*/top;
           f = left;
           f = /*warning:ClosureWrap*/right;
           f = bot;
         }
         {
           Right f;
           f = /*warning:ClosureWrap*/top;
           f = /*warning:ClosureWrap*/left;
           f = right;
           f = bot;
         }
         {
-          Bot f;
+          Bottom f;
           f = /*warning:ClosureWrap*/top;
           f = /*warning:ClosureWrap*/left;
           f = /*warning:ClosureWrap*/right;
           f = bot;
         }
       }
    '''
     });
   });
 
@@ skipping 395 matching lines @@
       '/main.dart': '''
       typedef T F<T>(T t1, T t2);
       typedef dynamic D(t1, t2);
 
       void main() {
         F f1 = (x, y) => x + y;
         F<int> f2 = /*warning:ClosureWrapLiteral*/(x, y) => x + y;
         D f3 = (x, y) => x + y;
         Function f4 = (x, y) => x + y;
         f2 = /*warning:ClosureWrap*/f1;
-        f1 = /*warning:ClosureWrapLiteral*/(int x, int y) => x + y;
+        f1 = (int x, int y) => x + y;
         f2 = /*severe:StaticTypeError*/(int x) => -x;
       }
    '''
     });
   });
 
   test('Generic subtyping: invariance', () {
     testChecker({
       '/main.dart': '''
 
@@ skipping 676 matching lines @@
             B f1;
             B f2;
             B f3;
             B f4;
           }
 
           class Child extends Base {
             /*severe:InvalidMethodOverride*/A f1; // invalid for getter
             /*severe:InvalidMethodOverride*/C f2; // invalid for setter
             var f3;
-            /*severe:InvalidMethodOverride*/dynamic f4;
+            /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/dynamic f4;
           }
        '''
     }, inferFromOverrides: true);
 
     testChecker({
       '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           class Base {
             B f1;
             B f2;
             B f3;
             B f4;
           }
 
           class Child extends Base {
             /*severe:InvalidMethodOverride*/A f1; // invalid for getter
             /*severe:InvalidMethodOverride*/C f2; // invalid for setter
-            /*severe:InferableOverride*/var f3;
-            /*severe:InvalidMethodOverride*/dynamic f4;
+            /*severe:InferableOverride,severe:InvalidMethodOverride*/var f3;
+            /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/dynamic f4;
           }
        '''
     }, inferFromOverrides: false);
   });
 
   test('getter/getter override', () {
     testChecker({
       '/main.dart': '''
           class A {}
           class B extends A {}
@@ skipping 73 matching lines @@
             void set f1(B value);
             void set f2(B value);
             void set f3(B value);
             void set f4(B value);
             void set f5(B value);
           }
 
           class Child extends Base {
             void set f1(A value) {}
             /*severe:InvalidMethodOverride*/void set f2(C value) {}
-            void set f3(value) {}
-            void set f4(dynamic value) {}
+            /*severe:InvalidMethodOverride*/void set f3(value) {}
+            /*severe:InvalidMethodOverride*/void set f4(dynamic value) {}
             set f5(B value) {}
           }
        '''
     });
   });
 
   test('field/setter override', () {
     testChecker({
       '/main.dart': '''
           class A {}
@@ skipping 10 matching lines @@
 
           class Child extends Base {
             B get f1 => null;
             B get f2 => null;
             B get f3 => null;
             B get f4 => null;
             B get f5 => null;
 
             void set f1(A value) {}
             /*severe:InvalidMethodOverride*/void set f2(C value) {}
-            void set f3(value) {}
-            void set f4(dynamic value) {}
+            /*severe:InvalidMethodOverride*/void set f3(value) {}
+            /*severe:InvalidMethodOverride*/void set f4(dynamic value) {}
             set f5(B value) {}
           }
        '''
     });
   });
 
   test('method override', () {
     testChecker({
       '/main.dart': '''
           class A {}
           class B extends A {}
           class C extends B {}
 
           class Base {
             B m1(B a);
             B m2(B a);
             B m3(B a);
             B m4(B a);
             B m5(B a);
             B m6(B a);
           }
 
           class Child extends Base {
             /*severe:InvalidMethodOverride*/A m1(A value) {}
             /*severe:InvalidMethodOverride*/C m2(C value) {}
             /*severe:InvalidMethodOverride*/A m3(C value) {}
             C m4(A value) {}
-            m5(value) {}
+            /*severe:InvalidMethodOverride*/m5(value) {}
             /*severe:InvalidMethodOverride*/dynamic m6(dynamic value) {}
           }
        '''
     }, inferFromOverrides: true);
   });
 
   test('binary operators', () {
     testChecker({
       '/main.dart': '''
           class A {
@@ skipping 413 matching lines @@
             }
 
             class I1 {
                 m(B a) {}
             }
 
             class T1 /*severe:InvalidMethodOverride*/extends Base
                 implements I1 {}
 
             class T2 extends Base implements I1 {
-                m(a) {}
+                /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/m(a) {}

[Leaf, 2015/03/18 22:57:26]

We may want to treat this differently long term.  Semantically, we are treating
this as being m(Object a), which is a valid override.  Basically the same
"optimization" that applies to your isDynamicCall function applies here: m is a
concrete method which will not be reified as dynamic -> dynamic, but rather as
Object -> dynamic.

[vsm, 2015/03/18 23:40:32]

Agree.  It seems as though we want the static type of m to be Object->dynamic,
but the static type of a to still be dynamic.

If we do this, a bunch of the DynamicInvokes in my test above also disappear.

             }
 
             class T3 extends Object with /*severe:InvalidMethodOverride*/Base
                 implements I1 {}
 
             class T4 extends Object with Base implements I1 {
-                m(a) {}
+                /*severe:InvalidMethodOverride,severe:InvalidMethodOverride*/m(a) {}
             }
          '''
       });
     });
 
     group('class override of grand interface', () {
       test('interface of interface of child', () {
         testChecker({
           '/main.dart': '''
               class A {}
@@ skipping 484 matching lines @@
         '/main.dart': '''
             class A {}
             class T1 implements A {
                 /*severe:InferableOverride*/toString() {}
             }
          '''
       }, inferFromOverrides: false);
     });
   });
 }