fix #28642, handling of top and bottom types in DDC

pkg/dev_compiler/test/browser/runtime_tests.js

 // 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.
 
 define(['dart_sdk'], function(dart_sdk) {
   const assert = chai.assert;
+  const async = dart_sdk.async;
   const core = dart_sdk.core;
   const collection = dart_sdk.collection;
   const dart = dart_sdk.dart;
   const dartx = dart.dartx;
 
 
   suite('generic', () => {
     "use strict";
 
     let generic = dart.generic;
@@ skipping 187 matching lines @@
 
     let cls7 = dart.fn((b, s, o) => { return null; },
                        dart.definiteFunctionType(B, [B, String], [Object]));
 
     let cls8 =
       dart.fn((b, s, o) => { return null; },
               dart.definiteFunctionType(B, [B, String], {p: Object}));
 
     function checkType(x, type, expectedTrue, strongOnly) {
       if (expectedTrue === undefined) expectedTrue = true;
-      if (strongOnly == undefined) strongOnly = false;
+      if (strongOnly === undefined) strongOnly = false;
       if (!strongOnly) {
         assert.doesNotThrow(() => instanceOf(x, type));
-        expect(instanceOf(x, type), expectedTrue);
+        expect(instanceOf(x, type), expectedTrue,
+          '"' + x + '" ' +
+          (expectedTrue ? 'should' : 'should not') +
+          ' be an instance of "' + dart.typeName(type) + '"');
       } else {
         assert.throws(() => instanceOf(x, type), dart.StrongModeError);
         expect(expectedTrue, false);
         expect(strongInstanceOf(x, type), null);
       }
     }
 
     test('int', () => {
       expect(isGroundType(int), true);
       expect(isGroundType(getReifiedType(5)), true);
@@ skipping 566 matching lines @@
 
     let functionType = dart.functionType;
     let definiteFunctionType = dart.definiteFunctionType;
     let typedef = dart.typedef;
     let isSubtype = dart.isSubtype;
     let int = core.int;
     let num = core.num;
     let dyn = dart.dynamic;
 
     function always(t1, t2) {
-      assert.equal(isSubtype(t1, t2), true);
+      assert.equal(isSubtype(t1, t2), true,
+          dart.toString(t1) +
+          " should always be a subtype of " +
+          dart.toString(t2));
     }
     function never(t1, t2) {
-      assert.equal(isSubtype(t1, t2), false);
+      assert.equal(isSubtype(t1, t2), false,
+          dart.toString(t1) +
+          " should never be a subtype of " +
+          dart.toString(t2));
     }
     function maybe(t1, t2) {
-      assert.equal(isSubtype(t1, t2), null);
+      assert.equal(isSubtype(t1, t2), null,
+          dart.toString(t1) +
+          " should maybe be a subtype of " +
+          dart.toString(t2));
     }
 
     function always2(t1, t2) {
-      assert.equal(isSubtype(t1, t2), true);
+      always(t1, t2);
       always(functionType(t1, [t2]), functionType(t2, [t1]));
     }
     function never2(t1, t2) {
-      assert.equal(isSubtype(t1, t2), false);
+      never(t1, t2);
       maybe(functionType(t1, [t2]), functionType(t2, [t1]));
     }
     function maybe2(t1, t2) {
-      assert.equal(isSubtype(t1, t2), null);
+      maybe(t1, t2);
       maybe(functionType(t1, [t2]), functionType(t2, [t1]));
     }
 
     function run_test(func1, func2, func2opt, func1extra, func2extra) {
       always2(func2(int, int), func2(int, int));
       always2(func2(int, num), func2(int, int));
       always2(func2(int, int), func2(num, int));
 
       always2(func2opt(int, int), func2opt(int, int));
       always2(func2opt(int, num), func2opt(int, int));
@@ skipping 79 matching lines @@
         return functionType(S, [], {extra: int});
       }
 
       function func2extra(S, T) {
         return functionType(S, [T], {extra: int});
       }
 
       run_test(func1, func2, func2opt, func1extra, func2extra);
     });
 
+    test('top and bottom types', () => {
+      let FutureOr = async.FutureOr$;
+      let tops = [
+        dart.dynamic,
+        core.Object,
+        dart.void,
+        FutureOr(dart.dynamic),
+        FutureOr(core.Object),
+        FutureOr(dart.void),
+        FutureOr(FutureOr(core.Object)),
+        // ... skip the (infinite) rest of the top types :D

[Leaf, 2017/02/06 21:11:59]

Probably for the best...

+      ];
+      let bottoms = [dart.bottom, core.Null];
+
+      for (let top of tops) {
+        for (let bottom of bottoms) {
+          always(bottom, top);
+          always(
+              definiteFunctionType(bottom, [top]),
+              definiteFunctionType(top, [bottom]));
+        }
+      }
+
+      for (let equalTypes of [tops, bottoms]) {
+        for (let t1 of equalTypes) {
+          for (let t2 of equalTypes) {
+            always(t1, t2);
+            always(t2, t1);
+
+            let t11 = definiteFunctionType(t1, [t1]);
+            let t22 = definiteFunctionType(t2, [t2]);
+            always(t11, t22);
+            always(t22, t11);
+          }
+        }
+      }
+    });
+
     test('basic typedefs', () => {
       function func1(S) {
         return dart.typedef('Func1', () => functionType(S, []))
       }
 
       function func2(S, T) {
         return dart.typedef('Func2', () => functionType(S, [T]))
       }
 
       function func2opt(S, T) {
@@ skipping 36 matching lines @@
       always(functionType(int, [], [int]), functionType(dyn, [], [dyn]));
       always(functionType(int, [], [int]), functionType(dyn, [dyn]));
       always(functionType(int, [], [int]), functionType(dyn, []));
       always(functionType(int, [int], {extra: int}), functionType(dyn, [dyn]));
 
       always(functionType(dyn, [dyn]), functionType(dyn, [dyn]));
       always(functionType(dyn, [], [dyn]), functionType(dyn, [], [dyn]));
       always(functionType(dyn, [], [dyn]), functionType(dyn, [dyn]));
       always(functionType(dyn, [], [dyn]), functionType(dyn, []));
       always(functionType(dyn, [dyn], {extra: dyn}), functionType(dyn, [dyn]));
-
     });
 
     test('void function types', () => {
       always(functionType(int, [int]), functionType(dart.void, [dyn]));
       always(functionType(int, [], [int]), functionType(dart.void, [], [dyn]));
       always(functionType(int, [], [int]), functionType(dart.void, [dyn]));
       always(functionType(int, [], [int]), functionType(dart.void, []));
       always(functionType(int, [int], {extra: int}), functionType(dart.void, [dyn]));
 
       always(functionType(dart.void, [int]), functionType(dart.void, [dyn]));
@@ skipping 13 matching lines @@
       always(functionType(dart.void, [], [dyn]), functionType(dart.void, [dyn]));
       always(functionType(dart.void, [], [dyn]), functionType(dart.void, []));
       always(functionType(dart.void, [dyn], {extra: dyn}), functionType(dart.void, [dyn]));
 
       always(functionType(dart.void, [int]), functionType(dyn, [dyn]));
       always(functionType(dart.void, [], [int]), functionType(dyn, [], [dyn]));
       always(functionType(dart.void, [], [int]), functionType(dyn, [dyn]));
       always(functionType(dart.void, [], [int]), functionType(dyn, []));
       always(functionType(dart.void, [int], {extra: int}), functionType(dyn, [dyn]));
 
-      never(functionType(dart.void, [int]), functionType(int, [dyn]));
-      never(functionType(dart.void, [], [int]), functionType(int, [], [dyn]));
-      never(functionType(dart.void, [], [int]), functionType(int, [dyn]));
-      never(functionType(dart.void, [], [int]), functionType(int, []));
-      never(functionType(dart.void, [int], {extra: int}), functionType(int, [dyn]));
+      maybe(functionType(dart.void, [int]), functionType(int, [dyn]));

[Leaf, 2017/02/06 21:11:59]

I'm worried about these changes, this could break code since we will throw an
error.

+      maybe(functionType(dart.void, [], [int]), functionType(int, [], [dyn]));
+      maybe(functionType(dart.void, [], [int]), functionType(int, [dyn]));
+      maybe(functionType(dart.void, [], [int]), functionType(int, []));
+      maybe(functionType(dart.void, [int], {extra: int}), functionType(int, [dyn]));
 
-      never(functionType(dart.void, [int]), functionType(int, [int]));
-      never(functionType(dart.void, [], [int]), functionType(int, [], [int]));
-      never(functionType(dart.void, [], [int]), functionType(int, [int]));
-      never(functionType(dart.void, [], [int]), functionType(int, []));
-      never(functionType(dart.void, [int], {extra: int}), functionType(int, [int]));
-
+      maybe(functionType(dart.void, [int]), functionType(int, [int]));
+      maybe(functionType(dart.void, [], [int]), functionType(int, [], [int]));
+      maybe(functionType(dart.void, [], [int]), functionType(int, [int]));
+      maybe(functionType(dart.void, [], [int]), functionType(int, []));
+      maybe(functionType(dart.void, [int], {extra: int}), functionType(int, [int]));
     });
 
     test('higher-order typedef', () => {
       let Func$ = dart.generic((S, T) =>
                                dart.typedef('Func', () =>
                                             functionType(T, [S])));
       let Func2$ = dart.generic((R, S, T) =>
                                 dart.typedef('Func2', () =>
                                              functionType(T, [Func$(R, S)])));
 
@@ skipping 19 matching lines @@
       never(AA$(core.Object), AA$(int));
 
       always(AA$(functionType(int, [int])), AA$(dyn));
       maybe(AA$(dyn), AA$(functionType(int, [int])));
       never(AA$(core.Object), AA$(functionType(int, [int])));
 
       always(AA$(functionType(int, [int])), AA$(functionType(dyn, [dyn])));
       maybe(AA$(functionType(dyn, [dyn])), AA$(functionType(int, [int])));
       maybe(AA$(functionType(core.Object, [core.Object])),
             AA$(functionType(int, [int])));
-
-
     });
-
   });
 
   suite('canonicalization', function() {
     'use strict';
     let functionType = dart.functionType;
     let definiteFunctionType = dart.definiteFunctionType;
     let typedef = dart.typedef;
     let generic = dart.generic;
 
     let Object = core.Object;
@@ skipping 100 matching lines @@
       list[0] = 42;
       assert.throws(() => list.add(42));
     });
 
     test('toString on ES Symbol', () => {
       let sym = Symbol('_foobar');
       assert.equal(dart.toString(sym), 'Symbol(_foobar)');
     });
   });
 });