Disable closure wrapping by default

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';
@@ skipping 368 matching lines @@
       int left(int x) => x;
       Object right(Object x) => x;
       int _bot(Object x) => /*warning:DownCastImplicit*/x;
       int bot(Object x) => x as int;
 
       void main() {
         { // Check typedef equality
           Left f = left;
           Left2 g = f;
         }
-        // TODO(leafp) Decide on ClosureWrap vs DownCast (or error).
         {
           Top f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Left f;
-          f = /*warning:ClosureWrap*/top;
+          f = /*warning:DownCastComposite*/top;
           f = left;
-          f = /*warning:ClosureWrap*/right; // Should we reject this?
+          f = /*warning:DownCastComposite*/right; // Should we reject this?
           f = bot;
         }
         {
           Right f;
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left; // Should we reject this?
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left; // Should we reject this?
           f = right;
           f = bot;
         }
         {
           Bot f;
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left;
-          f = /*warning:ClosureWrap*/right;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/right;
           f = bot;
         }
       }
    '''
     });
   });
 
   test('Function typing and subtyping: classes', () {
     testChecker({
       '/main.dart': '''
@@ skipping 20 matching lines @@
         }
         {
           Top f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Left f;
-          f = /*warning:ClosureWrap*/top;
+          f = /*warning:DownCastComposite*/top;
           f = left;
-          f = /*warning:ClosureWrap*/right; // Should we reject this?
+          f = /*warning:DownCastComposite*/right; // Should we reject this?
           f = bot;
         }
         {
           Right f;
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left; // Should we reject this?
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left; // Should we reject this?
           f = right;
           f = bot;
         }
         {
           Bot f;
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left;
-          f = /*warning:ClosureWrap*/right;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/right;
           f = bot;
         }
       }
    '''
     });
   });
 
   test('Function typing and subtyping: dynamic', () {
     testChecker({
       '/main.dart': '''
@@ skipping 13 matching lines @@
       void main() {
         {
           Top f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Left f;
-          f = /*warning:ClosureWrap*/top;
+          f = /*warning:DownCastComposite*/top;
           f = left;
-          f = /*warning:ClosureWrap*/right;
+          f = /*warning:DownCastComposite*/right;
           f = bot;
         }
         {
           Right f;
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
           f = right;
           f = bot;
         }
         {
           Bottom f;
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left;
-          f = /*warning:ClosureWrap*/right;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/right;
           f = bot;
         }
       }
    '''
     });
   });
 
   test('Function typing and subtyping: function literal variance', () {
     testChecker({
       '/main.dart': '''
@@ skipping 11 matching lines @@
       void main() {
         {
           Function2<B, A> f;
           f = top;
           f = left;
           f = right;
           f = bot;
         }
         {
           Function2<B, B> f;
-          f = /*warning:ClosureWrap*/top;
+          f = /*warning:DownCastComposite*/top;
           f = left;
-          f = /*warning:ClosureWrap*/right; // Should we reject this?
+          f = /*warning:DownCastComposite*/right; // Should we reject this?
           f = bot;
         }
         {
           Function2<A, A> f;
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left; // Should we reject this?
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left; // Should we reject this?
           f = right;
           f = bot;
         }
         {
           Function2<A, B> f;
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left;
-          f = /*warning:ClosureWrap*/right;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/right;
           f = bot;
         }
       }
    '''
     });
   });
 
   test('Function typing and subtyping: function variable variance', () {
     testChecker({
       '/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;
           Function2<A, A> right;
           Function2<A, B> bot;
 
           top = right;
           top = bot;
           top = top;
           top = left;
 
-          left = /*warning:ClosureWrap*/top;
+          left = /*warning:DownCastComposite*/top;
           left = left;
-          left = /*warning:ClosureWrap*/right; // Should we reject this?
+          left = /*warning:DownCastComposite*/right; // Should we reject this?
           left = bot;
 
-          right = /*warning:ClosureWrap*/top;
-          right = /*warning:ClosureWrap*/left; // Should we reject this?
+          right = /*warning:DownCastComposite*/top;
+          right = /*warning:DownCastComposite*/left; // Should we reject this?
           right = right;
           right = bot;
 
-          bot = /*warning:ClosureWrap*/top;
-          bot = /*warning:ClosureWrap*/left;
-          bot = /*warning:ClosureWrap*/right;
+          bot = /*warning:DownCastComposite*/top;
+          bot = /*warning:DownCastComposite*/left;
+          bot = /*warning:DownCastComposite*/right;
           bot = bot;
         }
       }
    '''
     });
   });
 
   test('Function typing and subtyping: higher order function literals', () {
     testChecker({
       '/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:ClosureWrap*/f;
+      AToB _bot(BToA f) => /*warning:DownCastComposite*/f;
       AToB bot(BToA f) => f as AToB;
 
       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:ClosureWrap*/f;
+      Function2<A, B> _bot(BToA f) => /*warning:DownCastComposite*/f;
       Function2<A, B> bot(BToA f) => f as Function2<A, B>;
 
 
       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:ClosureWrap*/f;
+      AToB _bot(Function2<B, A> f) => /*warning:DownCastComposite*/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:ClosureWrap*/top;
+          f = /*warning:DownCastComposite*/top;
           f = left;
-          f = /*warning:ClosureWrap*/right; // Should we reject this?
+          f = /*warning:DownCastComposite*/right; // Should we reject this?
           f = bot;
         }
         {
           Function2<BToA, BToA> f; // Right
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left; // Should we reject this?
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left; // Should we reject this?
           f = right;
           f = bot;
         }
         {
           Function2<BToA, AToB> f; // Bot
           f = bot;
-          f = /*warning:ClosureWrap*/left;
-          f = /*warning:ClosureWrap*/top;
-          f = /*warning:ClosureWrap*/left;
+          f = /*warning:DownCastComposite*/left;
+          f = /*warning:DownCastComposite*/top;
+          f = /*warning:DownCastComposite*/left;
         }
       }
    '''
     });
   });
 
   test('Function typing and subtyping: higher order function variables', () {
     testChecker({
       '/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;
           Function2<Function2<A, B>, Function2<A, B>> left;
           Function2<Function2<B, A>, Function2<A, B>> bot;
 
           top = right;
           top = bot;
           top = top;
           top = left;
 
-          left = /*pass should be warning:ClosureWrap*/top;
+          left = /*pass should be warning:DownCastComposite*/top;

[vsm, 2015/04/03 21:09:34]

We're missing handling of typedefs it appears.

[Leaf, 2015/04/03 21:24:59]

I think this is dartbug.com/21912

           left = left;
           left = /*pass should be severe:StaticTypeError*/right;
           left = bot;
 
-          right = /*pass should be warning:ClosureWrap*/top;
+          right = /*pass should be warning:DownCastComposite*/top;
           right = /*pass should be severe:StaticTypeError*/left;
           right = right;
           right = bot;
 
-          bot = /*pass should be warning:ClosureWrap*/top;
-          bot = /*pass should be warning:ClosureWrap*/left;
-          bot = /*pass should be warning:ClosureWrap*/right;
+          bot = /*pass should be warning:DownCastComposite*/top;
+          bot = /*pass should be warning:DownCastComposite*/left;
+          bot = /*pass should be warning:DownCastComposite*/right;
           bot = bot;
         }
       }
    '''
     });
   });
 
   test('Function typing and subtyping: named and optional parameters', () {
     testChecker({
       '/main.dart': '''
@@ skipping 24 matching lines @@
          r = r;
          r = o;
          r = /*severe:StaticTypeError*/n;
          r = /*severe:StaticTypeError*/rr;
          r = ro;
          r = rn;
          r = oo;
          r = /*severe:StaticTypeError*/nn;
          r = /*severe:StaticTypeError*/nnn;
 
-         o = /*severe:StaticTypeError*/r;
+         o = /*warning:DownCastComposite*/r;
          o = o;
          o = /*severe:StaticTypeError*/n;
          o = /*severe:StaticTypeError*/rr;
          o = /*severe:StaticTypeError*/ro;
          o = /*severe:StaticTypeError*/rn;
          o = oo;
          o = /*severe:StaticTypeError*/nn
          o = /*severe:StaticTypeError*/nnn;
 
          n = /*severe:StaticTypeError*/r;
          n = /*severe:StaticTypeError*/o;
          n = n;
          n = /*severe:StaticTypeError*/rr;
          n = /*severe:StaticTypeError*/ro;
          n = /*severe:StaticTypeError*/rn;
          n = /*severe:StaticTypeError*/oo;
          n = nn;
          n = nnn;
 
          rr = /*severe:StaticTypeError*/r;
          rr = /*severe:StaticTypeError*/o;
          rr = /*severe:StaticTypeError*/n;
          rr = rr;
          rr = ro;
          rr = /*severe:StaticTypeError*/rn;
          rr = oo;
          rr = /*severe:StaticTypeError*/nn;
          rr = /*severe:StaticTypeError*/nnn;
 
-         ro = /*severe:StaticTypeError*/r;
+         ro = /*warning:DownCastComposite*/r;

[vsm, 2015/04/03 21:09:34]

Note: these used to be a static error.  A down cast is legal here, but perhaps
likely to fail (as with most DCCs).

          ro = /*severe:StaticTypeError*/o;
          ro = /*severe:StaticTypeError*/n;
-         ro = /*severe:StaticTypeError*/rr;
+         ro = /*warning:DownCastComposite*/rr;
          ro = ro;
          ro = /*severe:StaticTypeError*/rn;
          ro = oo;
          ro = /*severe:StaticTypeError*/nn;
          ro = /*severe:StaticTypeError*/nnn;
 
-         rn = /*severe:StaticTypeError*/r;
+         rn = /*warning:DownCastComposite*/r;
          rn = /*severe:StaticTypeError*/o;
          rn = /*severe:StaticTypeError*/n;
          rn = /*severe:StaticTypeError*/rr;
          rn = /*severe:StaticTypeError*/ro;
          rn = rn;
          rn = /*severe:StaticTypeError*/oo;
          rn = /*severe:StaticTypeError*/nn;
          rn = /*severe:StaticTypeError*/nnn;
 
-         oo = /*severe:StaticTypeError*/r;
-         oo = /*severe:StaticTypeError*/o;
+         oo = /*warning:DownCastComposite*/r;
+         oo = /*warning:DownCastComposite*/o;
          oo = /*severe:StaticTypeError*/n;
-         oo = /*severe:StaticTypeError*/rr;
-         oo = /*severe:StaticTypeError*/ro;
+         oo = /*warning:DownCastComposite*/rr;
+         oo = /*warning:DownCastComposite*/ro;
          oo = /*severe:StaticTypeError*/rn;
          oo = oo;
          oo = /*severe:StaticTypeError*/nn;
          oo = /*severe:StaticTypeError*/nnn;
 
          nn = /*severe:StaticTypeError*/r;
          nn = /*severe:StaticTypeError*/o;
-         nn = /*severe:StaticTypeError*/n;
+         nn = /*warning:DownCastComposite*/n;
          nn = /*severe:StaticTypeError*/rr;
          nn = /*severe:StaticTypeError*/ro;
          nn = /*severe:StaticTypeError*/rn;
          nn = /*severe:StaticTypeError*/oo;
          nn = nn;
          nn = nnn;
 
          nnn = /*severe:StaticTypeError*/r;
          nnn = /*severe:StaticTypeError*/o;
-         nnn = /*severe:StaticTypeError*/n;
+         nnn = /*warning:DownCastComposite*/n;
          nnn = /*severe:StaticTypeError*/rr;
          nnn = /*severe:StaticTypeError*/ro;
          nnn = /*severe:StaticTypeError*/rn;
          nnn = /*severe:StaticTypeError*/oo;
-         nnn = /*severe:StaticTypeError*/nn;
+         nnn = /*warning:DownCastComposite*/nn;
          nnn = nnn;
       }
    '''
     });
   });
 
   test('Function subtyping: objects with call methods', () {
     testChecker({
       '/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:StaticTypeError*/new B();
            f = i2i;
-           f = /*warning:ClosureWrap*/n2n;
+           f = /*warning:DownCastComposite*/n2n;
            f = /*warning:DownCastComposite*/(i2i as Object);
            f = /*warning:DownCastComposite*/(n2n as Function);
          }
          {
            N2N f;
            f = /*severe:StaticTypeError*/new A();
            f = new B();
-           f = /*warning:ClosureWrap*/i2i;
+           f = /*warning:DownCastComposite*/i2i;
            f = n2n;
            f = /*warning:DownCastComposite*/(i2i as Object);
            f = /*warning:DownCastComposite*/(n2n as Function);
          }
          {
            A f;
            f = new A();
            f = /*severe:StaticTypeError*/new B();
            f = /*severe:StaticTypeError*/i2i;
            f = /*severe:StaticTypeError*/n2n;
@@ skipping 44 matching lines @@
       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 = (int x, int y) => x + y;
         f2 = /*severe:StaticTypeError*/(int x) => -x;
       }
    '''
-    });
+    }, wrapClosures: true);
   });
 
   test('Generic subtyping: invariance', () {
     testChecker({
       '/main.dart': '''
 
       class A {}
       class B extends A {}
       class C implements A {}
 
@@ skipping 1850 matching lines @@
             f = bar as II2D;
             f = bar as DD2I;
             f = bar as DI2D;
             f = bar as ID2D;
             f = bar as DD2D;
           }
       '''
     });
   });
 }