fix #29753, use ES5 constructors for 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;
@@ skipping 160 matching lines @@
     let Map$ = core.Map$;
     let double = core.double;
     let int = core.int;
     let num = core.num;
     let bool = core.bool;
 
     class A {}
     class B extends A {}
     class C extends B {}
 
-    let AA$ = generic((T, U) => class AA extends core.Object {});
+    let AA$ = generic((T, U) => {
+      class AA extends core.Object {}
+      (AA.new = function() {}).prototype = AA.prototype;
+      return AA;
+    });
     let AA = AA$();
-    let BB$ = generic((T, U) => class BB extends AA$(U, T) {});
+    let BB$ = generic((T, U) => {
+      class BB extends AA$(U, T) {}
+      (BB.new = function() {}).prototype = BB.prototype;
+      return BB;
+    });
     let BB = BB$();
     class CC extends BB$(String, List) {}
+    (CC.new = function() {}).prototype = CC.prototype;
 
     let Func2 = typedef('Func2', () => fnTypeFuzzy(dynamic, [dynamic, dynamic]));
     let Foo = typedef('Foo', () => fnTypeFuzzy(B, [B, String]));
 
     let FuncG$ = generic((T, U) => typedef('FuncG', () => fnTypeFuzzy(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; }
@@ skipping 83 matching lines @@
       expect(cast(5, int), 5);
       if (intIsNonNullable) {
         expect(() => cast(null, int), throws);
       } else {
         expect(cast(null, int), null);
       }
     });
 
     test('dynamic', () => {
       expect(isGroundType(dynamic), true);
-      checkType(new Object(), dynamic);
+      checkType(new Object.new(), dynamic);
       checkType(null, dynamic);
 
       expect(cast(null, dynamic), null);
     });
 
     test('Object', () => {
       expect(isGroundType(Object), true);
-      checkType(new Object(), dynamic);
+      checkType(new Object.new(), dynamic);
       checkType(null, Object);
 
       expect(cast(null, Object), null);
     });
 
     test('null', () => {
       // Object, dynamic cases are already handled above.
       checkType(null, core.Null);
       checkType(null, core.String, false);
       checkType(null, core.int, false);
@@ skipping 24 matching lines @@
       assert.isTrue(dart.is(3, FutureOr(double)));
       assert.isFalse(dart.is(3.5, FutureOr(int)));
       assert.isTrue(dart.is(3.5, FutureOr(double)));
 
       assert.equal(dart.as(3, FutureOr(FutureOr(double))), 3);
       assert.isTrue(dart.is(3, FutureOr(FutureOr(double))));
 
     });
 
     test('Map', () => {
-      let m1 = new (Map$(String, String))();
-      let m2 = new (Map$(Object, Object))();
-      let m3 = new Map();
-      let m4 = new (collection.HashMap$(dart.dynamic, dart.dynamic))();
-      let m5 = new collection.LinkedHashMap();
-      let m6 = new (Map$(String, dart.dynamic))();
-
+      let m1 = Map$(String, String).new();
+      let m2 = Map$(Object, Object).new();
+      let m3 = Map.new();
+      let m4 = collection.HashMap$(dart.dynamic, dart.dynamic).new();
+      let m5 = collection.LinkedHashMap.new();
+      let m6 = Map$(String, dart.dynamic).new();
 
       expect(isGroundType(Map), true);
       expect(isGroundType(getReifiedType(m1)), false);
       expect(isGroundType(Map$(String, String)), false);
       expect(isGroundType(getReifiedType(m2)), true);
       expect(isGroundType(Map$(Object, Object)), true);
       expect(isGroundType(getReifiedType(m3)), true);
       expect(isGroundType(Map), true);
       expect(isGroundType(getReifiedType(m4)), true);
       expect(isGroundType(collection.HashMap$(dynamic, dynamic)), true);
@@ skipping 39 matching lines @@
       //   dart.StrongModeError);
       // assert.throws(() => dart.as(m6, Map$(String, String)),
       //   dart.StrongModeError);
       assert.equal(dart.as(m1, Map$(String, String)), m1);
       // assert.throws(() => dart.as(m2, Map$(String, String)),
       //   dart.StrongModeError);
     });
 
     test('constructors', () => {
       class C extends core.Object {
-        new(x) {};
-        named(x, y) {};
       }
-      dart.defineNamedConstructor(C, 'named');
+      (C.new = function(x) {}).prototype = C.prototype;
+      (C.named = function(x, y) {}).prototype = C.prototype;
       dart.setSignature(C, {
         constructors: () => ({
           new: dart.fnType(C, [core.int]),
           named: dart.fnType(C, [core.int, core.int])
         })
       });
       let getType = dart.classGetConstructorType;
       isSubtype(getType(C), dart.fnTypeFuzzy(C, [core.int]));
       isSubtype(getType(C), dart.fnTypeFuzzy(C, [core.String]), false);
       isSubtype(getType(C, 'new'), dart.fnTypeFuzzy(C, [core.int]));
       isSubtype(getType(C, 'new'), dart.fnTypeFuzzy(C, [core.String]), false);
       isSubtype(getType(C, 'named'), dart.fnTypeFuzzy(C, [core.int, core.int]));
       isSubtype(getType(C, 'named'),
                 dart.fnTypeFuzzy(C, [core.int, core.String]), false);
     });
 
     test('generic and inheritance', () => {
-      let aaraw = new AA();
+      let aaraw = new AA.new();
       let aarawtype = getReifiedType(aaraw);
-      let aadynamic = new (AA$(dynamic, dynamic))();
+      let aadynamic = new (AA$(dynamic, dynamic).new)();
       let aadynamictype = getReifiedType(aadynamic);
-      let aa = new (AA$(String, List))();
+      let aa = new (AA$(String, List).new)();
       let aatype = getReifiedType(aa);
-      let bb = new (BB$(String, List))();
+      let bb = new (BB$(String, List).new)();
       let bbtype = getReifiedType(bb);
-      let cc = new CC();
+      let cc = new CC.new();
       let cctype = getReifiedType(cc);
       // We don't allow constructing bad types.
       // This was AA<String> in Dart (wrong number of type args).
-      let aabad = new (AA$(dart.dynamic, dart.dynamic))();
+      let aabad = new (AA$(dart.dynamic, dart.dynamic).new)();
       let aabadtype = getReifiedType(aabad);
 
       expect(isGroundType(aatype), false);
       expect(isGroundType(AA$(String, List)), false);
       expect(isGroundType(bbtype), false);
       expect(isGroundType(BB$(String, List)), false);
       expect(isGroundType(cctype), true);
       expect(isGroundType(CC), true);
       checkType(cc, aatype, false);
       checkType(cc, AA$(String, List), false);
@@ skipping 18 matching lines @@
       checkType(aadynamic, aarawtype);
       checkType(aadynamic, AA);
     });
 
     test('void', () => {
       //checkType((x) => x, type((void _(x)) {}));
     });
 
     test('mixins', () => {
       let c = collection;
-      var s1 = new (c.SplayTreeSet$(String))();
+      var s1 = new (c.SplayTreeSet$(String).new)();
 
       checkType(s1, c.IterableMixin);
       checkType(s1, c.IterableMixin$(String));
       checkType(s1, c.IterableMixin$(int), false);
 
       checkType(s1, c.SetMixin);
       checkType(s1, c.SetMixin$(String));
       checkType(s1, c.SetMixin$(int), false);
     });
 
@@ skipping 102 matching lines @@
 
       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,
-                           dart.fnType(core.int, [core.int]));
-          this.me = this;
-        }
         m(x, y) {return x;}
         call(x) {return x;}
         static s(x, y) { return x;}
       }
+      (Tester.new = function() {
+        this.f = dart.fn(x => x,
+                          dart.fnType(core.int, [core.int]));
+        this.me = this;
+      }).prototype = Tester.prototype;
       dart.setSignature(Tester, {
         methods: () => ({
           m: dart.fnType(core.int, [core.int, core.int]),
           call: dart.fnType(core.int, [core.int])
         }),
         statics: () => ({
           s: dart.fnType(core.String, [core.String])
         }),
         names: ['s']
       })
-      let o = new Tester();
+      let o = new Tester.new();
 
       // 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"));
       assert.throws(() => dart.dsend(o, 'q', 3));
 
       // Method send through a field
       assert.equal(dart.dsend(o, 'f', 3), 3);
@@ skipping 78 matching lines @@
       checkType(i_i2i,
           dart.fnTypeFuzzy(core.int, [], {extra: core.int,
                                            also: core.int}), false);
       checkType(i_i2i,
           dart.fnTypeFuzzy(core.int, [core.int], [core.int]), false);
     });
 
     test('Method tearoffs', () => {
       let c = collection;
       // Tear off of an inherited method
-      let map = new (Map$(core.int, core.String))();
+      let map = Map$(core.int, core.String).new();
       checkType(dart.bind(map, 'toString'),
                 dart.fnTypeFuzzy(String, []));
       checkType(dart.bind(map, 'toString'),
                 dart.fnTypeFuzzy(int, []), false, true);
 
       // Tear off of a method directly on the object
-      let smap = new (c.SplayTreeMap$(core.int, core.String))();
+      let smap = new (c.SplayTreeMap$(core.int, core.String).new)();
       checkType(dart.bind(smap, 'forEach'),
           dart.fnTypeFuzzy(dart.void,
                             [dart.fnTypeFuzzy(dart.void, [core.int, core.String])]));
       checkType(dart.bind(smap, 'forEach'),
           dart.fnTypeFuzzy(dart.void,
               [dart.fnTypeFuzzy(dart.void,
                   [core.String, core.String])]), false, true);
 
       // Tear off of a mixed in method
-      let mapB = new (c.MapBase$(core.int, core.int))();
+      let mapB = new (c.MapBase$(core.int, core.int).new)();
       checkType(dart.bind(mapB, 'forEach'),
           dart.fnTypeFuzzy(dart.void, [
               dart.fnTypeFuzzy(dart.void, [core.int, core.int])]));
       checkType(dart.bind(mapB, 'forEach'),
           dart.fnTypeFuzzy(dart.void, [
               dart.fnTypeFuzzy(dart.void, [core.int, core.String])]),
                 false, true);
 
       // Tear off of a method with a symbol name
-      let listB = new (c.ListBase$(core.int))();
+      let listB = new (c.ListBase$(core.int).new)();
       checkType(dart.bind(listB, dartx.add),
                 dart.fnTypeFuzzy(dart.void, [core.int]));
       checkType(dart.bind(listB, dartx.add),
                 dart.fnTypeFuzzy(dart.void, [core.String]), false, true);
 
       // Tear off of a static method
       checkType(c.ListBase.listToString,
                 dart.fnTypeFuzzy(core.String, [core.List]));
       checkType(c.ListBase.listToString,
                 dart.fnTypeFuzzy(core.String, [core.String]), false, true);
@@ skipping 29 matching lines @@
 
       class M2 {
         m(x) {return x;}
       };
       dart.setSignature(M2, {
         methods: () => ({
           m: dart.fnType(core.Object, [core.int]),
         })
       });
 
-      class O extends dart.mixin(Base, M1, M2) {
-        new() {};
-      };
+      class O extends dart.mixin(Base, M1, M2) {}
+      (O.new = function() {}).prototype = O.prototype;
       dart.setSignature(O, {});
-      var obj = new O();
+      var obj = new O.new();
       var m = dart.bind(obj, 'm');
       checkType(m, dart.fnTypeFuzzy(core.Object, [core.int]));
       checkType(m, dart.fnTypeFuzzy(core.int, [core.int]), false, true);
 
       // Test inherited signatures
       class P extends O {
-        new() {};
         m(x) {return x;};
       };
+      (P.new = function() {}).prototype = P.prototype;
       dart.setSignature(P, {});
-      var obj = new P();
+      var obj = new P.new();
       var m = dart.bind(obj, 'm');
       checkType(m, dart.fnTypeFuzzy(core.Object, [core.int]));
       checkType(m, dart.fnTypeFuzzy(core.int, [core.int]), false, true);
     });
 
     test('Object members', () => {
       let nullHash = dart.hashCode(null);
       assert.equal(nullHash, 0);
       let nullString = dart.toString(null);
       assert.equal(nullString, 'null');
 
-      let map = new Map();
+      let map = Map.new();
       let mapHash = dart.hashCode(map);
       checkType(mapHash, core.int);
       assert.equal(mapHash, map.hashCode);
 
       let mapString = dart.toString(map);
       assert.equal(mapString, map.toString());
       checkType(mapString, core.String);
 
       let str = "A string";
       let strHash = dart.hashCode(str);
@@ skipping 300 matching lines @@
                                              fnTypeFuzzy(T, [Func$(R, S)])));
 
       maybe(fnTypeFuzzy(int, [fnTypeFuzzy(int, [num])]),
             fnTypeFuzzy(num, [fnTypeFuzzy(int, [int])]));
       maybe(fnTypeFuzzy(int, [Func$(num, int)]),
             fnTypeFuzzy(num, [Func$(int, int)]));
       maybe(Func2$(num, int, int), Func2$(int, int, num));
     });
 
     test('mixed types', () => {
-      let AA$ = dart.generic((T) => class AA extends core.Object {});
+      let AA$ = dart.generic((T) => {
+        class AA extends core.Object {}
+        (AA.new = function() {}).prototype = AA.prototype;
+        return AA;
+      });
 
       always(int, dyn);
       maybe(dyn, int);
 
       never(fnTypeFuzzy(int, [int]), int);
 
       never(int, fnTypeFuzzy(int, [int]));
 
       always(AA$(int), AA$(dyn));
       maybe(AA$(dyn), AA$(int));
@@ skipping 20 matching lines @@
     let Object = core.Object;
     let String = core.String;
     let int = core.int;
     let dynamic = dart.dynamic;
     let bottom = dart.bottom;
     let Map = core.Map;
     let Map$ = core.Map$;
 
     class A {}
 
-    let AA$ = generic((T, U) => class AA extends core.Object {});
+    let AA$ = generic((T, U) => {
+      class AA extends core.Object {}
+      (AA.new = function() {}).prototype = AA.prototype;
+      return AA;
+    });
     let AA = AA$();
 
     let Func2 = typedef('Func2', () => fnTypeFuzzy(dynamic, [dynamic, dynamic]));
 
     let FuncG$ = generic((T, U) => typedef('FuncG', () => fnTypeFuzzy(T, [T, U])))
     let FuncG = FuncG$();
 
     test('base types', () => {
       assert.equal(Object, Object);
       assert.equal(String, String);
@@ skipping 69 matching lines @@
 
       assert.notEqual(fnTypeFuzzy(String, []),
                    fnTypeFuzzy(int, []))
     });
   });
 
   suite('primitives', function() {
     'use strict';
 
     test('fixed length list', () => {
-      let list = new core.List(10);
+      let list = core.List.new(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)');
     });
   });
 });