Redo how Type objects are exposed from DDC.

test/browser/runtime_tests.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 assert = chai.assert;
 var dart_sdk = dart_library.import('dart_sdk');
 var core = dart_sdk.core;
 var collection = dart_sdk.collection;
 var dart = dart_sdk.dart;
 var dartx = dart.dartx;
@@ skipping 101 matching lines @@
 suite('instanceOf', () => {
   "use strict";
 
   let expect = assert.equal;
   let isGroundType = dart.isGroundType;
   let generic = dart.generic;
   let intIsNonNullable = false;
   let cast = dart.as;
   let instanceOf = dart.is;
   let strongInstanceOf = dart.strongInstanceOf;
-  let runtimeType = dart.realRuntimeType;
+  let getReifiedType = dart.getReifiedType;
   let functionType = dart.functionType;
   let typedef = dart.typedef;
   let isSubtype = dart.isSubtype;
 
   let Object = core.Object;
   let String = core.String;
   let dynamic = dart.dynamic;
   let List = core.List;
   let Map = core.Map;
   let Map$ = core.Map$;
@@ skipping 73 matching lines @@
     if (!strongOnly) {
       expect(instanceOf(x, type), expectedTrue);
     } else {
       assert.throws(() => instanceOf(x, type), dart.StrongModeError);
       expect(strongInstanceOf(x, type), expectedTrue);
     }
   }
 
   test('int', () => {
     expect(isGroundType(int), true);
-    expect(isGroundType(runtimeType(5)), true);
+    expect(isGroundType(getReifiedType(5)), true);
 
     checkType(5, int);
     checkType(5, dynamic);
     checkType(5, Object);
     checkType(5, num);
 
     checkType(5, bool, false);
     checkType(5, String, false);
 
     expect(cast(5, int), 5);
@@ skipping 26 matching lines @@
     checkType(null, core.String, false);
     checkType(null, core.int, false);
     checkType(null, Map, false);
     checkType(void 0, core.Null);
     checkType(void 0, core.Object);
     checkType(void 0, dart.dynamic);
   });
 
   test('String', () => {
     expect(isGroundType(String), true);
-    expect(isGroundType(runtimeType("foo")), true);
+    expect(isGroundType(getReifiedType("foo")), true);
     checkType("foo", String);
     checkType("foo", Object);
     checkType("foo", dynamic);
 
     expect(cast(null, String), null);
   });
 
   test('Map', () => {
     let m1 = new (Map$(String, String))();
     let m2 = new (Map$(Object, Object))();
     let m3 = new Map();
     let m4 = new (collection.HashMap$(dart.dynamic, dart.dynamic))();
     let m5 = new collection.LinkedHashMap();
     let m6 = new (Map$(String, dart.dynamic))();
 
 
     expect(isGroundType(Map), true);
-    expect(isGroundType(runtimeType(m1)), false);
+    expect(isGroundType(getReifiedType(m1)), false);
     expect(isGroundType(Map$(String, String)), false);
-    expect(isGroundType(runtimeType(m2)), true);
+    expect(isGroundType(getReifiedType(m2)), true);
     expect(isGroundType(Map$(Object, Object)), true);
-    expect(isGroundType(runtimeType(m3)), true);
+    expect(isGroundType(getReifiedType(m3)), true);
     expect(isGroundType(Map), true);
-    expect(isGroundType(runtimeType(m4)), true);
+    expect(isGroundType(getReifiedType(m4)), true);
     expect(isGroundType(collection.HashMap$(dynamic, dynamic)), true);
-    expect(isGroundType(runtimeType(m5)), true);
+    expect(isGroundType(getReifiedType(m5)), true);
     expect(isGroundType(collection.LinkedHashMap), true);
     expect(isGroundType(collection.LinkedHashMap), true);
 
     // Map<T1,T2> <: Map
     checkType(m1, Map);
     checkType(m1, Object);
 
     // Instance of self
-    checkType(m1, runtimeType(m1));
+    checkType(m1, getReifiedType(m1));
     checkType(m1, Map$(String, String));
 
     // Covariance on generics
-    checkType(m1, runtimeType(m2));
+    checkType(m1, getReifiedType(m2));
     checkType(m1, Map$(Object, Object));
 
     // No contravariance on generics.
-    checkType(m2, runtimeType(m1), false, true);
+    checkType(m2, getReifiedType(m1), false, true);
     checkType(m2, Map$(String, String), false, true);
 
     // null is! Map
     checkType(null, Map, false);
 
     // Raw generic types
     checkType(m5, Map);
     checkType(m4, Map);
 
     // Is checks
@@ skipping 34 matching lines @@
     isSubtype(getType(C), dart.functionType(C, [core.String]), false);
     isSubtype(getType(C, 'C'), dart.functionType(C, [core.int]));
     isSubtype(getType(C, 'C'), dart.functionType(C, [core.String]), false);
     isSubtype(getType(C, 'named'), dart.functionType(C, [core.int, core.int]));
     isSubtype(getType(C, 'named'),
               dart.functionType(C, [core.int, core.String]), false);
   });
 
   test('generic and inheritance', () => {
     let aaraw = new AA();
-    let aarawtype = runtimeType(aaraw);
+    let aarawtype = getReifiedType(aaraw);
     let aadynamic = new (AA$(dynamic, dynamic))();
-    let aadynamictype = runtimeType(aadynamic);
+    let aadynamictype = getReifiedType(aadynamic);
     let aa = new (AA$(String, List))();
-    let aatype = runtimeType(aa);
+    let aatype = getReifiedType(aa);
     let bb = new (BB$(String, List))();
-    let bbtype = runtimeType(bb);
+    let bbtype = getReifiedType(bb);
     let cc = new CC();
-    let cctype = runtimeType(cc);
+    let cctype = getReifiedType(cc);
     // We don't allow constructing bad types.
     // This was AA<String> in Dart (wrong number of type args).
     let aabad = new (AA$(dart.dynamic, dart.dynamic))();
-    let aabadtype = runtimeType(aabad);
+    let aabadtype = getReifiedType(aabad);
 
     expect(isGroundType(aatype), false);
     expect(isGroundType(AA$(String, List)), false);
     expect(isGroundType(bbtype), false);
     expect(isGroundType(BB$(String, List)), false);
     expect(isGroundType(cctype), true);
     expect(isGroundType(CC), true);
     checkType(cc, aatype, false, true);
     checkType(cc, AA$(String, List), false, true);
     checkType(cc, bbtype);
@@ skipping 80 matching lines @@
     checkType(bar5, functionType(B, [B, String]));
     checkType(cls5, functionType(B, [B, String]));
     checkType(bar6, Foo, false, true);
     checkType(cls6, Foo, false, true);
     checkType(bar6, functionType(B, [B, String]), false, true);
     checkType(cls6, functionType(B, [B, String]), false, true);
     checkType(bar7, Foo);
     checkType(cls7, Foo);
     checkType(bar7, functionType(B, [B, String]));
     checkType(cls7, functionType(B, [B, String]));
-    checkType(bar7, runtimeType(bar6));
-    checkType(cls7, runtimeType(bar6));
+    checkType(bar7, getReifiedType(bar6));
+    checkType(cls7, getReifiedType(bar6));
     checkType(bar8, Foo);
     checkType(cls8, Foo);
     checkType(bar8, functionType(B, [B, String]));
     checkType(cls8, functionType(B, [B, String]));
-    checkType(bar8, runtimeType(bar6), false, true);
-    checkType(cls8, runtimeType(bar6), false, true);
-    checkType(bar7, runtimeType(bar8), false, true);
-    checkType(cls7, runtimeType(bar8), false, true);
-    checkType(bar8, runtimeType(bar7), false, true);
-    checkType(cls8, runtimeType(bar7), false, true);
+    checkType(bar8, getReifiedType(bar6), false, true);
+    checkType(cls8, getReifiedType(bar6), false, true);
+    checkType(bar7, getReifiedType(bar8), false, true);
+    checkType(cls7, getReifiedType(bar8), false, true);
+    checkType(bar8, getReifiedType(bar7), false, true);
+    checkType(cls8, getReifiedType(bar7), false, true);
 
     // Parameterized typedefs
     expect(isGroundType(FuncG), true);
     expect(isGroundType(FuncG$(B, String)), false);
     checkType(bar1, FuncG$(B, String), false, true);
     checkType(cls1, FuncG$(B, String), false, true);
     checkType(bar3, FuncG$(B, String));
     checkType(cls3, FuncG$(B, String));
   });
 
@@ skipping 245 matching lines @@
     var m = dart.bind(obj, 'm');
     checkType(m, dart.functionType(core.Object, [core.int]));
     checkType(m, dart.functionType(core.int, [core.int]), false, true);
   });
 
   test('Object members', () => {
     let nullHash = dart.hashCode(null);
     assert.equal(nullHash, 0);
     let nullString = dart.toString(null);
     assert.equal(nullString, 'null');
-    let nullType = dart.runtimeType(null);
-    assert.equal(nullType, core.Null);
 
     let map = new Map();
     let mapHash = dart.hashCode(map);
     checkType(mapHash, core.int);
     assert.equal(mapHash, map.hashCode);
 
     let mapString = dart.toString(map);
     assert.equal(mapString, map.toString());
     checkType(mapString, core.String);
-    let mapType = dart.runtimeType(map);
-    assert.equal(mapType, map.runtimeType);
 
     let str = "A string";
     let strHash = dart.hashCode(str);
     checkType(strHash, core.int);
 
     let strString = dart.toString(str);
     checkType(strString, core.String);
     assert.equal(str, strString);
-    let strType = dart.runtimeType(str);
-    assert.equal(strType, core.String);
 
     let n = 42;
     let intHash = dart.hashCode(n);
     checkType(intHash, core.int);
 
     let intString = dart.toString(n);
     assert.equal(intString, '42');
-    let intType = dart.runtimeType(n);
-    assert.equal(intType, core.int);
   });
 });
 
 suite('primitives', function() {
   'use strict';
 
   test('fixed length list', () => {
     let list = new core.List(10);
     list[0] = 42;
     assert.throws(() => list.add(42));
   });
 });