Use short array syntax in method 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 984 matching lines @@
   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 sig = sigObj[name];
+    let parts = sigObj[name];
+    if (parts === void 0) return void 0;
+    let sig = functionType.apply(functionType, parts);

[Jennifer Messerly, 2015/05/20 19:47:34]

first arg here could be null right, since there is no `this`? That was the
pattern vsm@ used for Array.apply I think. (Not a big deal tho, it will be
ignored either way.)

[vsm, 2015/05/20 22:29:35]

Yes, the first arg to apply is the 'this' pointer.  functionType is top-level,
so cleaner to pass in null.

[Leaf, 2015/05/20 22:52:07]

Done.

     return sig;
   }
 
   /// 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)
@@ skipping 13 matching lines @@
   }
 
   // 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() { return f[_staticSig][name];};
+      function getT() { let parts = f[_staticSig][name];
+                        return functionType.apply(functionType, parts)

[Jennifer Messerly, 2015/05/20 19:47:34]

indent here is a little off

[Leaf, 2015/05/20 22:52:07]

Done.

+                      };
       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
@@ skipping 220 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 = {}));