Name and hoist types

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.
 
 var assert = chai.assert;
 var dart_sdk = dart_library.import('dart_sdk');
 var core = dart_sdk.core;
 var collection = dart_sdk.collection;
 var dart = dart_sdk.dart;
 var dartx = dart.dartx;
@@ skipping 135 matching lines @@
 
   let Func2 = typedef('Func2', () => functionType(dynamic, [dynamic, dynamic]));
   let Foo = typedef('Foo', () => functionType(B, [B, String]));
 
   let FuncG$ = generic((T, U) => typedef('FuncG', () => functionType(T, [T, U])))
   let FuncG = FuncG$();
 
   // TODO(vsm): Revisit when we encode types on functions properly.
   // A bar1(C c, String s) => null;
   function bar1(c, s) { return null; }
-  dart.fn(bar1, A, [C, String]);
+  dart.fn(bar1, dart.definiteFunctionType(A, [C, String]));
 
   // bar2(B b, String s) => null;
   function bar2(b, s) { return null; }
-  dart.fn(bar2, dynamic, [B, String]);
+  dart.fn(bar2, dart.definiteFunctionType(dynamic, [B, String]));
 
   // B bar3(B b, Object o) => null;
   function bar3(b, o) { return null; }
-  dart.fn(bar3, B, [B, Object]);
+  dart.fn(bar3, dart.definiteFunctionType(B, [B, Object]));
 
   // B bar4(B b, o) => null;
   function bar4(b, o) { return null; }
-  dart.fn(bar4, B, [B, dynamic]);
+  dart.fn(bar4, dart.definiteFunctionType(B, [B, dynamic]));
 
   // C bar5(A a, Object o) => null;
   function bar5(a, o) { return null; }
-  dart.fn(bar5, C, [A, Object]);
+  dart.fn(bar5, dart.definiteFunctionType(C, [A, Object]));
 
   // B bar6(B b, String s, String o) => null;
   function bar6(b, s, o) { return null; }
-  dart.fn(bar6, B, [B, String, String]);
+  dart.fn(bar6, dart.definiteFunctionType(B, [B, String, String]));
 
   // B bar7(B b, String s, [Object o]) => null;
   function bar7(b, s, o) { return null; }
-  dart.fn(bar7, B, [B, String], [Object]);
+  dart.fn(bar7, dart.definiteFunctionType(B, [B, String], [Object]));
 
   // B bar8(B b, String s, {Object p}) => null;
   function bar8(b, s, o) { return null; }
-  dart.fn(bar8, B, [B, String], {p: Object});
+  dart.fn(bar8, dart.definiteFunctionType(B, [B, String], {p: Object}));
 
-  let cls1 = dart.fn((c, s) => { return null; }, A, [C, String]);
+  let cls1 = dart.fn((c, s) => { return null; }, 
+                     dart.definiteFunctionType(A, [C, String]));
 
-  let cls2 = dart.fn((b, s) => { return null; }, dynamic, [B, String]);
+  let cls2 = dart.fn((b, s) => { return null; }, 
+                     dart.definiteFunctionType(dynamic, [B, String]));
 
-  let cls3 = dart.fn((b, o) => { return null; }, B, [B, Object]);
+  let cls3 = dart.fn((b, o) => { return null; }, 
+                     dart.definiteFunctionType(B, [B, Object]));
 
-  let cls4 = dart.fn((b, o) => { return null; }, B, [B, dynamic]);
+  let cls4 = dart.fn((b, o) => { return null; }, 
+                     dart.definiteFunctionType(B, [B, dynamic]));
 
-  let cls5 = dart.fn((a, o) => { return null; }, C, [A, Object]);
+  let cls5 = dart.fn((a, o) => { return null; }, 
+                     dart.definiteFunctionType(C, [A, Object]));
 
-  let cls6 = dart.fn((b, s, o) => { return null; }, B, [B, String, String]);
+  let cls6 = dart.fn((b, s, o) => { return null; }, 
+                     dart.definiteFunctionType(B, [B, String, String]));
 
-  let cls7 = dart.fn((b, s, o) => { return null; }, B, [B, String], [Object]);
+  let cls7 = dart.fn((b, s, o) => { return null; }, 
+                     dart.definiteFunctionType(B, [B, String], [Object]));
 
   let cls8 =
-    dart.fn((b, s, o) => { return null; }, B, [B, String], {p: Object});
+    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) {
       assert.doesNotThrow(() => instanceOf(x, type));
       expect(instanceOf(x, type), expectedTrue);
     } else {
       assert.throws(() => instanceOf(x, type), dart.StrongModeError);
       expect(expectedTrue, false);
@@ skipping 124 matching lines @@
   });
 
   test('constructors', () => {
     class C extends core.Object {
       C(x) {};
       named(x, y) {};
     }
     dart.defineNamedConstructor(C, 'named');
     dart.setSignature(C, {
       constructors: () => ({
-        C: [C, [core.int]],
-        named: [C, [core.int, core.int]]
+        C: dart.definiteFunctionType(C, [core.int]),
+        named: dart.definiteFunctionType(C, [core.int, core.int])
       })
     });
     let getType = dart.classGetConstructorType;
     isSubtype(getType(C), dart.functionType(C, [core.int]));
     isSubtype(getType(C), dart.functionType(C, [core.String]), false);
     isSubtype(getType(C, 'C'), dart.functionType(C, [core.int]));
     isSubtype(getType(C, 'C'), dart.functionType(C, [core.String]), false);
     isSubtype(getType(C, 'named'), dart.functionType(C, [core.int, core.int]));
     isSubtype(getType(C, 'named'),
               dart.functionType(C, [core.int, core.String]), false);
@@ skipping 133 matching lines @@
     checkType(bar1, FuncG$(B, String), false, true);
     checkType(cls1, FuncG$(B, String), false, true);
     checkType(bar3, FuncG$(B, String));
     checkType(cls3, FuncG$(B, String));
   });
 
   test('dcall', () => {
     function dd2d(x, y) {return x};
     dart.fn(dd2d);
     function ii2i(x, y) {return x};
-    dart.fn(ii2i, core.int, [core.int, core.int]);
+    dart.fn(ii2i, dart.definiteFunctionType(core.int, [core.int, core.int]));
     function ii_2i(x, y) {return x};
-    dart.fn(ii_2i, core.int, [core.int], [core.int]);
+    dart.fn(ii_2i, dart.definiteFunctionType(core.int, [core.int], [core.int]));
     function i_i2i(x, opts) {return x};
-    dart.fn(i_i2i, core.int, [core.int], {extra: core.int});
+    dart.fn(i_i2i, 
+            dart.definiteFunctionType(core.int, [core.int], {extra: core.int}));
 
     assert.equal(dart.dcall(dd2d, 0, 1), 0);
     assert.equal(dart.dcall(dd2d, "hello", "world"), "hello");
     assert.throws(() => dart.dcall(dd2d, 0));
     assert.throws(() => dart.dcall(dd2d, 0, 1, 2));
     assert.throws(() => dart.dcall(dd2d, 0, 1, {extra : 3}));
     // This should throw but currently doesn't.
     //    assert.throws(() => dart.dcall(dd2d, 0, {extra:3}));
 
     assert.equal(dart.dcall(ii2i, 0, 1), 0);
     assert.throws(() => dart.dcall(ii2i, "hello", "world"));
     assert.throws(() => dart.dcall(ii2i, 0));
     assert.throws(() => dart.dcall(ii2i, 0, 1, 2));
 
     assert.equal(dart.dcall(ii_2i, 0, 1), 0);
     assert.throws(() => dart.dcall(ii_2i, "hello", "world"));
     assert.equal(dart.dcall(ii_2i, 0), 0);
     assert.throws(() => dart.dcall(ii_2i, 0, 1, 2));
 
     assert.throws(() => dart.dcall(i_i2i, 0, 1));
     assert.throws(() => dart.dcall(i_i2i, "hello", "world"));
     assert.equal(dart.dcall(i_i2i, 0), 0);
     assert.throws(() => dart.dcall(i_i2i, 0, 1, 2));
     assert.equal(dart.dcall(i_i2i, 0, {extra: 3}), 0);
   });
 
   test('dsend', () => {
     class Tester extends core.Object {
       new() {
-        this.f = dart.fn(x => x, core.int, [core.int]);
+        this.f = dart.fn(x => x, 
+                         dart.definiteFunctionType(core.int, [core.int]));
         this.me = this;
       }
       m(x, y) {return x;}
       call(x) {return x;}
       static s(x, y) { return x;}
     }
     dart.setSignature(Tester, {
       methods: () => ({
-        m: [core.int, [core.int, core.int]],
-        call: [core.int, [core.int]]
+        m: dart.definiteFunctionType(core.int, [core.int, core.int]),
+        call: dart.definiteFunctionType(core.int, [core.int])
       }),
       statics: () => ({
-        s: [core.String, [core.String]]
+        s: dart.definiteFunctionType(core.String, [core.String])
       }),
       names: ['s']
     })
     let o = new Tester();
 
     // Method send
     assert.equal(dart.dsend(o, 'm', 3, 4), 3);
     assert.equal(dart.dsend(o, 'm', null, 4), null);
     assert.throws(() => dart.dsend(o, 'm', 3));
     assert.throws(() => dart.dsend(o, 'm', "hello", "world"));
@@ skipping 36 matching lines @@
 
     // Hand crafted tests
     // All dynamic
     function dd2d(x, y) {return x};
     dart.fn(dd2d);
     checkType(dd2d, dart.functionType(dart.dynamic,
                                       [dart.dynamic, dart.dynamic]));
 
     // Set the type eagerly
     function ii2i(x, y) {return x};
-    dart.fn(ii2i, core.int, [core.int, core.int]);
+    dart.fn(ii2i, dart.definiteFunctionType(core.int, [core.int, core.int]));
     checkType(ii2i, dart.functionType(core.int,
                                       [core.int, core.int]));
 
     // Set the type lazily
     function ss2s(x, y) {return x};
     var coreString;
-    dart.lazyFn(ss2s, () => [coreString, [coreString, coreString]]);
+    dart.lazyFn(ss2s, 
+                () => dart.definiteFunctionType(coreString, 
+                                                [coreString, coreString]));
     coreString = core.String;
     checkType(ss2s, dart.functionType(core.String,
                                       [core.String, core.String]));
 
     // Optional types
     function ii_2i(x, y) {return x};
-    dart.fn(ii_2i, core.int, [core.int], [core.int]);
+    dart.fn(ii_2i, dart.definiteFunctionType(core.int, [core.int], [core.int]));
     checkType(ii_2i, dart.functionType(core.int, [core.int],
                                        [core.int]));
     checkType(ii_2i, dart.functionType(core.int, [core.int,
                                                   core.int]));
     checkType(ii_2i, dart.functionType(core.int, [], [core.int,
                                                       core.int]),
               false);
     checkType(ii_2i, dart.functionType(core.int, [core.int],
                                        {extra: core.int}), false);
 
     // Named types
     function i_i2i(x, opts) {return x};
-    dart.fn(i_i2i, core.int, [core.int], {extra: core.int});
+    dart.fn(i_i2i, dart.definiteFunctionType(core.int, [core.int], 
+                                             {extra: core.int}));
     checkType(i_i2i, dart.functionType(core.int, [core.int],
                                        {extra: core.int}));
     checkType(i_i2i, dart.functionType(core.int,
                                        [core.int, core.int]), false);
     checkType(i_i2i, dart.functionType(core.int, [core.int], {}));
     checkType(i_i2i,
         dart.functionType(core.int, [], {extra: core.int,
                                          also: core.int}), false);
     checkType(i_i2i,
         dart.functionType(core.int, [core.int], [core.int]), false);
@@ skipping 50 matching lines @@
               dart.functionType(core.bool, [core.String]));
     checkType(dart.bind("", dartx.endsWith),
               dart.functionType(core.bool, [core.int]), false, true);
 
     // Tear off a mixin method
     class Base {
       m(x) {return x;}
     };
     dart.setSignature(Base, {
       methods: () => ({
-        m: [core.int, [core.int]],
+        m: dart.definiteFunctionType(core.int, [core.int]),
       })
     });
 
     class M1 {
       m(x) {return x;}
     };
     dart.setSignature(M1, {
       methods: () => ({
-        m: [core.num, [core.int]],
+        m: dart.definiteFunctionType(core.num, [core.int]),
       })
     });
 
     class M2 {
       m(x) {return x;}
     };
     dart.setSignature(M2, {
       methods: () => ({
-        m: [core.Object, [core.int]],
+        m: dart.definiteFunctionType(core.Object, [core.int]),
       })
     });
 
     class O extends dart.mixin(Base, M1, M2) {
       O() {};
     };
     dart.setSignature(O, {});
     var obj = new O();
     var m = dart.bind(obj, 'm');
     checkType(m, dart.functionType(core.Object, [core.int]));
@@ skipping 430 matching lines @@
     let list = new core.List(10);
     list[0] = 42;
     assert.throws(() => list.add(42));
   });
 
   test('toString on ES Symbol', () => {
     let sym = Symbol('_foobar');
     assert.equal(dart.toString(sym), 'Symbol(_foobar)');
   });
 });