Generate static calls for Object fields and methods

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;
@@ skipping 78 matching lines @@
 
   function dsend(obj, method/*, ...args*/) {
     let args = Array.prototype.slice.call(arguments, 2);
     return checkAndCall(obj[method], obj, args, method);
   }
   dart.dsend = dsend;
 
   function dindex(obj, index) {
     // TODO(jmesserly): remove this special case once Array extensions are
     // hooked up.
-    if (obj instanceof Array && getRuntimeType(index) == core.int) {
+    if (obj instanceof Array && runtimeType(index) == core.int) {
       return obj[index];
     }
     return checkAndCall(obj.get, obj, [index], '[]');
   }
   dart.dindex = dindex;
 
   function dsetindex(obj, index, value) {
     return checkAndCall(obj.set, obj, [index, value], '[]=');
   }
   dart.dsetindex = dsetindex;
 
   /**
    * Returns bound `method`.
    * This helper function avoids needing a temp for `obj`.
    */
   function bind(obj, method) {
     // This is a static bind (dynamic would use `dload`) so no need to check
     // if `method` is really there on `obj`.`
     return obj[method].bind(obj);
   }
   dart.bind = bind;
 
   function cast(obj, type) {
     // TODO(vsm): handle non-nullable types
     if (obj == null) return obj;
-    let actual = getRuntimeType(obj);
+    let actual = runtimeType(obj);
     if (isSubtype(actual, type)) return obj;
     throw new _js_helper.CastErrorImplementation(actual, type);
   }
   dart.as = cast;
 
 
   // TODO(vsm): How should we encode the runtime type?
-  let runtimeType = Symbol('runtimeType');
+  let _runtimeType = Symbol('_runtimeType');
 
   /**
    * Returns the runtime type of obj. This is the same as `obj.runtimeType`
    * but will not call an overridden getter.
    *
    * Currently this will return null for non-Dart objects.
    */
-  function getRuntimeType(obj) {
+  function runtimeType(obj) {

[Jennifer Messerly, 2015/04/23 19:01:42]

The intent of this method was "get the _real_ runtimeType", inspired by
`getRuntimeType` in _js_helper. So the Object.runtimeType getter should return
this, but in Dart, you can override the runtimeType getter. In other words, we
really need two methods:

realRuntimeType(obj) --> this method

runtimeType(obj) {
  // ... check null and primitives ...

  // delegate to user code
  return obj.runtimeType;
}

I guess they probably need some common code for the null/primitives

[vsm, 2015/04/23 20:35:55]

I've split this back out for now.

The other option to consider is disallowing override of runtimeType.  I was
leaning toward this, but I guess there is no strong reason to for now ... we
don't use it for actual type checks and neither does dart2js/vm AFAIK.

     switch (typeof obj) {
       case "undefined":
         return core.Null;
       case "number":
         return Math.floor(obj) == obj ? core.int : core.double;
       case "boolean":
         return core.bool;
       case "string":
         return core.String;
       case "symbol":
         return Symbol;
     }
     // Undefined is handled above. For historical reasons,
     // typeof null == "object" in JS.
     if (obj === null) return core.Null;
     // TODO(vsm): Should we treat Dart and JS objects differently here?
     // E.g., we can check if obj instanceof core.Object to differentiate.
-    var result = obj[runtimeType];
+    var result = obj[_runtimeType];
     if (result) return result;
     result = obj.constructor;
     if (result == Function) {
       return getFunctionType(obj);
     }
     return result;
   }
-  dart.getRuntimeType = getRuntimeType;
+  dart.runtimeType = runtimeType;
 
   function instanceOf(obj, type) {
-    return isSubtype(getRuntimeType(obj), type);
+    return isSubtype(runtimeType(obj), type);
   }
   dart.is = instanceOf;
 
   /**
    * Computes the canonical type.
    * This maps JS types onto their corresponding Dart Type.
    */
   // TODO(jmesserly): lots more needs to be done here.
   function canonicalType(t) {
     if (t === Object) return core.Object;
@@ skipping 644 matching lines @@
   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)];
+    let objectKey = [runtimeType(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;
+    obj[_runtimeType] = type;
   }
   dart.setType = setType;
 
+  function hashCode(obj) {
+    if (obj == null) {
+      return 0;
+    }
+    // TODO(vsm): What should we do for primitives and non-Dart objects?
+    switch (typeof obj) {
+      case "undefined":
+        return core.Null;

[Jennifer Messerly, 2015/04/23 19:01:41]

copy+paste error? this code can't be reached. `obj == null` above will match
`null` and `undefined`

[vsm, 2015/04/23 20:35:55]

Done.

+      case "number":
+        return obj & 0x1FFFFFFF;
+      case "boolean":
+        return obj & 0x1FFFFFFF;
+      case "string":
+        // TODO(vsm): Call the JSString hashCode?

[Jennifer Messerly, 2015/04/23 19:01:42]

+1

[vsm, 2015/04/23 20:35:55]

Will look at primitives next.

+        return obj.length;
+    }
+    return obj.hashCode;
+  }
+  dart.hashCode = hashCode;
+
+  function toString(obj) {

[Jennifer Messerly, 2015/04/23 19:02:54]

oh, just noticed noSuchMethod helper is missing?

[vsm, 2015/04/23 20:35:55]

Added.

+    if (obj == null) {
+      return "null";
+    }
+    return obj.toString();

[Jennifer Messerly, 2015/04/23 19:02:54]

we'll have to make sure to never call dart.toString (and friends) for "super"
calls, or this will infinite loop

[vsm, 2015/04/23 20:35:55]

Good point!  I added a check to the codegen that should prevent this.

+  }
+  dart.toString = toString;
+
   // 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 = {}));