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 553 matching lines @@
     var t;
     if (arguments.length == 1) {
       // No type arguments, it's all dynamic
       let len = closure.length;
       let args = Array.apply(null, new Array(len)).map(() => dart.dynamic);
       t = functionType(dart.dynamic, args);
     } else {
       // We're passed the piecewise components of the function type,
       // construct it.
       let args = Array.prototype.slice.call(arguments, 1);
-      t = functionType.apply(functionType, args);
+      t = functionType.apply(null, args);
     }
     setRuntimeType(closure, t);
     return closure;
   }
   dart.fn = fn;
 
   function functionType(returnType, args, extra) {
     // TODO(vsm): Cache / memomize?
     var optionals;
     var named;
@@ skipping 410 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(null, parts);
     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(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
@@ 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 = {}));