Generate all runtime files from dart.

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_library.import('dart/core');
 var collection = dart_library.import('dart/collection');
 var dart = dart_library.import('dart/_runtime');
 var dartx = 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 = dart_library.import('dart/_classes');
-var types = dart_library.import('dart/_types');
-var dart_utils = dart_library.import('dart/_utils');
-
 suite('generic', () => {
   "use strict";
 
   let generic = dart.generic;
 
   test('zero arguments is not allowed', () => {
     assert.throws(() => { generic(function(){}); });
   });
 
+  test('dcall noSuchMethod has correct error target', () => {
+    assert.throws(() => dart.dcall(42),
+        new RegExp('NoSuchMethodError.*\nReceiver: 42', 'm'),
+        'Calls with non-function receiver should throw a NoSuchMethodError' +
+        ' with correct target');
+    
+    // TODO(jmesserly): we should show the name "print" in there somewhere.
+    assert.throws(() => dart.dcall(core.print, 1, 2, 3),
+        new RegExp('NoSuchMethodError.*\n' +
+        "Receiver: Instance of '\\(Object\\) -> void'", 'm'),
+        'Calls with incorrect argument types should throw a NoSuchMethodError' +
+        ' with correct target');
+  });
+
   test('can throw number', () => {
     try {
       dart.throw(42);
     } catch (e) {
       assert.equal(e, 42);
     }
   });
 
   test('argument count cannot change', () => {
     let SomeType = generic(function(x) { return {x: x}; });
@@ skipping 44 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(classes.getGenericClass(someValue), SomeType);
-    assert.deepEqual(classes.getGenericArgs(someValue), ['hi', 123]);
+    assert.equal(dart.getGenericClass(someValue), SomeType);
+    assert.deepEqual(dart.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 = types.isGroundType;
+  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 functionType = dart.functionType;
   let typedef = dart.typedef;
-  let isSubtype = types.isSubtype;
+  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$;
   let int = core.int;
   let num = core.num;
   let bool = core.bool;
@@ skipping 63 matching lines @@
 
   let cls8 =
     dart.fn((b, s, o) => { return null; }, B, [B, String], {p: Object});
 
   function checkType(x, type, expectedTrue, strongOnly) {
     if (expectedTrue === undefined) expectedTrue = true;
     if (strongOnly == undefined) strongOnly = false;
     if (!strongOnly) {
       expect(instanceOf(x, type), expectedTrue);
     } else {
-      assert.throws(() => instanceOf(x, type), dart_utils.StrongModeError);
+      assert.throws(() => instanceOf(x, type), dart.StrongModeError);
       expect(strongInstanceOf(x, type), expectedTrue);
     }
   }
 
   test('int', () => {
     expect(isGroundType(int), true);
     expect(isGroundType(runtimeType(5)), true);
 
     checkType(5, int);
     checkType(5, dynamic);
@@ skipping 88 matching lines @@
 
     // null is! Map
     checkType(null, Map, false);
 
     // Raw generic types
     checkType(m5, Map);
     checkType(m4, Map);
 
     // Is checks
     assert.throws(() => dart.is(m3, Map$(String, String)),
-      dart_utils.StrongModeError);
+      dart.StrongModeError);
     assert.throws(() => dart.is(m6, Map$(String, String)),
-      dart_utils.StrongModeError);
+      dart.StrongModeError);
     assert.isTrue(dart.is(m1, Map$(String, String)));
     assert.throws(() => dart.is(m2, Map$(String, String)),
-      dart_utils.StrongModeError);
+      dart.StrongModeError);
 
     // As checks
     // TODO(vsm): Enable these.  We're currently only logging warnings on
     // StrongModeErrors.
     // assert.throws(() => dart.as(m3, Map$(String, String)),
-    //   dart_utils.StrongModeError);
+    //   dart.StrongModeError);
     // assert.throws(() => dart.as(m6, Map$(String, String)),
-    //   dart_utils.StrongModeError);
+    //   dart.StrongModeError);
     assert.equal(dart.as(m1, Map$(String, String)), m1);
     // assert.throws(() => dart.as(m2, Map$(String, String)),
-    //   dart_utils.StrongModeError);
+    //   dart.StrongModeError);
   });
 
   test('constructors', () => {
     class C extends core.Object {
       C(x) {};
       named(x, y) {};
     }
     dart.defineNamedConstructor(C, 'named');
     dart.setSignature(C, {
       constructors: () => ({
@@ skipping 440 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));
   });
 });