Make typedefs lazy again

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';
 
   let defineProperty = Object.defineProperty;
   let getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
@@ skipping 192 matching lines @@
     let result;
     if (map) {
       result = map.get(t2);
       if (result !== void 0) return result;
     } else {
       subtypeMap.set(t1, map = new Map());
     }
     if (t2 == core.Type) {
       // Special case Types.
       result = t1.prototype instanceof core.Type ||
-        t1 instanceof FunctionType ||
+        t1 instanceof AbstractFunctionType ||
         isSubtype_(t1, t2);
     } else {
       result = isSubtype_(t1, t2)
     }
     map.set(t2, result);
     return result;
   }
   dart.isSubtype = isSubtype;
 
   function _isBottom(type, dynamicIsBottom) {
@@ skipping 108 matching lines @@
 
     return false;
   }
 
   // TODO(jmesserly): this isn't currently used, but it could be if we want
   // `obj is NonGroundType<T,S>` to be rejected at runtime instead of compile
   // time.
   function isGroundType(type) {
     // TODO(vsm): Cache this if we start using it at runtime.
 
-    if (type instanceof FunctionType) {
+    if (type instanceof AbstractFunctionType) {
       if (!_isTop(type.returnType, false)) return false;
       for (let i = 0; i < type.args.length; ++i) {
         if (!_isBottom(type.args[i], true)) return false;
       }
       for (let i = 0; i < type.optionals.length; ++i) {
         if (!_isBottom(type.optionals[i], true)) return false;
       }
       var names = getOwnPropertyNames(type.named);
       for (let i = 0; i < names.length; ++i) {
         if (!_isBottom(type.named[names[i]], true)) return false;
@@ skipping 30 matching lines @@
     return x;
   }
   dart.notNull = notNull;
 
   function _typeName(type) {
     var name = type.name;
     if (!name) throw 'Unexpected type: ' + type;
     return name;
   }
 
-  // TODO(jmesserly): extends Type?
-  class FunctionType {
-    constructor(returnType, args, optionals, named, opt_typedefName) {
-      this.returnType = returnType;
-      this.args = args;
-      this.optionals = optionals;
-      this.named = named;
-      this._stringValue = opt_typedefName;
+  class AbstractFunctionType {
+    constructor() {
+      this._stringValue = null;
     }
 
     get name() {
       if (this._stringValue) return this._stringValue;
 
       var buffer = '(';
       for (let i = 0; i < this.args.length; ++i) {
         if (i > 0) {
           buffer += ', ';
         }
@@ skipping 21 matching lines @@
         }
         buffer += '}';
       }
 
       buffer += ') -> ' + _typeName(this.returnType);
       this._stringValue = buffer;
       return buffer;
     }
   }
 
+  class FunctionType extends AbstractFunctionType {
+    constructor(returnType, args, optionals, named) {
+      super();
+      this.returnType = returnType;
+      this.args = args;
+      this.optionals = optionals;
+      this.named = named;
+    }
+  }
+
   function functionType(returnType, args, extra) {
     // TODO(vsm): Cache / memomize?
     var optionals;
     var named;
     if (extra === void 0) {
       optionals = [];
       named = {};
     } else if (extra instanceof Array) {
       optionals = extra;
       named = {};
     } else {
       optionals = [];
       named = extra;
     }
     return new FunctionType(returnType, args, optionals, named);
   }
   dart.functionType = functionType;
 
-  function typedef(name, functionType) {
-    let f = functionType;
-    return new FunctionType(f.returnType, f.args, f.optionals, f.named, name);
+  class Typedef extends AbstractFunctionType {
+    constructor(name, closure) {
+      super();
+      this._name = name;
+      this._closure = closure;
+      this._functionType = null;
+    }
+
+    get name() {
+      return this._name;
+    }
+
+    get functionType() {
+      if (!this._functionType) {
+        this._functionType = this._closure();
+      }
+      return this._functionType;
+    }
+
+    get returnType() {
+      return this.functionType.returnType;
+    }
+
+    get args() {
+      return this.functionType.args;
+    }
+
+    get optionals() {
+      return this.functionType.optionals;
+    }
+
+    get named() {
+      return this.functionType.named;
+    }
+  }
+
+  function typedef(name, closure) {
+    return new Typedef(name, closure);
   }
   dart.typedef = typedef;
 
   function isFunctionType(type) {
-    return isClassSubType(type, core.Function) || type instanceof FunctionType;
+    return isClassSubType(type, core.Function) ||
+        type instanceof AbstractFunctionType;
   }
 
   function getFunctionType(obj) {
     // TODO(vsm): Encode this properly on the function for Dart-generated code.
-    var args = Array.apply(null, new Array(obj.length)).map(function(){return core.Object});
+    var args = Array.apply(null, new Array(obj.length)).map(() => core.Object);
     return functionType(dart.bottom, args);
   }
 
   function isFunctionSubType(ft1, ft2) {
     if (ft2 == core.Function) {
       return true;
     }
 
     let ret1 = ft1.returnType;
     let ret2 = ft2.returnType;
@@ skipping 462 matching lines @@
   dart.defineLibrary = defineLibrary;
 
   // TODO(jmesserly): hack to bootstrap the SDK
   _js_helper = _js_helper || {};
   _js_helper.checkNum = notNull;
 
   _js_primitives = _js_primitives || {};
   _js_primitives.printString = (s) => console.log(s);
 
 })(dart || (dart = {}));