Redo how Type objects are exposed from DDC.

tool/input_sdk/private/ddc_runtime/rtti.dart

 // 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.
 
 /// This library defines the association between runtime objects and
 /// runtime types.
 part of dart._runtime;
 
-///
 /// Runtime type information.  This module defines the mapping from
 /// runtime objects to their runtime type information.  See the types
 /// module for the definition of how type information is represented.
 ///
-/// Runtime objects fall into four main categories:
+/// There are two kinds of objects that represent "types" at runtime. A
+/// "runtime type" contains all of the data needed to implement the runtime
+/// type checking inserted by the compiler. These objects fall into four
+/// categories:
 ///
 ///   - Things represented by javascript primitives, such as
 ///     null, numbers, booleans, strings, and symbols.  For these
 ///     we map directly from the javascript type (given by typeof)
 ///     to the appropriate class type from core, which serves as their
 ///     rtti.
 ///
 ///   - Functions, which are represented by javascript functions.
 ///     Representations of Dart functions always have a
 ///     _runtimeType property attached to them with the appropriate
 ///     rtti.
 ///
 ///   - Objects (instances) which are represented by instances of
 ///     javascript (ES6) classes.  Their types are given by their
 ///     classes, and the rtti is accessed by projecting out their
 ///     constructor field.
 ///
 ///   - Types objects, which are represented as described in the types
 ///     module.  Types always have a _runtimeType property attached to
 ///     them with the appropriate rtti.  The rtti for these is always
 ///     core.Type.  TODO(leafp): consider the possibility that we can
 ///     reliably recognize type objects and map directly to core.Type
 ///     rather than attaching this property everywhere.
 ///
-///
+/// The other kind of object representing a "type" is the instances of the
+/// dart:core Type class. These are the user visible objects you get by calling
+/// "runtimeType" on an object or using a class literal expression. These are
+/// different from the above objects, and are created by calling `wrapType()`
+/// on a runtime type.
 
-///
-///Tag a closure with a type, using one of three forms:
+/// Tags a closure with a type, using one of three forms:
 /// dart.fn(cls) marks cls has having no optional or named
 ///  parameters, with all argument and return types as dynamic
 /// dart.fn(cls, func) marks cls with the lazily computed
 ///  runtime type as computed by func()
 /// dart.fn(cls, rType, argsT, extras) marks cls as having the
 /// runtime type dart.functionType(rType, argsT, extras)
 ///
 /// Note that since we are producing a type for a concrete function,
 /// it is sound to use the definite arrow type.
 ///
@@ skipping 33 matching lines @@
     case "symbol":
       return Symbol;
   }
   // Undefined is handled above. For historical reasons,
   // typeof null == "object" in JS.
   if ($obj === null) return $Null;
   return null;
 })()''');
 
 runtimeType(obj) => JS('', '''(() => {
-  // Lookup primitive (int/double/string)
+  // Handle primitives where the method isn't on the object.
   let result = $checkPrimitiveType($obj);
-  if (result !== null) return result;
+  if (result !== null) return $wrapType(result);
 
-  // Lookup recorded type
-  result = $obj.runtimeType;
-  if (result) return result;
-
-  return $_nonPrimitiveRuntimeType(obj);
+  // Delegate to the actual method on the object.

[Jennifer Messerly, 2016/05/02 23:04:20]

it might be worth a comment/TODO here, this issue has background:
https://github.com/dart-lang/dev_compiler/issues/451

If I run `cd tool/input_sdk; git grep "get runtimeType"` there are a bunch of
hits in the SDK, mostly in native_typed_data ... those won't work. So if we've
got an extension type, we need to call into the extension method.

This issue affects all Object members (toString, nSM, hashCode, runtimeType) not
just runtimeType.

But might be worth leaving a note, because otherwise the code looks wrong (well,
it is, but the problem already existed)

+  return $obj.runtimeType;
 })()''');
 
 getFunctionType(obj) => JS('', '''(() => {
   // TODO(vsm): Encode this properly on the function for Dart-generated code.
   let args = Array($obj.length).fill($dynamicR);
   return $definiteFunctionType($bottom, args);
 })()''');
 
+/// The base implementation of Object.runtimeType.
+objectRuntimeType(obj) => JS('', '''(() => {

[Jennifer Messerly, 2016/05/02 23:04:20]

Hey so I've been trying to clean these up. You can write this as just:

    objectRuntimeType(obj) => wrapType(getReifiedType(obj));

Not all Dart code works in this magic library, because we haven't bootstrapped
the runtime by the point it executes, but I'm trying to bring sanity where I can
:)

[Bob Nystrom, 2016/05/03 20:50:47]

Done.

+  return $wrapType($getReifiedType($obj));
+})()''');
+
+/// Returns an the runtime representation of the type of obj.
 ///
-/// Returns the runtime type of obj. This is the same as `obj.realRuntimeType`
-/// but will not call an overridden getter.
-///
-/// Currently this will return null for non-Dart objects.
-///
-realRuntimeType(obj) => JS('', '''(() => {
+/// The resulting object is used internally for runtime type checking. This is
+/// different from the user-visible Type object returned by calling
+/// `runtimeType` on some Dart object.
+getReifiedType(obj) => JS('', '''(() => {

[Jennifer Messerly, 2016/05/02 23:04:20]

if you feel like it -- cleanup idea :)

getReifiedType(obj) {
  var result = checkPrimitiveType(obj);
  if (result != null) return result;
  return _nonPrimitiveRuntimeType(obj);
}

[Bob Nystrom, 2016/05/03 20:50:47]

Done.

   // Lookup primitive type
   let result = $checkPrimitiveType($obj);
   if (result !== null) return result;
 
   return $_nonPrimitiveRuntimeType(obj);
 })()''');
 
 _nonPrimitiveRuntimeType(obj) => JS('', '''(() => {
   // Lookup recorded *real* type (not user definable runtimeType)
   // TODO(vsm): Should we treat Dart and JS objects differently here?
   // E.g., we can check if obj instanceof core.Object to differentiate.
   let result = $obj[$_runtimeType];
   if (result) return result;
 
   // Lookup extension type
   result = $obj[$_extensionType];
   if (result) return result;
 
   // Fallback on constructor for class types
   result = $obj.constructor;
   if (result == Function) {
     // An undecorated Function should have come from
     // JavaScript.  Treat as untyped.
     return $jsobject;
   }
   return result;
 })()''');
 
+/// Given an internal runtime type object, wraps it in a `WrappedType` object
+/// that implements the dart:core Type interface.
+wrapType(type) => JS('', '''(() => {

[Jennifer Messerly, 2016/05/02 23:04:20]

nowadays we'd write this more like:

wrapType(type) {
  // If we've already wrapped this type once, use the previous wrapper. This
  // way, multiple references to the same type return an identical Type.
  if (JS('bool', '#.hasOwnProperty(#)', type, _typeObject)) {
    return JS('', '#[#]', type, _typeObject);
  }
  return JS('', '#[#] = new #(#)', type, _typeObject, WrappedType, type);
}


Same code, but implemented more consistently with our dart2js inherited SDK.
It's kind of like inline ASM. Also matches how code_generator.dart looks.

[Bob Nystrom, 2016/05/03 20:50:47]

Done.

+  // If we've already wrapped this type once, use the previous wrapper. This
+  // way, multiple references to the same type return an identical Type.
+  if ($type.hasOwnProperty($_typeObject)) {
+    return $type[$_typeObject];
+  }
+
+  return $type[$_typeObject] = new $WrappedType($type);
+})()''');
+
 read(value) => JS('', '#[#]', value, _runtimeType);
 
 /// Tag the runtime type of [value] to be type [t].
 void tag(value, t) {
   JS('', '#[#] = #', value, _runtimeType, t);
 }
 
 tagComputed(value, compute) {
   JS('', '#(#, #, { get: # })', defineProperty, value, _runtimeType, compute);
 }
 
 tagMemoized(value, compute) => JS('', '''(() => {
   let cache = null;
   function getter() {
     if ($compute == null) return cache;
     cache = $compute();
     $compute = null;
     return cache;
   }
   $tagComputed($value, getter);
 })()''');