Add constructors to signatures

lib/runtime/dart_runtime.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 dart, _js_helper, _js_primitives;
 (function (dart) {
   'use strict';
 
   // TODO(vsm): This is referenced (as init.globalState) from
   // isolate_helper.dart.  Where should it go?
@@ skipping 979 matching lines @@
           }
           map.set(arg, value);
         }
       }
       return value;
     }
     return makeGenericType;
   }
   dart.generic = generic;
 
+  let _constructorSig = Symbol('sigCtor');
   let _methodSig = Symbol("sig");
   let _staticSig = Symbol("sigStatic");
 
   /// Get the type of a function using the store runtime type
   function _getFunctionType(f) {
     return f[_runtimeType];
   }
 
   /// Get the type of a method using the stored signature
   function _getMethodType(obj, name) {
     if (obj === void 0) return void 0;
     if (obj == null) return void 0;
     let sigObj = obj.__proto__.constructor[_methodSig];
     if (sigObj === void 0) return void 0;
     let parts = sigObj[name];
     if (parts === void 0) return void 0;
     let sig = functionType.apply(null, parts);
     return sig;
   }
 
+  /// Get the type of a constructor from a class using the stored signature
+  /// If name is undefined, returns the type of the default constructor
+  /// Returns undefined if the constructor is not found.
+  function _getConstructorType(cls, name) {
+    if(!name) name = cls.name;
+    if (cls === void 0) return void 0;
+    if (cls == null) return void 0;
+    let sigCtor = cls[_constructorSig];
+    if (sigCtor === void 0) return void 0;
+    let parts = sigCtor[name];
+    if (parts === void 0) return void 0;
+    let sig = functionType.apply(null, parts);
+    return sig;
+  }
+  dart.classGetConstructorType = _getConstructorType;
+
   /// Given an object and a method name, tear off the method.
   /// Sets the runtime type of the torn off method appropriately,
   /// and also binds the object.
   /// TODO(leafp): Consider caching the tearoff on the object?
   function bind(obj, name) {
     let f = obj[name].bind(obj);
     let sig = _getMethodType(obj, name)
     assert(sig);
     setRuntimeType(f, sig);
     return f;
   }
   dart.bind = bind;
 
   // Set up the method signature field on the constructor
   function _setMethodSignature(f, sigF) {
     defineMemoizedGetter(f, _methodSig, () => {
       let sigObj = sigF();
       sigObj.__proto__ = f.__proto__[_methodSig];
       return sigObj;
     });
   }
 
+  // Set up the constructor signature field on the constructor
+  function _setConstructorSignature(f, sigF) {
+    defineMemoizedGetter(f, _constructorSig, sigF);
+  }
+
   // Set up the static signature field on the constructor
   function _setStaticSignature(f, sigF) {
     defineMemoizedGetter(f, _staticSig, sigF);
   }
 
   // Set the lazily computed runtime type field on static methods
   function _setStaticTypes(f, names) {
     for (let name of names) {
       function getT() {
         let parts = f[_staticSig][name];
         return functionType.apply(null, parts);
       };
       defineProperty(f[name], _runtimeType, {get : getT});
     }
   }
 
   /// Set up the type signature of a class (constructor object)
   /// f is a constructor object
   /// signature is an object containing optional properties as follows:
   ///  methods: A function returning an object mapping method names
   ///   to method types.  The function is evaluated lazily and cached.
   ///  statics: A function returning an object mapping static method
   ///   names to types.  The function is evalutated lazily and cached.
   ///  names: An array of the names of the static methods.  Used to
   ///   permit eagerly setting the runtimeType field on the methods
   ///   while still lazily computing the type descriptor object.
   function setSignature(f, signature) {
+    let constructors =
+      ('constructors' in signature) ? signature.constructors : () => ({});
     let methods =
       ('methods' in signature) ? signature.methods : () => ({});
     let statics =
       ('statics' in signature) ? signature.statics : () => ({});
     let names =
       ('names' in signature) ? signature.names : [];
+    _setConstructorSignature(f, constructors);
     _setMethodSignature(f, methods);
     _setStaticSignature(f, statics);
     _setStaticTypes(f, names);
   };
   dart.setSignature = setSignature;
 
   let _value = Symbol('_value');
   /**
    * Looks up a sequence of [keys] in [map], recursively, and
    * returns the result. If the value is not found, [valueFn] will be called to
@@ skipping 199 matching lines @@
   Number.prototype['>'] = function(arg) { return this.valueOf() > arg; };
   Number.prototype['+'] = function(arg) { return this.valueOf() + arg; };
 
   // TODO(vsm): DOM facades?
   // See: https://github.com/dart-lang/dev_compiler/issues/173
   NodeList.prototype.get = function(i) { return this[i]; };
   NamedNodeMap.prototype.get = function(i) { return this[i]; };
   DOMTokenList.prototype.get = function(i) { return this[i]; };
 
 })(dart || (dart = {}));