Load on demand

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, dartx;
+var dart, dartx;
 (function (dart) {
   'use strict';
 
-  // TODO(vsm): This is referenced (as init.globalState) from
-  // isolate_helper.dart.  Where should it go?
-  // See: https://github.com/dart-lang/dev_compiler/issues/164
-  dart.globalState = null;
-
   const defineProperty = Object.defineProperty;
   const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
   const getOwnPropertyNames = Object.getOwnPropertyNames;
   const getOwnPropertySymbols = Object.getOwnPropertySymbols;
   const hasOwnProperty = Object.prototype.hasOwnProperty;
   const slice = [].slice;
 
   let _constructorSig = Symbol('sigCtor');
   let _methodSig = Symbol("sig");
   let _staticSig = Symbol("sigStatic");
 
   function getOwnNamesAndSymbols(obj) {
     return getOwnPropertyNames(obj).concat(getOwnPropertySymbols(obj));
   }
 
   function dload(obj, field) {
     field = _canonicalFieldName(obj, field, [], field);
     if (_getMethodType(obj, field) !== void 0) {
       return dart.bind(obj, field);
     }
     // TODO(vsm): Implement NSM robustly.  An 'in' check breaks on certain
     // types.  hasOwnProperty doesn't chase the proto chain.
     // Also, do we want an NSM on regular JS objects?
     // See: https://github.com/dart-lang/dev_compiler/issues/169
-    var result = obj[field];
+    let result = obj[field];
 
     // TODO(vsm): Check this more robustly.
     if (typeof result == "function" && !hasOwnProperty.call(obj, field)) {
       // This appears to be a method tearoff.  Bind this.
       return result.bind(obj);
     }
     return result;
   }
   dart.dload = dload;
 
@@ skipping 52 matching lines @@
   function dcall(f/*, ...args*/) {
     let args = slice.call(arguments, 1);
     let ftype = _getFunctionType(f);
     return checkAndCall(f, ftype, void 0, args, 'call');
   }
   dart.dcall = dcall;
 
   let _extensionType = Symbol('extensionType');
   function _canonicalFieldName(obj, name, args, displayName) {
     if (obj[_extensionType]) {
-      var extension = dartx[name];
+      let extension = dartx[name];
       if (extension) return extension;
       // TODO(jmesserly): in the future we might have types that "overlay" Dart
       // methods while also exposing the full native API, e.g. dart:html vs
       // dart:dom. To support that we'd need to fall back to the normal name
       // if an extension method wasn't found.
       throwNoSuchMethod(obj, displayName, args);
     }
     return name;
   }
 
@@ skipping 15 matching lines @@
   }
   dart.dindex = dindex;
 
   function dsetindex(obj, index, value) {
     return callMethod(obj, 'set', [index, value], '[]=');
   }
   dart.dsetindex = dsetindex;
 
   function typeToString(type) {
     if (typeof(type) == "function") {
-      var name = type.name;
-      var args = type[dart.typeArguments];
+      let name = type.name;
+      let args = type[dart.typeArguments];
       if (args) {
         name += '<';
-        for (var i = 0; i < args.length; ++i) {
+        for (let i = 0; i < args.length; ++i) {
           if (i > 0) name += ', ';
           name += typeToString(args[i]);
         }
         name += '>';
       }
       return name;
     } else {
       return type.toString();
     }
   }
@@ skipping 40 matching lines @@
     return null;
   }
 
   /**
    * Returns the runtime type of obj. This is the same as `obj.realRuntimeType`
    * but will not call an overridden getter.
    *
    * Currently this will return null for non-Dart objects.
    */
   function realRuntimeType(obj) {
-    var result = checkPrimitiveType(obj);
+    let result = checkPrimitiveType(obj);
     if (result !== null) return result;
     // TODO(vsm): Should we treat Dart and JS objects differently here?
     // E.g., we can check if obj instanceof core.Object to differentiate.
     result = obj[_runtimeType];
     if (result) return result;
     result = obj.constructor;
     if (result == Function) {
       return getFunctionType(obj);
     }
     return result;
@@ skipping 91 matching lines @@
     // TODO(vsm): Handle Objects with call methods.  Those are functions
     // even if they do not *nominally* subtype core.Function.
     if (isFunctionType(t1) &&
         isFunctionType(t2)) {
       return isFunctionSubType(t1, t2);
     }
     return false;
   }
 
   function safeGetOwnProperty(obj, name) {
-    var desc = getOwnPropertyDescriptor(obj, name);
+    let desc = getOwnPropertyDescriptor(obj, name);
     if (desc) return desc.value;
   }
 
   function isClassSubType(t1, t2) {
     // We support Dart's covariant generics with the caveat that we do not
     // substitute bottom for dynamic in subtyping rules.
     // I.e., given T1, ..., Tn where at least one Ti != dynamic we disallow:
     // - S !<: S<T1, ..., Tn>
     // - S<dynamic, ..., dynamic> !<: S<T1, ..., Tn>
     t1 = canonicalType(t1);
@@ skipping 60 matching lines @@
     // TODO(vsm): Cache this if we start using it at runtime.
 
     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);
+      let names = getOwnPropertyNames(type.named);
       for (let i = 0; i < names.length; ++i) {
         if (!_isBottom(type.named[names[i]], true)) return false;
       }
       return true;
     }
 
     let typeArgs = safeGetOwnProperty(type, dart.typeArguments);
     if (!typeArgs) return true;
     for (let t of typeArgs) {
       if (t != core.Object && t != dart.dynamic) return false;
@@ skipping 18 matching lines @@
 
   /** Checks that `x` is not null or undefined. */
   function notNull(x) {
     if (x == null) throwRuntimeError('expected not-null value');
     return x;
   }
   dart.notNull = notNull;
 
   function _typeName(type) {
     if (type === void 0) throwRuntimeError('Undefined type');
-    var name = type.name;
+    let name = type.name;
     if (!name) throwRuntimeError('Unexpected type: ' + type);
     return name;
   }
 
   class AbstractFunctionType {
     constructor() {
       this._stringValue = null;
     }
 
     /// Check that a function of this type can be applied to 
     /// actuals.
     checkApply(actuals) {
       if (actuals.length < this.args.length) return false;
-      var index = 0;
+      let index = 0;
       for(let i = 0; i < this.args.length; ++i) {
         if (!instanceOfOrNull(actuals[i], this.args[i])) return false;
         ++index;
       }
       if (actuals.length == this.args.length) return true;
       let extras = actuals.length - this.args.length;
       if (this.optionals.length > 0) {
         if (extras > this.optionals.length) return false;
         for(let i = 0, j=index; i < extras; ++i, ++j) {
           if (!instanceOfOrNull(actuals[j], this.optionals[i])) return false;
@@ skipping 15 matching lines @@
           return false;
         }
         if (!instanceOfOrNull(opts[name], this.named[name])) return false;
       }
       return true;
     }
 
     get name() {
       if (this._stringValue) return this._stringValue;
 
-      var buffer = '(';
+      let buffer = '(';
       for (let i = 0; i < this.args.length; ++i) {
         if (i > 0) {
           buffer += ', ';
         }
         buffer += _typeName(this.args[i]);
       }
       if (this.optionals.length > 0) {
         if (this.args.length > 0) buffer += ', ';
         buffer += '[';
         for (let i = 0; i < this.optionals.length; ++i) {
@@ skipping 38 matching lines @@
   /// dart.fn(cls, func) marks cls with the lazily computed
   ///  runtime type as computed by func()
   /// dart.fn(cls, rType, argsT, extras) marks cls as having the
   ///  runtime type dart.functionType(rType, argsT, extras)
   function fn(closure/* ...args*/) {
     // Closure and a lazy type constructor
     if (arguments.length == 2) {
       defineLazyProperty(closure, _runtimeType, {get : arguments[1]});
       return closure;
     }
-    var t;
+    let t;
     if (arguments.length == 1) {
       // No type arguments, it's all dynamic
       let len = closure.length;
       let 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();
     } else {
       // We're passed the piecewise components of the function type,
       // construct it.
       let args = slice.call(arguments, 1);
       t = functionType.apply(null, args);
     }
     setRuntimeType(closure, t);
     return closure;
   }
   dart.fn = fn;
 
   function functionType(returnType, args, extra) {
     // TODO(vsm): Cache / memomize?
-    var optionals;
-    var named;
+    let optionals;
+    let named;
     if (extra === void 0) {
       optionals = [];
       named = {};
     } else if (extra instanceof Array) {
       optionals = extra;
       named = {};
     } else {
       optionals = [];
       named = extra;
     }
@@ skipping 42 matching lines @@
   }
   dart.typedef = typedef;
 
   function isFunctionType(type) {
     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(() => core.Object);
+    let 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 23 matching lines @@
       }
     }
 
     let optionals1 = ft1.optionals;
     let optionals2 = ft2.optionals;
 
     if (args1.length + optionals1.length < args2.length + optionals2.length) {
       return false;
     }
 
-    var j = 0;
+    let j = 0;
     for (let i = args1.length; i < args2.length; ++i, ++j) {
       if (!isSubtype_(args2[i], optionals1[j], true)) {
         return false;
       }
     }
 
     for (let i = 0; i < optionals2.length; ++i, ++j) {
       if (!isSubtype_(optionals2[i], optionals1[j], true)) {
         return false;
       }
@@ skipping 136 matching lines @@
     for (let name of methodNames) {
       let method = getOwnPropertyDescriptor(proto, name);
       defineProperty(proto, getExtensionSymbol(name), method);
     }
     // Ensure the signature is available too.
     // TODO(jmesserly): not sure if we can do this in a cleaner way. Essentially
     // we need to copy the signature (and in the future, other data like
     // annotations) any time we copy a method as part of our metaprogramming.
     // It might be more friendly to JS metaprogramming if we include this info
     // on the function.
-    var originalSigFn = getOwnPropertyDescriptor(type, _methodSig).get;
+    let originalSigFn = getOwnPropertyDescriptor(type, _methodSig).get;
     defineMemoizedGetter(type, _methodSig, function() {
-      var sig = originalSigFn();
+      let sig = originalSigFn();
       for (let name of methodNames) {
         sig[getExtensionSymbol(name)] = sig[name];
       }
       return sig;
     });
   }
   dart.defineExtensionMembers = defineExtensionMembers;
 
   function setBaseClass(derived, base) {
     // Link the extension to the type it's extending as a base class.
@@ skipping 286 matching lines @@
     _setStaticTypes(f, names);
   }
   dart.setSignature = setSignature;
 
   let _value = Symbol('_value');
   /**
    * Looks up a sequence of [keys] in [map], recursively, and
    * returns the result. If the value is not found, [valueFn] will be called to
    * add it. For example:
    *
-   *     var map = new Map();
+   *     let map = new Map();
    *     putIfAbsent(map, [1, 2, 'hi ', 'there '], () => 'world');
    *
    * ... will create a Map with a structure like:
    *
    *     { 1: { 2: { 'hi ': { 'there ': 'world' } } } }
    */
   function multiKeyPutIfAbsent(map, keys, valueFn) {
     for (let k of keys) {
       let value = map.get(k);
       if (!value) {
@@ skipping 78 matching lines @@
         return obj & 0x1FFFFFFF;
       case "string":
         // TODO(vsm): Call the JSString hashCode?
         return obj.length;
     }
     return obj.hashCode;
   }
   dart.hashCode = hashCode;
 
   function runtimeType(obj) {
-    var result = checkPrimitiveType(obj);
+    let result = checkPrimitiveType(obj);
     if (result !== null) return result;
     return obj.runtimeType;
   }
   dart.runtimeType = runtimeType;
 
   function toString(obj) {
     if (obj == null) {
       return "null";
     }
     return obj.toString();
@@ skipping 15 matching lines @@
     return obj.noSuchMethod(invocation);
   }
   dart.noSuchMethod = noSuchMethod;
 
   class JsIterator {
     constructor(dartIterator) {
       this.dartIterator = dartIterator;
     }
     next() {
       let i = this.dartIterator;
-      var done = !i.moveNext();
+      let done = !i.moveNext();
       return { done: done, value: done ? void 0 : i.current };
     }
   }
   dart.JsIterator = JsIterator;
 
   // TODO(jmesserly): right now this is a sentinel. It should be a type object
   // of some sort, assuming we keep around `dynamic` at runtime.
   dart.dynamic = { toString() { return 'dynamic'; }, get name() {return toString();}};
   dart.void = { toString() { return 'void'; }, get name() {return toString();}};
   dart.bottom = { toString() { return 'bottom'; }, get name() {return toString();}};
 
   dart.global = window || global;
   dart.JsSymbol = Symbol;
 
-  // All libraries, including those that have referenced (lazyImport),
-  // but not yet loaded.
-  var libraries = new Map();
+  // Module support.  This is a simplified module system for Dart.
+  // Longer term, we can easily migrate to an existing JS module system:
+  // ES6, AMD, RequireJS, ....
 
-  // Completed libraries.
-  var loadedLibraries = new Set();
+  class LibraryLoader {
+    constructor(name, defaultValue, imports, lazyImports, loader) {
+      this._name = name;
+      this._library = defaultValue ? defaultValue : {};
+      this._imports = imports;
+      this._lazyImports = lazyImports;
+      this._loader = loader;
 
-  // Import a library by name.
-  // This is exported for REPL / JS interop convenience.
-  function import_(name) {
-    let loaded = loadedLibraries.has(name);
-    let value = libraries[name];
-    // TODO(vsm): Change this to a hard throw.
-    // For now, we're missing some libraries.  E.g., dart:js:
-    // https://github.com/dart-lang/dev_compiler/issues/168
-    if (!loaded) {
-      console.warn('Missing required module: ' + name);
-    } else if (!value) {
-      throwRuntimeError('Library import error: ' + name)
+      // Cyclic import detection
+      this._state = LibraryLoader.NOT_LOADED;
     }
-    return value;
+
+    loadImports(pendingSet) {
+      return this.handleImports(this._imports, (lib) => lib.load(pendingSet));
+    }
+
+    deferLazyImports(pendingSet) {
+      return this.handleImports(this._lazyImports,
+        (lib) => {
+          pendingSet.add(lib._name);
+          return lib.stub();
+      });
+    }
+
+    loadLazyImports(pendingSet) {
+      return this.handleImports(pendingSet, (lib) => lib.load());
+    }
+
+    handleImports(list, handler) {
+      let results = [];
+      for (let name of list) {
+        let lib = libraries[name];
+        if (!lib) {
+          throwRuntimeError('Library not available: ' + name);
+        }
+        results.push(handler(lib));
+      }
+      return results;
+    }
+
+    load(inheritedPendingSet) {
+      // Check for cycles
+      if (this._state == LibraryLoader.LOADING) {
+        throwRuntimeError('Circular dependence on library: ' + this._name);
+      } else if (this._state >= LibraryLoader.LOADED) {
+        return this._library;
+      }
+      this._state = LibraryLoader.LOADING;
+
+      // Handle imports and record lazy imports
+      let pendingSet = inheritedPendingSet ? inheritedPendingSet : new Set();
+      let args = this.loadImports(pendingSet);
+      args = args.concat(this.deferLazyImports(pendingSet));
+
+      // Load the library
+      args.unshift(this._library);
+      this._loader.apply(null, args);
+      this._state = LibraryLoader.LOADED;
+
+      // Handle lazy imports
+      if (inheritedPendingSet === void 0) {
+        // Drain the queue
+        this.loadLazyImports(pendingSet);
+      }
+      this._state = LibraryLoader.READY;
+      return this._library;
+    }
+
+    stub() {
+      return this._library;
+    }
+  }
+  LibraryLoader.NOT_LOADED = 0;
+  LibraryLoader.LOADING = 1;
+  LibraryLoader.LOADED = 2;
+  LibraryLoader.READY = 3;
+
+  // Map from name to LibraryLoader
+  let libraries = new Map();
+
+  function library(name, defaultValue, imports, lazyImports, loader) {
+    libraries[name] =
+      new LibraryLoader(name, defaultValue, imports, lazyImports, loader);
+  }
+  dart.library = library;
+
+  function import_(libraryName) {
+    bootstrap();
+    let loader = libraries[libraryName];
+    return loader.load();
   }
   dart.import = import_;
 
-  function initializeLibraryStub(name) {
-    // Create the library object if necessary.
-    if (!libraries[name]) {
-      libraries[name] = {};
-    }
-    return libraries[name];
-  }
-  const lazyImport = initializeLibraryStub;
-
-  function defineLibrary(name, defaultValue) {
-    if (loadedLibraries.has(name)) {
-      throwRuntimeError('Library is already defined: ' + name);
-    }
-    var value;
-    if (defaultValue) {
-      var oldValue = libraries[name];
-      if (oldValue && oldValue != defaultValue) {
-        throwRuntimeError(
-          `Library ${name} cannot be redefined to ${defaultValue}`);
-      }
-      libraries[name] = value = defaultValue;
-    } else {
-      value = initializeLibraryStub(name);
-    }
-    loadedLibraries.add(name);
-    return value;
-  }
-
-  function library(name, defaultValue, imports, lazyImports, module) {
-    var args = [];
-    var lib = defineLibrary(name, defaultValue);
-    args.push(lib);
-    for (var i = 0; i < imports.length; ++i) {
-      lib = import_(imports[i]);
-      args.push(lib);
-    }
-    for (var i = 0; i < lazyImports.length; ++i) {
-      lib = lazyImport(lazyImports[i]);
-      args.push(lib);
-    }
-    module.apply(null, args);
-  }
-  dart.library = library;
-
   function start(libraryName) {
-    let lib = import_(libraryName);
-    _isolate_helper.startRootIsolate(lib.main, []);
+    let library = import_(libraryName);
+    _isolate_helper.startRootIsolate(library.main, []);
   }
   dart.start = start;
 
-  let core = lazyImport('dart/core');
-  let collection = lazyImport('dart/collection');
-  let async = lazyImport('dart/async');
-  let _interceptors = lazyImport('dart/_interceptors');
-  let _isolate_helper = lazyImport('dart/_isolate_helper');
-  let _js_helper = lazyImport('dart/_js_helper');
-  _js_helper.checkNum = notNull;
-  let _js_primitives = lazyImport('dart/_js_primitives');
-  _js_primitives.printString = (s) => console.log(s);
+  // Libraries used in this file.
+  let core;
+  let collection;
+  let async;
+  let _interceptors;
+  let _isolate_helper;
+  let _js_helper;
+  let _js_primitives;
 
-  // 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]; };
+  function bootstrap() {
+    if (core) return;
 
-  /** Dart extension members. */
-  dartx = dartx || {};
+    let lazyImport = (name) => libraries[name].stub();
 
+    core = lazyImport('dart/core');
+    collection = lazyImport('dart/collection');
+    async = lazyImport('dart/async');
+    _interceptors = lazyImport('dart/_interceptors');
+    _isolate_helper = lazyImport('dart/_isolate_helper');
+    _js_helper = lazyImport('dart/_js_helper');
+    _js_helper.checkNum = notNull;
+    _js_primitives = lazyImport('dart/_js_primitives');
+    _js_primitives.printString = (s) => console.log(s);
+
+    // 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]; };
+
+    // TODO(vsm): This is referenced (as init.globalState) from
+    // isolate_helper.dart.  Where should it go?
+    // See: https://github.com/dart-lang/dev_compiler/issues/164
+    dart.globalState = null;
+
+    /** Dart extension members. */
+    dartx = dartx || {};
+  }
 })(dart || (dart = {}));