Partial fix for call methods #542

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
 ///
@@ skipping 238 matching lines @@
     ('names' in signature) ? signature.names : [];
   $_setConstructorSignature($f, constructors);
   $_setMethodSignature($f, methods);
   $_setStaticSignature($f, statics);
   $_setStaticTypes($f, names);
   $tagLazy($f, () => $Type);
 })()''');
 
 hasMethod(obj, name) => JS('', '$getMethodType($obj, $name) !== void 0');
 
+/// Given a class and an initializer method name, creates a constructor
+/// function with the same name.
 ///
-/// Given a class and an initializer method name, creates a constructor
-/// function with the same name. For example `new SomeClass.name(args)`.
-///
+/// 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() { return initMethod.apply(this, arguments); };
+  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 });
 })()''');
 
+
 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 148 matching lines @@
   JS('', '#.__proto__ = #', derived, base);
 }
 
 /// Like [setBaseClass] but for generic extension types, e.g. `JSArray<E>`
 setExtensionBaseClass(derived, base) {
   // Mark the generic type as an extension type.
   JS('', '#.prototype[#] = #', derived, _extensionType, derived);
   // Link the prototype objects
   JS('', '#.prototype.__proto__ = #.prototype', derived, base);
 }
+
+/// 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__ = #.__proto__', callableCtor, classExpr);
+  return callableCtor;
+}
+
+/// 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 });
+})()''');