No dynamic at runtime

lib/runtime/dart_runtime.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 dart, _js_helper, _js_primitives;
 (function (dart) {
   'use strict';
 
   // TODO(vsm): This is referenced (as init.globalState) from
   // isolate_helper.dart.  Where should it go?
@@ skipping 547 matching lines @@
   function fn(closure/* ...args*/) {
     // Closure and a lazy type constructor
     if (arguments.length == 2) {
       defineLazyProperty(closure, _runtimeType, {get : arguments[1]});
       return closure;
     }
     var t;
     if (arguments.length == 1) {
       // No type arguments, it's all dynamic
       let len = closure.length;
-      let args = Array.apply(null, new Array(len)).map(() => dart.dynamic);
-      t = functionType(dart.dynamic, args);
+      function build() {
+        let args = Array.apply(null, new Array(len)).map(() => core.Object);
+        return functionType(core.Object, args);
+      }
+      // We could be called before Object is defined.
+      if (core.Object === void 0) return fn(closure, build);
+      t = build();

[vsm, 2015/05/20 23:03:10]

yikes ... perhaps we should move Object to this file?

[Leaf, 2015/05/20 23:35:28]

Yes, figuring out some way to architect things so that the dependencies between
the dart.XXX and the essential few core.YYY types that they refer to become more
manageable would be good.

     } else {
       // We're passed the piecewise components of the function type,
       // construct it.
       let args = Array.prototype.slice.call(arguments, 1);
       t = functionType.apply(functionType, args);
     }
     setRuntimeType(closure, t);
     return closure;
   }
   dart.fn = fn;
@@ skipping 371 matching lines @@
   function generic(typeConstructor) {
     let length = typeConstructor.length;
     if (length < 1) throw Error('must have at least one generic type argument');
 
     let resultMap = new Map();
     function makeGenericType(/*...arguments*/) {
       if (arguments.length != length && arguments.length != 0) {
         throw Error('requires ' + length + ' or 0 type arguments');
       }
       let args = Array.prototype.slice.call(arguments);
+      // TODO(leafp): This should really be core.Object for
+      // consistency, but Object is not attached to core
+      // until the entire core library has been processed,
+      // which is too late.
       while (args.length < length) args.push(dart.dynamic);
 
       let value = resultMap;
       for (let i = 0; i < length; i++) {
         let arg = args[i];
         if (arg == null) {
           throw Error('type arguments should not be null: ' + typeConstructor);
         }
         let map = value;
         value = map.get(arg);
@@ skipping 299 matching lines @@
   Number.prototype['>'] = function(arg) { return this.valueOf() > arg; };
   Number.prototype['+'] = function(arg) { return this.valueOf() + arg; };
 
   // TODO(vsm): DOM facades?
   // See: https://github.com/dart-lang/dev_compiler/issues/173
   NodeList.prototype.get = function(i) { return this[i]; };
   NamedNodeMap.prototype.get = function(i) { return this[i]; };
   DOMTokenList.prototype.get = function(i) { return this[i]; };
 
 })(dart || (dart = {}));