Redo how Type objects are exposed from DDC.

tool/input_sdk/private/ddc_runtime/types.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 representation of runtime types.
 part of dart._runtime;
 
 /// The Symbol for storing type arguments on a specialized generic type.
 final _mixins = JS('', 'Symbol("mixins")');
 @JSExportName('implements')
 final implements_ = JS('', 'Symbol("implements")');
 final metadata = JS('', 'Symbol("metadata")');
 
+/// The symbol used to store the cached `Type` object associated with a class.
+final _typeObject = JS('', 'Symbol("typeObject")');
 
+/// Types in dart are represented internally at runtime as follows.
 ///
-/// Types in dart are represented at runtime as follows.
 ///   - Normal nominal types, produced from classes, are represented
 ///     at runtime by the JS class of which they are an instance.
 ///     If the type is the result of instantiating a generic class,
 ///     then the "classes" module manages the association between the
 ///     instantiated class and the original class declaration
 ///     and the type arguments with which it was instantiated.  This
 ///     assocation can be queried via the "classes" module".
 ///
 ///   - All other types are represented as instances of class TypeRep,
 ///     defined in this module.
 ///     - Dynamic, Void, and Bottom are singleton instances of sentinal
 ///       classes.
 ///     - Function types are instances of subclasses of AbstractFunctionType.
 ///
 /// Function types are represented in one of two ways:
 ///   - As an instance of FunctionType.  These are eagerly computed.
 ///   - As an instance of TypeDef.  The TypeDef representation lazily
 ///     computes an instance of FunctionType, and delegates to that instance.
 ///
-/// All types satisfy the following interface:
-///  get String name;
-///  String toString();
+/// These above "runtime types" are what is used for implementing DDC's
+/// internal type checks. These objects are distinct from the objects exposed
+/// to user code by class literals and calling `Object.runtimeType`. In DDC,
+/// the latter are represented by instances of WrappedType which contain a
+/// real runtime type internally. This ensures that the returned object only
+/// exposes the API that Type defines:
 ///
-///
+///     get String name;
+///     String toString();
 final TypeRep = JS('', '''
   class TypeRep {
     get name() { return this.toString(); }
     get [$_runtimeType]() { return $Type; }
   }
 ''');
 
 final Dynamic = JS('', '''
   class Dynamic extends $TypeRep {
     toString() { return "dynamic"; }
@@ skipping 17 matching lines @@
 ''');
 final bottom = JS('', 'new $Bottom()');
 
 final JSObject = JS('', '''
   class JSObject extends $TypeRep {
     toString() { return "NativeJavaScriptObject"; }
   }
 ''');
 final jsobject = JS('', 'new $JSObject()');
 
+final WrappedType = JS('', '''
+  class WrappedType extends $TypeRep {
+    constructor(type) {
+      super();
+      this._runtimeType = type;
+    }
+    toString() { return $typeName(this._runtimeType); }
+  }
+''');
+
 final AbstractFunctionType = JS('', '''
   class AbstractFunctionType extends $TypeRep {
     constructor() {
       super();
       this._stringValue = null;
     }
 
     toString() { return this.name; }
 
     get name() {
@@ skipping 208 matching lines @@
 bool isDartType(type) => JS('bool', '#(#) === #', _getRuntimeType, type, Type);
 
 typeName(type) => JS('', '''(() => {
   // Non-instance types
   if ($type instanceof $TypeRep) return $type.toString();
   // Instance types
   let tag = $_getRuntimeType($type);
   if (tag === $Type) {
     let name = $type.name;
     let args = $getGenericArgs($type);
-    if (args) {
-      name += '<';
-      for (let i = 0; i < args.length; ++i) {
-        if (i > 0) name += ', ';
-        name += $typeName(args[i]);
-      }
-      name += '>';
+    if (!args) return name;
+
+    let result = name;
+    let allDynamic = true;
+
+    result += '<';
+    for (let i = 0; i < args.length; ++i) {
+      if (i > 0) name += ', ';
+
+      let argName = $typeName(args[i]);
+      if (argName != 'dynamic') allDynamic = false;
+
+      result += argName;
     }
-    return name;
+    result += '>';
+
+    // Don't print the type arguments if they are all dynamic. Show "raw"
+    // types as just the bare type name.
+    if (allDynamic) return name;
+    return result;
   }
   if (tag) return "Not a type: " + tag.name;
   return "JSObject<" + $type.name + ">";
 })()''');
 
 /// Get the underlying function type, potentially from the call method
 /// for a class type.
 getImplicitFunctionType(type) => JS('', '''(() => {
   if ($isFunctionType($type)) return $type;
   return $getMethodTypeFromType(type, 'call');
@@ skipping 73 matching lines @@
   }
 
   return true;
 })()''');
 
 ///
 /// Computes the canonical type.
 /// This maps JS types onto their corresponding Dart Type.
 ///
 // TODO(jmesserly): lots more needs to be done here.
-canonicalType(t) {
-  if (JS('bool', '# === Object', t)) return Object;
-  if (JS('bool', '# === Function', t)) return Function;
-  if (JS('bool', '# === Array', t)) return List;
+canonicalType(t) => JS('', '''(() => {
+  if (t === Object) return Object;
+  if (t === Function) return Function;
+  if (t === Array) return List;
 
   // We shouldn't normally get here with these types, unless something strange
   // happens like subclassing Number in JS and passing it to Dart.
-  if (JS('bool', '# === String', t)) return String;
-  if (JS('bool', '# === Number', t)) return double;
-  if (JS('bool', '# === Boolean', t)) return bool;
-  return t;
-}
+  if (t === String) return String;
+  if (t === Number) return double;
+  if (t === Boolean) return bool;
+   return t;
+})()''');
 
 final subtypeMap = JS('', 'new Map()');
 isSubtype(t1, t2) => JS('', '''(() => {
   // See if we already know the answer
   // TODO(jmesserly): general purpose memoize function?
   let map = $subtypeMap.get($t1);
   let result;
   if (map) {
     result = map.get($t2);
     if (result !== void 0) return result;
@@ skipping 127 matching lines @@
     return true;
   }
 
   let typeArgs = $getGenericArgs($type);
   if (!typeArgs) return true;
   for (let t of typeArgs) {
     if (t != $Object && t != $dynamicR) return false;
   }
   return true;
 })()''');