fix #29753, use ES5 constructors for ddc

pkg/dev_compiler/tool/input_sdk/private/ddc_runtime/classes.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.
 
 /// This library defines the operations that define and manipulate Dart
 /// classes.  Included in this are:
 ///   - Generics
 ///   - Class metadata
 ///   - Extension methods
 ///
 
 // TODO(leafp): Consider splitting some of this out.
 part of dart._runtime;
 
 ///
 /// Returns a new type that mixes members from base and all mixins.
 ///
 /// Each mixin applies in sequence, with further to the right ones overriding
 /// previous entries.
 ///
 /// For each mixin, we only take its own properties, not anything from its
 /// superclass (prototype).
-///
 mixin(base, @rest mixins) => JS(
     '',
     '''(() => {
   // Create an initializer for the mixin, so when derived constructor calls
   // super, we can correctly initialize base and mixins.
 
   // Create a class that will hold all of the mixin methods.
   class Mixin extends $base {}
   // Save the original constructor.  For ClassTypeAlias definitions, this
   // is the concrete type.  We embed metadata (e.g., implemented interfaces)
   // on this constructor and need to access that from runtime instances.
   let constructor = Mixin.prototype.constructor;
   // Copy each mixin's methods, with later ones overwriting earlier entries.
   for (let m of $mixins) {
     $copyProperties(Mixin.prototype, m.prototype);
   }
-  // Restore original Mixin constructor.
+  // Restore original Mixin JS constructor.
   Mixin.prototype.constructor = constructor;  
-  // Initializer methods: run mixin initializers, then the base.
-  Mixin.prototype.new = function(...args) {
-    // Run mixin initializers. They cannot have arguments.
-    // Run them backwards so most-derived mixin is initialized first.
-    for (let i = $mixins.length - 1; i >= 0; i--) {
-      $mixins[i].prototype.new.call(this);
-    }
-    // Run base initializer.
-    $base.prototype.new.apply(this, args);
-  };
-  let namedCtors = ${safeGetOwnProperty(base, _namedConstructors)};
-  if ($base[$_namedConstructors] != null) {
-    for (let namedCtor of $base[$_namedConstructors]) {
-      Mixin.prototype[namedCtor] = function(...args) {
+  // Dart constructors: run mixin constructors, then the base constructors.
+  for (let memberName of $getOwnNamesAndSymbols($base)) {
+    let member = $safeGetOwnProperty($base, memberName);
+    if (typeof member == "function" && member.prototype === base.prototype) {
+      $defineValue(Mixin, memberName, function(...args) {
         // Run mixin initializers. They cannot have arguments.
         // Run them backwards so most-derived mixin is initialized first.
         for (let i = $mixins.length - 1; i >= 0; i--) {
-          $mixins[i].prototype.new.call(this);
+          $mixins[i].new.call(this);
         }
         // Run base initializer.
-        $base.prototype[namedCtor].apply(this, args);
-      };
-      $defineNamedConstructor(Mixin, namedCtor);
+        $base[memberName].apply(this, args);
+      }).prototype = Mixin.prototype;
     }
   }
 
   // Set the signature of the Mixin class to be the composition
   // of the signatures of the mixins.
   $setSignature(Mixin, {
     methods: () => {
       let s = {};
       for (let m of $mixins) {
         if (m[$_methodSig]) $copyProperties(s, m[$_methodSig]);
@@ skipping 315 matching lines @@
   let sigObj = $type[$sigF];
   if (sigObj === void 0) return false;
   return $name in sigObj;
 })()''');
 
 hasMethod(type, name) => _hasSigEntry(type, _methodSig, name);
 hasGetter(type, name) => _hasSigEntry(type, _getterSig, name);
 hasSetter(type, name) => _hasSigEntry(type, _setterSig, name);
 hasField(type, name) => _hasSigEntry(type, _fieldSig, name);
 
-/// Given a class and an initializer method name, creates a constructor
-/// function with the same name.
-///
-/// After we define the named constructor, the class can be constructed with
-/// `new SomeClass.name(args)`.
-defineNamedConstructor(clazz, name) => JS(
-    '',
-    '''(() => {
-  let proto = $clazz.prototype;
-  let initMethod = proto[$name];
-  let ctor = function(...args) { initMethod.apply(this, args); };
-  ctor.prototype = proto;
-  // Use defineProperty so we don't hit a property defined on Function,
-  // like `caller` and `arguments`.
-  $defineProperty($clazz, $name, { value: ctor, configurable: true });
-
-  let namedCtors = ${safeGetOwnProperty(clazz, _namedConstructors)};
-  if (namedCtors == null) $clazz[$_namedConstructors] = namedCtors = [];
-  namedCtors.push($name);
-})()''');
-
-final _namedConstructors = JS('', 'Symbol("_namedConstructors")');
-
 final _extensionType = JS('', 'Symbol("extensionType")');
 
 getExtensionType(obj) => JS('', '#[#]', obj, _extensionType);
 
 final dartx = JS('', 'dartx');
 
 getExtensionSymbol(name) {
   var sym = JS('', 'dartx[#]', name);
   if (sym == null) {
     sym = JS('', 'Symbol("dartx." + #.toString())', name);
@@ skipping 159 matching lines @@
   return JS(
       '',
       '''(() => {
     if ($base) {
       $derived.prototype[$_extensionType] = $derived;
       $derived.prototype.__proto__ = $base.prototype
     }
 })()''');
 }
 
-/// Given a special constructor function that creates a function instances,
-/// and a class with a `call` method, merge them so the constructor function
-/// will have the correct methods and prototype.
-///
-/// For example:
-///
-///     lib.Foo = dart.callableClass(
-///         function Foo { function call(...args) { ... } ... return call; },
-///         class Foo { call(x) { ... } });
-///     ...
-///       let f = new lib.Foo();
-///       f(42);
-callableClass(callableCtor, classExpr) {
-  JS('', '#.prototype = #.prototype', callableCtor, classExpr);
-  // We're not going to use the original class, so we can safely replace it to
-  // point at this constructor for the runtime type information.
-  JS('', '#.prototype.constructor = #', callableCtor, callableCtor);
-  JS('', '#.__proto__ = #', callableCtor, classExpr);
-  return callableCtor;
+defineEnumValues(enumClass, names) {
+  var values = [];
+  for (var i = 0; i < JS('int', '#.length', names); i++) {
+    var value = const_(JS('', 'new #.new(#)', enumClass, i));
+    JS('', '#.push(#)', values, value);
+    defineValue(enumClass, JS('', '#[#]', names, i), value);
+  }
+  JS('', '#.values = #', enumClass, constList(values, enumClass));
 }
-
-/// Given a class and an initializer method name and a call method, creates a
-/// constructor function with the same name.
-///
-/// For example it can be called with `new SomeClass.name(args)`.
-///
-/// The constructor
-defineNamedConstructorCallable(clazz, name, ctor) => JS(
-    '',
-    '''(() => {
-  ctor.prototype = $clazz.prototype;
-  // Use defineProperty so we don't hit a property defined on Function,
-  // like `caller` and `arguments`.
-  $defineProperty($clazz, $name, { value: ctor, configurable: true });
-
-  let namedCtors = ${safeGetOwnProperty(clazz, _namedConstructors)};
-  if (namedCtors == null) $clazz[$_namedConstructors] = namedCtors = [];
-  namedCtors.push($name);
-})()''');
-
-defineEnumValues(enumClass, names) => JS(
-    '',
-    '''(() => {
-  let values = [];
-  for (var i = 0; i < $names.length; i++) {
-    let value = $const_(new $enumClass(i));
-    values.push(value);
-    Object.defineProperty($enumClass, $names[i],
-        { value: value, configurable: true });
-  }
-  $enumClass.values = $constList(values, $enumClass);
-})()''');