fixes #25640, errors on function downcasts when we know it's an exact type

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 265 matching lines @@
   testChecker('Void subtyping', {
     '/main.dart': '''
       typedef int Foo();
       void foo() {}
       void main () {
         Foo x = /*severe:STATIC_TYPE_ERROR*/foo();
       }
    '''
   });
 
-  testChecker('Ground type subtyping: dynamic is top', {
-    '/main.dart': '''
+  group('Ground type subtyping:', () {
+    testChecker('dynamic is top', {
+      '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          y = o;
          y = i;
          y = d;
          y = n;
          y = a;
          y = b;
       }
    '''
-  });
+    });
 
-  testChecker('Ground type subtyping: dynamic downcasts', {
-    '/main.dart': '''
+    testChecker('dynamic downcasts', {
+      '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          o = y;
          i = /*info:DYNAMIC_CAST*/y;
          d = /*info:DYNAMIC_CAST*/y;
          n = /*info:DYNAMIC_CAST*/y;
          a = /*info:DYNAMIC_CAST*/y;
          b = /*info:DYNAMIC_CAST*/y;
       }
    '''
-  });
+    });
 
-  testChecker('Ground type subtyping: assigning a class', {
-    '/main.dart': '''
+    testChecker('assigning a class', {
+      '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          y = a;
          o = a;
          i = /*severe:STATIC_TYPE_ERROR*/a;
          d = /*severe:STATIC_TYPE_ERROR*/a;
          n = /*severe:STATIC_TYPE_ERROR*/a;
          a = a;
          b = /*info:DOWN_CAST_IMPLICIT*/a;
       }
    '''
-  });
+    });
 
-  testChecker('Ground type subtyping: assigning a subclass', {
-    '/main.dart': '''
+    testChecker('assigning a subclass', {
+      '/main.dart': '''
 
       class A {}
       class B extends A {}
       class C extends A {}
 
       void main() {
          dynamic y;
          Object o;
          int i = 0;
          double d = 0.0;
          num n;
          A a;
          B b;
          C c;
          y = b;
          o = b;
          i = /*severe:STATIC_TYPE_ERROR*/b;
          d = /*severe:STATIC_TYPE_ERROR*/b;
          n = /*severe:STATIC_TYPE_ERROR*/b;
          a = b;
          b = b;
          c = /*severe:STATIC_TYPE_ERROR*/b;
       }
    '''
-  });
+    });
 
-  testChecker('Ground type subtyping: interfaces', {
-    '/main.dart': '''
+    testChecker('interfaces', {
+      '/main.dart': '''
 
       class A {}
       class B extends A {}
       class C extends A {}
       class D extends B implements C {}
 
       void main() {
          A top;
          B left;
          C right;
@@ skipping 17 matching lines @@
            right = bot;
          }
          {
            bot = /*info:DOWN_CAST_IMPLICIT*/top;
            bot = /*info:DOWN_CAST_IMPLICIT*/left;
            bot = /*info:DOWN_CAST_IMPLICIT*/right;
            bot = bot;
          }
       }
    '''
+    });
   });
 
-  testChecker('Function typing and subtyping: int and object', {
-    '/main.dart': '''
+  group('Function typing and subtyping:', () {
+    testChecker('int and object', {
+      '/main.dart': '''
 
       typedef Object Top(int x);      // Top of the lattice
       typedef int Left(int x);        // Left branch
       typedef int Left2(int x);       // Left branch
       typedef Object Right(Object x); // Right branch
       typedef int Bot(Object x);      // Bottom of the lattice
 
-      Object top(int x) => x;
-      int left(int x) => x;
-      Object right(Object x) => x;
+      Object globalTop(int x) => x;
+      int globalLeft(int x) => x;
+      Object globalRight(Object x) => x;
       int _bot(Object x) => /*info:DOWN_CAST_IMPLICIT*/x;
-      int bot(Object x) => x as int;
+      int globalBot(Object x) => x as int;
 
       void main() {
+        // Note: use locals so we only know the type, not that it's a specific
+        // function declaration. (we can issue better errors in that case.)
+        var top = globalTop;
+        var left = globalLeft;
+        var right = globalRight;
+        var bot = globalBot;

[vsm, 2016/02/03 23:52:00]

Perhaps a test to cover the static method case (error) and the instance method
case (downcast composite?).

[Jennifer Messerly, 2016/02/04 00:41:30]

instance methods are covered by this test (line 1640):
https://codereview.chromium.org/1663533002/diff/1/pkg/analyzer/test/src/task/...

Static methods are currently treated as a warning (downcast composite). They're
a bit of an odd case ... at the moment, we could safely issue an error. If we
got metaclasses: https://github.com/gbracha/metaclasses/blob/master/proposal.md
... it wouldn't be safe to issue an error anymore. I could add it with a TODO
about metaclass issue, if that sounds good? Or we could just leave it as a
warning, and say that's good enough.

+
         { // Check typedef equality
           Left f = left;
           Left2 g = f;
         }
         {
           Top f;
           f = top;
           f = left;
           f = right;
           f = bot;
@@ skipping 14 matching lines @@
         }
         {
           Bot f;
           f = /*warning:DOWN_CAST_COMPOSITE*/top;
           f = /*warning:DOWN_CAST_COMPOSITE*/left;
           f = /*warning:DOWN_CAST_COMPOSITE*/right;
           f = bot;
         }
       }
    '''
-  });
+    });
 
-  testChecker('Function typing and subtyping: classes', {
-    '/main.dart': '''
+    testChecker('classes', {
+      '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       typedef A Top(B x);   // Top of the lattice
       typedef B Left(B x);  // Left branch
       typedef B Left2(B x); // Left branch
       typedef A Right(A x); // Right branch
       typedef B Bot(A x);   // Bottom of the lattice
 
@@ skipping 10 matching lines @@
         }
         {
           Top f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Left f;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/top;

[vsm, 2016/02/03 23:52:00]

nice!

           f = left;
-          f = /*warning:DOWN_CAST_COMPOSITE*/right; // Should we reject this?
+          f = /*severe:STATIC_TYPE_ERROR*/right;
           f = bot;
         }
         {
           Right f;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
-          f = /*warning:DOWN_CAST_COMPOSITE*/left; // Should we reject this?
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
           f = right;
           f = bot;
         }
         {
           Bot f;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
-          f = /*warning:DOWN_CAST_COMPOSITE*/left;
-          f = /*warning:DOWN_CAST_COMPOSITE*/right;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+          f = /*severe:STATIC_TYPE_ERROR*/right;
           f = bot;
         }
       }
    '''
-  });
+    });
 
-  testChecker('Function typing and subtyping: dynamic', {
-    '/main.dart': '''
+    testChecker('dynamic', {
+      '/main.dart': '''
 
       class A {}
 
       typedef dynamic Top(dynamic x);     // Top of the lattice
       typedef dynamic Left(A x);          // Left branch
       typedef A Right(dynamic x);         // Right branch
       typedef A Bottom(A x);              // Bottom of the lattice
 
       dynamic left(A x) => x;
       A bot(A x) => x;
       dynamic top(dynamic x) => x;
       A right(dynamic x) => /*info:DYNAMIC_CAST*/x;
 
       void main() {
         {
           Top f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Left f;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
           f = left;
-          f = /*warning:DOWN_CAST_COMPOSITE*/right;
+          f = /*severe:STATIC_TYPE_ERROR*/right;
           f = bot;
         }
         {
           Right f;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
-          f = /*warning:DOWN_CAST_COMPOSITE*/left;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
           f = right;
           f = bot;
         }
         {
           Bottom f;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
-          f = /*warning:DOWN_CAST_COMPOSITE*/left;
-          f = /*warning:DOWN_CAST_COMPOSITE*/right;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+          f = /*severe:STATIC_TYPE_ERROR*/right;
           f = bot;
         }
       }
    '''
-  });
+    });
 
-  testChecker('Function typing and subtyping: function literal variance', {
-    '/main.dart': '''
+    testChecker('function literal variance', {
+      '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       typedef T Function2<S, T>(S z);
 
       A top(B x) => x;
       B left(B x) => x;
       A right(A x) => x;
       B bot(A x) => x as B;
 
       void main() {
         {
           Function2<B, A> f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Function2<B, B> f;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
           f = left;
-          f = /*warning:DOWN_CAST_COMPOSITE*/right; // Should we reject this?
+          f = /*severe:STATIC_TYPE_ERROR*/right;
           f = bot;
         }
         {
           Function2<A, A> f;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
-          f = /*warning:DOWN_CAST_COMPOSITE*/left; // Should we reject this?
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
           f = right;
           f = bot;
         }
         {
           Function2<A, B> f;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
-          f = /*warning:DOWN_CAST_COMPOSITE*/left;
-          f = /*warning:DOWN_CAST_COMPOSITE*/right;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+          f = /*severe:STATIC_TYPE_ERROR*/right;
           f = bot;
         }
       }
    '''
-  });
+    });
 
-  testChecker('Function typing and subtyping: function variable variance', {
-    '/main.dart': '''
+    testChecker('function variable variance', {
+      '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       typedef T Function2<S, T>(S z);
 
       void main() {
         {
           Function2<B, A> top;
           Function2<B, B> left;
@@ skipping 15 matching lines @@
           right = right;
           right = bot;
 
           bot = /*warning:DOWN_CAST_COMPOSITE*/top;
           bot = /*warning:DOWN_CAST_COMPOSITE*/left;
           bot = /*warning:DOWN_CAST_COMPOSITE*/right;
           bot = bot;
         }
       }
    '''
-  });
+    });
 
-  testChecker('Function typing and subtyping: higher order function literals', {
-    '/main.dart': '''
+    testChecker('higher order function literals 1', {
+      '/main.dart': '''
 
       class A {}
       class B extends A {}
 
       typedef T Function2<S, T>(S z);
 
       typedef A BToA(B x);  // Top of the base lattice
       typedef B AToB(A x);  // Bot of the base lattice
 
       BToA top(AToB f) => f;
       AToB left(AToB f) => f;
       BToA right(BToA f) => f;
       AToB _bot(BToA f) => /*warning:DOWN_CAST_COMPOSITE*/f;
       AToB bot(BToA f) => f as AToB;

[Jennifer Messerly, 2016/02/02 22:15:05]

it's hard to see in the diff, but the original code here was busted ... there
were 3 definitions of "top", "left", etc. I presume this was supposed to be
split into 3 separate test cases. As it was, only one of the definitions were
actually tested, because of the name collision.

So I split it into 3 separate test cases. Should have coverage of them all now.

 
+      void main() {
+        {
+          Function2<AToB, BToA> f; // Top
+          f = top;
+          f = left;
+          f = right;
+          f = bot;
+        }
+        {
+          Function2<AToB, AToB> f; // Left
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = left;
+          f = /*severe:STATIC_TYPE_ERROR*/right;
+          f = bot;
+        }
+        {
+          Function2<BToA, BToA> f; // Right
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+          f = right;
+          f = bot;
+        }
+        {
+          Function2<BToA, AToB> f; // Bot
+          f = bot;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+        }
+      }
+   '''
+    });
+
+    testChecker('higher order function literals 2', {
+      '/main.dart': '''
+
+      class A {}
+      class B extends A {}
+
+      typedef T Function2<S, T>(S z);
+
+      typedef A BToA(B x);  // Top of the base lattice
+      typedef B AToB(A x);  // Bot of the base lattice
+
       Function2<B, A> top(AToB f) => f;
       Function2<A, B> left(AToB f) => f;
       Function2<B, A> right(BToA f) => f;
       Function2<A, B> _bot(BToA f) => /*warning:DOWN_CAST_COMPOSITE*/f;
       Function2<A, B> bot(BToA f) => f as Function2<A, B>;
 
+      void main() {
+        {
+          Function2<AToB, BToA> f; // Top
+          f = top;
+          f = left;
+          f = right;
+          f = bot;
+        }
+        {
+          Function2<AToB, AToB> f; // Left
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = left;
+          f = /*severe:STATIC_TYPE_ERROR*/right;
+          f = bot;
+        }
+        {
+          Function2<BToA, BToA> f; // Right
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+          f = right;
+          f = bot;
+        }
+        {
+          Function2<BToA, AToB> f; // Bot
+          f = bot;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+        }
+      }
+   '''
+    });
+
+    testChecker('higher order function literals 3', {
+      '/main.dart': '''
+
+      class A {}
+      class B extends A {}
+
+      typedef T Function2<S, T>(S z);
+
+      typedef A BToA(B x);  // Top of the base lattice
+      typedef B AToB(A x);  // Bot of the base lattice
 
       BToA top(Function2<A, B> f) => f;
       AToB left(Function2<A, B> f) => f;
       BToA right(Function2<B, A> f) => f;
       AToB _bot(Function2<B, A> f) => /*warning:DOWN_CAST_COMPOSITE*/f;
       AToB bot(Function2<B, A> f) => f as AToB;
 
       void main() {
         {
           Function2<AToB, BToA> f; // Top
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Function2<AToB, AToB> f; // Left
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
           f = left;
-          f = /*warning:DOWN_CAST_COMPOSITE*/right; // Should we reject this?
+          f = /*severe:STATIC_TYPE_ERROR*/right;
           f = bot;
         }
         {
           Function2<BToA, BToA> f; // Right
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
-          f = /*warning:DOWN_CAST_COMPOSITE*/left; // Should we reject this?
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
           f = right;
           f = bot;
         }
         {
           Function2<BToA, AToB> f; // Bot
           f = bot;
-          f = /*warning:DOWN_CAST_COMPOSITE*/left;
-          f = /*warning:DOWN_CAST_COMPOSITE*/top;
-          f = /*warning:DOWN_CAST_COMPOSITE*/left;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
+          f = /*severe:STATIC_TYPE_ERROR*/top;
+          f = /*severe:STATIC_TYPE_ERROR*/left;
         }
       }
    '''
-  });
+    });
 
-  testChecker(
-      'Function typing and subtyping: higher order function variables', {
-    '/main.dart': '''
+    testChecker('higher order function variables', {
+      '/main.dart': '''
 
     class A {}
     class B extends A {}
 
     typedef T Function2<S, T>(S z);
 
     void main() {
       {
         Function2<Function2<A, B>, Function2<B, A>> top;
         Function2<Function2<B, A>, Function2<B, A>> right;
@@ skipping 17 matching lines @@
         right = right;
         right = bot;
 
         bot = /*warning:DOWN_CAST_COMPOSITE*/top;
         bot = /*warning:DOWN_CAST_COMPOSITE*/left;
         bot = /*warning:DOWN_CAST_COMPOSITE*/right;
         bot = bot;
       }
     }
    '''
-  });
+    });
 
-  testChecker('Function typing and subtyping: named and optional parameters', {
-    '/main.dart': '''
+    testChecker('named and optional parameters', {
+      '/main.dart': '''
 
       class A {}
 
       typedef A FR(A x);
       typedef A FO([A x]);
       typedef A FN({A x});
       typedef A FRR(A x, A y);
       typedef A FRO(A x, [A y]);
       typedef A FRN(A x, {A n});
       typedef A FOO([A x, A y]);
@@ skipping 95 matching lines @@
          nnn = /*severe:STATIC_TYPE_ERROR*/o;
          nnn = /*warning:DOWN_CAST_COMPOSITE*/n;
          nnn = /*severe:STATIC_TYPE_ERROR*/rr;
          nnn = /*severe:STATIC_TYPE_ERROR*/ro;
          nnn = /*severe:STATIC_TYPE_ERROR*/rn;
          nnn = /*severe:STATIC_TYPE_ERROR*/oo;
          nnn = /*warning:DOWN_CAST_COMPOSITE*/nn;
          nnn = nnn;
       }
    '''
-  });
+    });
 
-  testChecker('Function subtyping: objects with call methods', {
-    '/main.dart': '''
+    testChecker('Function subtyping: objects with call methods', {
+      '/main.dart': '''
 
       typedef int I2I(int x);
       typedef num N2N(num x);
       class A {
          int call(int x) => x;
       }
       class B {
          num call(num x) => x;
       }
       int i2i(int x) => x;
       num n2n(num x) => x;
       void main() {
          {
            I2I f;
            f = new A();
            f = /*severe:STATIC_TYPE_ERROR*/new B();
            f = i2i;
-           f = /*warning:DOWN_CAST_COMPOSITE*/n2n;
+           f = /*severe:STATIC_TYPE_ERROR*/n2n;
            f = /*warning:DOWN_CAST_COMPOSITE*/i2i as Object;
            f = /*warning:DOWN_CAST_COMPOSITE*/n2n as Function;
          }
          {
            N2N f;
            f = /*severe:STATIC_TYPE_ERROR*/new A();
            f = new B();
-           f = /*warning:DOWN_CAST_COMPOSITE*/i2i;
+           f = /*severe:STATIC_TYPE_ERROR*/i2i;
            f = n2n;
            f = /*warning:DOWN_CAST_COMPOSITE*/i2i as Object;
            f = /*warning:DOWN_CAST_COMPOSITE*/n2n as Function;
          }
          {
            A f;
            f = new A();
            f = /*severe:STATIC_TYPE_ERROR*/new B();
            f = /*severe:STATIC_TYPE_ERROR*/i2i;
            f = /*severe:STATIC_TYPE_ERROR*/n2n;
@@ skipping 13 matching lines @@
            Function f;
            f = new A();
            f = new B();
            f = i2i;
            f = n2n;
            f = /*info:DOWN_CAST_IMPLICIT*/i2i as Object;
            f = (n2n as Function);
          }
       }
    '''
-  });
+    });
 
-  testChecker('Function typing and subtyping: void', {
-    '/main.dart': '''
+    testChecker('void', {
+      '/main.dart': '''
 
       class A {
         void bar() => null;
         void foo() => bar; // allowed
       }
    '''
-  });
+    });
 
-  testChecker('Function subtyping: uninferred closure', {
-    '/main.dart': '''
+    testChecker('uninferred closure', {
+      '/main.dart': '''
       typedef num Num2Num(num x);
       void main() {
         Num2Num g = /*info:INFERRED_TYPE_CLOSURE,severe:STATIC_TYPE_ERROR*/(int x) { return x; };
         print(g(42));
       }
     '''
+    });
   });
 
   testChecker('Relaxed casts', {
     '/main.dart': '''
 
       class A {}
 
       class L<T> {}
       class M<T> extends L<T> {}
       //     L<dynamic|Object>
@@ skipping 426 matching lines @@
             /*=S*/ then/*<S>*/(Object onValue(T t)) => null;
           }
 
           class DerivedFuture4<A> extends Future<A> {
             /*=B*/ then/*<B>*/(Object onValue(A a)) => null;
           }
       '''
   });
 
   testChecker('generic function wrong number of arguments', {
-      '/main.dart': r'''
+    '/main.dart': r'''
           /*=T*/ foo/*<T>*/(/*=T*/ x, /*=T*/ y) => x;
           /*=T*/ bar/*<T>*/({/*=T*/ x, /*=T*/ y}) => x;
 
           main() {
             // resolving thses shouldn't crash.
             foo(1, 2, 3);
             String x = foo('1', '2', '3');
             foo(1);
             String x = foo('1');
             x = /*severe:STATIC_TYPE_ERROR*/foo(1, 2, 3);
@@ skipping 1130 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* new Iterable<int>(); }
         Iterable<int> baz5() sync* { yield* (/*info:INFERRED_TYPE_ALLOCATION*/new Iterable()); }
     '''
     });
   });
 }