Refactor runtime into libraries, better type reps

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 core = dart.import('dart/core');
-var collection = dart.import('dart/collection');
+var core = loader.import('dart/core');
+var collection = loader.import('dart/collection');
+var dart = loader.import('dart/dart_runtime');
+var dartx = loader.import('dart/dartx');
+
+// TODO(leafp): These are here to test some things not
+// currently exposed through the main dart entry point.
+// If we decide to expose them, this can go away.
+var classes = loader.import('dart/classes');
+var types = loader.import('dart/types');
 
 suite('generic', () => {
   "use strict";
 
   let generic = dart.generic;
 
   test('zero arguments is not allowed', () => {
     assert.throws(() => { generic(function(){}); });
   });
 
@@ skipping 46 matching lines @@
     count = 0;
 
     // Nothing has been stored on the object
     assert.strictEqual(Object.keys(t1).length, 0);
     assert.strictEqual(Object.keys(t2).length, 0);
   });
 
   test('type constructor is reflectable', () => {
     let SomeType = generic(function(x, y) { return Object.create(null); });
     let someValue = SomeType('hi', 123);
-    assert.equal(someValue[dart.originalDeclaration], SomeType);
-    assert.deepEqual(someValue[dart.typeArguments], ['hi', 123]);
+    assert.equal(classes.getGenericClass(someValue), SomeType);
+    assert.deepEqual(classes.getGenericArgs(someValue), ['hi', 123]);
   });
 
   test('proper type constructor is called', () => {
     // This tests https://github.com/dart-lang/dev_compiler/issues/178
     let l = dart.list([1, 2, 3], core.int);
     let s = l[dartx.join]();
     assert.equal(s, '123');
   });
 });
 
 
 suite('instanceOf', () => {
   "use strict";
 
   let expect = assert.equal;
-  let isGroundType = dart.isGroundType;
+  let isGroundType = types.isGroundType;
   let generic = dart.generic;
   let intIsNonNullable = false;
   let cast = dart.as;
   let instanceOf = dart.is;
   let runtimeType = dart.realRuntimeType;
   let functionType = dart.functionType;
   let typedef = dart.typedef;
-  let isSubtype = dart.isSubtype;
+  let isSubtype = types.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$;
   let int = core.int;
   let num = core.num;
   let bool = core.bool;
@@ skipping 248 matching lines @@
 
     checkType(s1, c.IterableMixin);
     checkType(s1, c.IterableMixin$(String));
     checkType(s1, c.IterableMixin$(int), false);
 
     checkType(s1, c.SetMixin);
     checkType(s1, c.SetMixin$(String));
     checkType(s1, c.SetMixin$(int), false);
   });
 
+  test('Type', () => {
+    checkType(int, core.Type, true);
+    checkType(num, core.Type, true);
+    checkType(bool, core.Type, true);
+    checkType(String, core.Type, true);
+    checkType(dynamic, core.Type, true);
+    checkType(Object, core.Type, true);
+    checkType(List, core.Type, true);
+    checkType(Map, core.Type, true);
+    checkType(Map$(int, String), core.Type, true);
+    checkType(Func2, core.Type, true);
+    checkType(functionType(dynamic, [dynamic]), core.Type, true);
+    checkType(core.Type, core.Type, true);
+
+    checkType(3, core.Type, false);
+    checkType("hello", core.Type, false);
+  })
+
   test('Functions', () => {
     // - return type: Dart is bivariant.  We're covariant.
     // - param types: Dart is bivariant.  We're contravariant.
     expect(isGroundType(Func2), true);
     expect(isGroundType(Foo), false);
     expect(isGroundType(functionType(B, [B, String])), false);
     checkType(bar1, Foo, false);
     checkType(cls1, Foo, false);
     checkType(bar1, functionType(B, [B, String]), false);
     checkType(cls1, functionType(B, [B, String]), false);
@@ skipping 326 matching lines @@
 
 suite('primitives', function() {
   'use strict';
 
   test('fixed length list', () => {
     let list = new core.List(10);
     list[0] = 42;
     assert.throws(() => list.add(42));
   });
 });