small cleanups to dart_runtime.js

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?
   // See: https://github.com/dart-lang/dev_compiler/issues/164
   dart.globalState = null;
 
   let defineProperty = Object.defineProperty;
   let getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
   let getOwnPropertyNames = Object.getOwnPropertyNames;
   let getOwnPropertySymbols = Object.getOwnPropertySymbols;
 
   function getOwnNamesAndSymbols(obj) {
     return getOwnPropertyNames(obj).concat(getOwnPropertySymbols(obj));
   }
 
-  // Adapted from Angular.js
-  let FN_ARGS = /^function\s*[^\(]*\(\s*([^\)]*)\)/m;
-  let FN_ARG_SPLIT = /,/;
-  let FN_ARG = /^\s*(_?)(\S+?)\1\s*$/;
-  let STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/mg;
-
-  function formalParameterList(fn) {

[Jennifer Messerly, 2015/05/29 23:02:20]

dead code

[vsm, 2015/05/29 23:07:37]

We may want this for parameter mirrors - otherwise, we'd need to store in
metadata I think - but I can add back if needed.  It needs to be updated for ES6
function variants anyway.

-    let fnText,argDecl;
-    let args=[];
-    fnText = fn.toString().replace(STRIP_COMMENTS, '');
-    argDecl = fnText.match(FN_ARGS);
-
-    let r = argDecl[1].split(FN_ARG_SPLIT);
-    for (let arg of r) {
-      arg.replace(FN_ARG, function(all, underscore, name){
-        args.push(name);
-      });
-    }
-    return args;
-  }
-
   function dload(obj, field) {
     field = _canonicalFieldName(obj, field);
     if (_getMethodType(obj, field) !== void 0) {
       return dart.bind(obj, field);
     }
     // TODO(vsm): Implement NSM robustly.  An 'in' check breaks on certain
     // types.  hasOwnProperty doesn't chase the proto chain.
     // Also, do we want an NSM on regular JS objects?
     // See: https://github.com/dart-lang/dev_compiler/issues/169
     var result = obj[field];
@@ skipping 65 matching lines @@
   dart.dcall = dcall;
 
   // TODO(vsm): Automatically build this.
   // All dynamic methods should check for these.
   // See: https://github.com/dart-lang/dev_compiler/issues/142
   var _extensionMethods = {
     // Lazy - as these symbols may not be loaded yet.
     // TODO(vsm): This should record / check the receiver type
     // as well.  E.g., only look for core.$map if the receiver
     // is an Iterable.
-    'map': () => core.$map,
+    'map': () => core.$map
   };
 
   // TODO(leafp): Integrate this with the eventual proper extension
   // method system.
   function _canonicalFieldName(obj, name) {
     if (obj[name] === void 0) return _extensionMethods[name]();
     return name;
   }
 
   function dsend(obj, method/*, ...args*/) {
@@ skipping 425 matching lines @@
   function fn(closure/* ...args*/) {
     // Closure and a lazy type constructor
     if (arguments.length == 2) {
       defineLazyProperty(closure, _runtimeType, {get : arguments[1]});
       return closure;
     }
     var t;
     if (arguments.length == 1) {
       // No type arguments, it's all dynamic
       let len = closure.length;
-      function build() {
+      let build = () => {
         let args = Array.apply(null, new Array(len)).map(() => core.Object);
         return functionType(core.Object, args);
-      }
+      };
       // We could be called before Object is defined.
       if (core.Object === void 0) return fn(closure, build);
       t = build();
     } else {
       // We're passed the piecewise components of the function type,
       // construct it.
       let args = Array.prototype.slice.call(arguments, 1);
       t = functionType.apply(null, args);
     }
     setRuntimeType(closure, t);
@@ skipping 425 matching lines @@
   }
 
   /// 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;

[Jennifer Messerly, 2015/05/29 23:02:21]

it doesn't like unnecessary locals

+    return functionType.apply(null, parts);
   }
 
   /// 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;
+    return functionType.apply(null, parts);
   }
   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)
+    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() {
+      defineProperty(f[name], _runtimeType, { get: function() {
         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
    * add it. For example:
    *
    *     var map = new Map();
    *     putIfAbsent(map, [1, 2, 'hi ', 'there '], () => 'world');
@@ skipping 162 matching lines @@
   _js_primitives.printString = (s) => console.log(s);
 
   // TODO(vsm): Plumb this correctly.
   // See: https://github.com/dart-lang/dev_compiler/issues/40
   String.prototype.contains = function(sub) { return this.indexOf(sub) >= 0; }
   let _split = String.prototype.split;
   String.prototype.split = function() {
     let result = _split.apply(this, arguments);
     dart.setType(result, core.List$(core.String));
     return result;
-  }
+  };
   String.prototype.get = function(i) {
     return this[i];
-  }
+  };
   String.prototype.codeUnitAt = function(i) {
     return this.charCodeAt(i);
-  }
+  };
   String.prototype.replaceAllMapped =  function(from, cb) {
     return this.replace(from.multiple, function() {
       // Remove offset & string from the result array
       var matches = arguments;
       matches.splice(-2, 2);
       // The callback receives match, p1, ..., pn
       return cb(matches);
     });
-  }
+  };
   String.prototype['+'] = function(arg) { return this.valueOf() + arg; };
 
   Boolean.prototype['!'] = function() { return !this.valueOf(); };
   Boolean.prototype['&&'] = function(arg) { return this.valueOf() && arg; };
   Boolean.prototype['||'] = function(arg) { return this.valueOf() || arg; };
   Number.prototype['<'] = function(arg) { return this.valueOf() < arg; };
   Number.prototype['<='] = function(arg) { return this.valueOf() <= arg; };
   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 = {}));