Deferred parsing for legacy modules

pkg/dev_compiler/lib/js/legacy/dart_library.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.
 
 /* This file defines the module loader for the dart runtime.
 */
 var dart_library;
 if (!dart_library) {
 dart_library =
   typeof module != "undefined" && module.exports || {};
 
 (function (dart_library) {
   'use strict';
 
   /** Note that we cannot use dart_utils.throwInternalError from here. */
   function throwLibraryError(message) {
     throw Error(message);
   }
 
   const dartLibraryName = Symbol('dartLibraryName');
   dart_library.dartLibraryName = dartLibraryName;
 
   const libraryImports = Symbol('libraryImports');
   dart_library.libraryImports = libraryImports;
 
   // 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, ....
 
+  // Returns a proxy that delegates to the underlying loader.
+  // This defers loading of a module until a library is actually used.
+  const loadedModule = Symbol('loadedModule');
+  dart_library.defer = function(module, name, patch) {
+    var revocable = Proxy.revocable(module, {
+      get: function(o, p) {
+        var mod = o[loadedModule];
+        var lib = mod[name];
+        // Install unproxied module and library in caller's context.
+        patch(mod, lib);
+        // Ensure proxy is only used on first access.
+        revocable.revoke();
+        return lib[p];
+      }
+    });
+    return revocable.proxy;
+  };
+
   class LibraryLoader {
 
     constructor(name, defaultValue, imports, loader) {
       this._name = name;
       this._library = defaultValue ? defaultValue : {};
       this._imports = imports;
       this._loader = loader;
 
       // Cyclic import detection
       this._state = LibraryLoader.NOT_LOADED;
@@ skipping 18 matching lines @@
                               + this._name);
       } else if (this._state >= LibraryLoader.READY) {
         return this._library;
       }
       this._state = LibraryLoader.LOADING;
 
       // Handle imports
       let args = this.loadImports();
 
       // Load the library
-      args.unshift(this._library);
-      this._loader.apply(null, args);
+      let loader = this;
+      let library = this._library;
+      library[loadedModule] = library;
+      args.unshift(library);
+
+      if (this._name == 'dart_sdk') {
+        // Eagerly load the SDK.
+        this._loader.apply(null, args);
+        loader._loader = null;
+      } else {
+        // Load / parse other modules on demand.
+        let done = false;
+        this._library = new Proxy(args, {
+          get: function(o, name) {
+            if (done) {
+              return library[name];
+            }
+            done = true;
+            loader._loader.apply(null, o);
+            loader._loader = null;
+            return library[name];
+          }
+        });
+      }
+
       this._state = LibraryLoader.READY;
       this._library[dartLibraryName] = this._name;
       this._library[libraryImports] = this._imports;
       return this._library;
     }
 
     stub() {
       return this._library;
     }
   }
@@ skipping 34 matching lines @@
     return loader.load();
   }
   dart_library.import = import_;
 
   var _currentIsolate = false;
 
   function start(moduleName, libraryName) {
     if (libraryName == null) libraryName = moduleName;
     let library = import_(moduleName)[libraryName];
     let dart_sdk = import_('dart_sdk');
+
     if (!_currentIsolate) {
-      // Create isolate and run main.
+      // Create isolate.
       _currentIsolate = true;
-      dart_sdk._isolate_helper.startRootIsolate(library.main, []);
-    } else {
-      // Main isolate is already initialized - just run main.
-      library.main();
+      dart_sdk._isolate_helper.startRootIsolate(() => {}, []);
     }
+
+    library.main();
   }
   dart_library.start = start;
 
   let _bootstrapped = false;
   function bootstrap() {
     if (_bootstrapped) return;
     _bootstrapped = true;
 
     // Force import of core.
     var dart_sdk = import_('dart_sdk');
 
     // This import is only needed for chrome debugging. We should provide an
     // option to compile without it.
     dart_sdk._debugger.registerDevtoolsFormatter();
   }
 
 })(dart_library);
 }