canonicalize const

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;
 (function (dart) {
   'use strict';
 
   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) {
     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 a in r) {
-      let arg = r[a];
+    for (let arg of r) {
       arg.replace(FN_ARG, function(all, underscore, name){
         args.push(name);
       });
     }
     return args;
   }
 
   function dload(obj, field) {
     if (!(field in obj)) {
       throw new core.NoSuchMethodError(obj, field);
@@ skipping 278 matching lines @@
   }
 
   // TODO(jmesserly): this isn't currently used, but it could be if we want
   // `obj is NonGroundType<T,S>` to be rejected at runtime instead of compile
   // time.
   function isGroundType(type) {
     // TODO(vsm): Cache this if we start using it at runtime.
 
     if (type instanceof AbstractFunctionType) {
       if (!_isTop(type.returnType, false)) return false;
-      for (var i = 0; i < type.args.length; ++i) {
+      for (let i = 0; i < type.args.length; ++i) {
         if (!_isBottom(type.args[i], true)) return false;
       }
-      for (var i = 0; i < type.optionals.length; ++i) {
+      for (let i = 0; i < type.optionals.length; ++i) {
         if (!_isBottom(type.optionals[i], true)) return false;
       }
-      var names = Object.getOwnPropertyNames(type.named);
-      for (var i = 0; i < names.length; ++i) {
+      var names = getOwnPropertyNames(type.named);
+      for (let i = 0; i < names.length; ++i) {
         if (!_isBottom(type.named[names[i]], true)) return false;
       }
       return true;
     }
 
     let typeArgs = safeGetOwnProperty(type, dart.typeArguments);
     if (!typeArgs) return true;
     for (let t of typeArgs) {
       if (t != core.Object && t != dart.dynamic) return false;
     }
@@ skipping 30 matching lines @@
 
   class AbstractFunctionType {
     constructor() {
       this._stringValue = null;
     }
 
     get name() {
       if (this._stringValue) return this._stringValue;
 
       var buffer = '(';
-      for (var i = 0; i < this.args.length; ++i) {
+      for (let i = 0; i < this.args.length; ++i) {
         if (i > 0) {
           buffer += ', ';
         }
         buffer += _typeName(this.args[i]);
       }
       if (this.optionals.length > 0) {
         if (this.args.length > 0) buffer += ', ';
         buffer += '[';
-        for (var i = 0; i < this.optionals.length; ++i) {
+        for (let i = 0; i < this.optionals.length; ++i) {
           if (i > 0) {
             buffer += ', ';
           }
           buffer += _typeName(this.optionals[i]);
         }
         buffer += ']';
       } else if (this.named.length > 0) {
         if (this.args.length > 0) buffer += ', ';
         buffer += '{';
-        let names = Object.getOwnPropertyNames(this.named).sort();
-        for (var i = 0; i < names.length; ++i) {
+        let names = getOwnPropertyNames(this.named).sort();
+        for (let i = 0; i < names.length; ++i) {
           if (i > 0) {
             buffer += ', ';
           }
           buffer += names[i] + ': ' + _typeName(this.named[names[i]]);
         }
         buffer += '}';
       }
 
       buffer += ') -> ' + _typeName(this.returnType);
       this._stringValue = buffer;
@@ skipping 100 matching lines @@
       }
     }
 
     let args1 = ft1.args;
     let args2 = ft2.args;
 
     if (args1.length > args2.length) {
       return false;
     }
 
-    for (var i = 0; i < args1.length; ++i) {
+    for (let i = 0; i < args1.length; ++i) {
       if (!isSubtype_(args2[i], args1[i], true)) {
         return false;
       }
     }
 
     let optionals1 = ft1.optionals;
     let optionals2 = ft2.optionals;
 
     if (args1.length + optionals1.length < args2.length + optionals2.length) {
       return false;
     }
 
     var j = 0;
-    for (var i = args1.length; i < args2.length; ++i, ++j) {
+    for (let i = args1.length; i < args2.length; ++i, ++j) {
       if (!isSubtype_(args2[i], optionals1[j], true)) {
         return false;
       }
     }
 
-    for (var i = 0; i < optionals2.length; ++i, ++j) {
+    for (let i = 0; i < optionals2.length; ++i, ++j) {
       if (!isSubtype_(optionals2[i], optionals1[j], true)) {
         return false;
       }
     }
 
     let named1 = ft1.named;
     let named2 = ft2.named;
 
-    let names = Object.getOwnPropertyNames(named2);
-    for (var i = 0; i < names.length; ++i) {
+    let names = getOwnPropertyNames(named2);
+    for (let i = 0; i < names.length; ++i) {
       let name = names[i];
-      let n1 = named1[name]
+      let n1 = named1[name];
       let n2 = named2[name];
       if (n1 === void 0) {
         return false;
       }
       if (!isSubtype_(n2, n1, true)) {
         return false;
       }
     }
 
     return true;
@@ skipping 23 matching lines @@
       lazySetter(value);
       return value;
     }
     desc.get = lazyGetter;
     desc.configurable = true;
     if (writable) desc.set = lazySetter;
     defineProperty(to, name, desc);
   }
 
   function defineLazy(to, from) {
-    let names = getOwnPropertyNames(from);
-    for (let i = 0; i < names.length; i++) {
-      let name = names[i];
+    for (let name of getOwnNamesAndSymbols(from)) {
       defineLazyProperty(to, name, getOwnPropertyDescriptor(from, name));
     }
   }
   // TODO(jmesserly): these are identical, but this makes it easier to grep for.
   dart.defineLazyClass = defineLazy;
   dart.defineLazyProperties = defineLazy;
   dart.defineLazyClassGeneric = defineLazyProperty;
 
   /**
    * Copy properties from source to destination object.
    * This operation is commonly called `mixin` in JS.
    */
   function copyProperties(to, from) {
-    function copyPropertiesHelper(names) {
-      for (let i = 0; i < names.length; i++) {
-        let name = names[i];
-        defineProperty(to, name, getOwnPropertyDescriptor(from, name));
-      }
+    for (let name of getOwnNamesAndSymbols(from)) {
+      defineProperty(to, name, getOwnPropertyDescriptor(from, name));
     }
-    copyPropertiesHelper(getOwnPropertyNames(from));
-    copyPropertiesHelper(getOwnPropertySymbols(from));
     return to;
   }
   dart.copyProperties = copyProperties;
 
   /**
    * This is called whenever a derived class needs to introduce a new field,
    * shadowing a field or getter/setter pair on its parent.
    *
    * This is important because otherwise, trying to read or write the field
    * would end up calling the getter or setter, and one of those might not even
@@ skipping 73 matching lines @@
   // TODO(jmesserly): this could be faster
   function map(values) {
     let map = new collection.LinkedHashMap();
     if (Array.isArray(values)) {
       for (let i = 0, end = values.length - 1; i < end; i += 2) {
         let key = values[i];
         let value = values[i + 1];
         map.set(key, value);
       }
     } else if (typeof values === 'object') {
-      for (let key of Object.getOwnPropertyNames(values)) {
+      for (let key of getOwnPropertyNames(values)) {
         map.set(key, values[key]);
       }
     }
     return map;
   }
   dart.map = map;
 
   function assert(condition) {
     // TODO(jmesserly): throw assertion error.
     if (!condition) throw 'assertion failed';
@@ skipping 59 matching lines @@
           }
           map.set(arg, value);
         }
       }
       return value;
     }
     return makeGenericType;
   }
   dart.generic = generic;
 
+  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');
+   *
+   * ... will create a Map with a structure like:
+   *
+   *     { 1: { 2: { 'hi ': { 'there ': 'world' } } } }
+   */
+  function multiKeyPutIfAbsent(map, keys, valueFn) {
+    for (let k of keys) {
+      let value = map.get(k);
+      if (!value) {
+        // TODO(jmesserly): most of these maps are very small (e.g. 1 item),
+        // so it may be worth optimizing for that.
+        map.set(k, value = new Map());
+      }
+      map = value;
+    }
+    if (map.has(_value)) return map.get(_value);
+    let value = valueFn();
+    map.set(_value, value);
+    return value;
+  }
+
+  /** The global constant table. */
+  let constants = new Map();
+
+  /**
+   * Canonicalize a constant object.
+   *
+   * Preconditions:
+   * - `obj` is an objects or array, not a primitive.
+   * - nested values of the object are themselves already canonicalized.
+   */
+  function constant(obj) {
+    let objectKey = [getRuntimeType(obj)];
+    // There's no guarantee in JS that names/symbols are returned in the same
+    // order. We could probably get the same order if we're judicious about
+    // initializing them, but easier to not depend on that.
+    for (let name of getOwnNamesAndSymbols(obj)) {
+      // TODO(jmesserly): we can make this faster if needed.
+      objectKey.push(name);
+      objectKey.push(obj[name]);
+    }
+    return multiKeyPutIfAbsent(constants, objectKey, () => obj);
+  }
+  dart.const = constant;
+
   /** Sets the runtime type of `obj` to be `type` */
   function setType(obj, type) {
     obj[runtimeType] = type;
   }
   dart.setType = setType;
 
   // TODO(jmesserly): right now this is a sentinel. It should be a type object
   // of some sort, assuming we keep around `dynamic` at runtime.
   dart.dynamic = { toString() { return 'dynamic'; } };
   dart.void = { toString() { return 'void'; } };
   dart.bottom = { toString() { return 'bottom'; } };
 
   dart.global = window || global;
   dart.JsSymbol = Symbol;
 
   // TODO(jmesserly): hack to bootstrap the SDK
   _js_helper = _js_helper || {};
   _js_helper.checkNum = notNull;
 
 })(dart || (dart = {}));