Add deferred loading to Kernel.

pkg/compiler/lib/src/kernel/kernel_visitor.dart

 // Copyright (c) 2016, 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.md file.
 
 import 'package:kernel/ast.dart' as ir;
 import 'package:kernel/frontend/accessors.dart'
     show
         Accessor,
         IndexAccessor,
         NullAwarePropertyAccessor,
@@ skipping 196 matching lines @@
     return node;
   }
 
   ir.Node associateNode(ir.Node node, Node ast) {
     kernel.nodeToAst[node] = ast;
     return node;
   }
 
   bool isVoidContext = false;
 
+  /// If non-null, reference to a deferred library that a subsequent getter is
+  /// using.
+  ir.DeferredImport _deferredLibrary;
+
   KernelVisitor(this.currentElement, this.elements, this.kernel);
 
   KernelVisitor get sendVisitor => this;
 
   KernelVisitor get declVisitor => this;
 
   ir.TreeNode visitForValue(Expression node) {
     bool wasVoidContext = isVoidContext;
     isVoidContext = false;
     try {
@@ skipping 129 matching lines @@
 
   @override
   ir.Expression handleError(Node node) => new ir.InvalidExpression();
 
   @override
   void apply(Node node, _) {
     throw new UnsupportedError("apply");
   }
 
   @override
-  void previsitDeferredAccess(Send node, PrefixElement prefix, _) {}
+  void previsitDeferredAccess(Send node, PrefixElement prefix, _) {
+    // This is visited before any element access, and if it is deferred,
+    // prefix.isDeferred = true.
+    if (prefix != null && prefix.isDeferred) {
+      _deferredLibrary = new ir.DeferredImport(
+          kernel.libraries[prefix.deferredImport.importedLibrary], prefix.name);
+    } else {
+      _deferredLibrary = null;
+    }
+  }
 
   @override
   internalError(Spannable spannable, String message) {
     kernel.internalError(spannable, message);
   }
 
   @override
   applyParameters(NodeList parameters, _) {
     throw new UnsupportedError("applyParameters");
   }
@@ skipping 1610 matching lines @@
   }
 
   @override
   visitStaticFieldDeclaration(VariableDefinitions node, Node definition,
       FieldElement field, Node initializer, _) {
     // Shouldn't be called, handled by fieldToIr.
     return internalError(node, "StaticFieldDeclaration");
   }
 
   ir.Expression buildStaticGet(Element element) {
-    return buildStaticAccessor(element).buildSimpleRead();
+    var expression = buildStaticAccessor(element).buildSimpleRead();
+    if (_deferredLibrary != null) {
+      ir.Let let = new ir.Let(
+          makeOrReuseVariable(new ir.CheckLibraryIsLoaded(_deferredLibrary)),
+          expression);
+      return let;
+    }
+    return expression;
   }
 
   @override
   ir.Expression handleStaticFieldGet(Send node, FieldElement field, _) {
     return associateNode(buildStaticGet(field), node);
   }
 
   @override
   ir.MethodInvocation handleStaticFieldInvoke(Send node, FieldElement field,
       NodeList arguments, CallStructure callStructure, _) {
@@ skipping 217 matching lines @@
 
   @override
   IrFunction visitStaticGetterDeclaration(
       FunctionExpression node, MethodElement getter, Node body, _) {
     return buildIrFunction(ir.ProcedureKind.Getter, getter, body);
   }
 
   @override
   ir.Expression handleStaticGetterGet(Send node, FunctionElement getter, _) {
     if (getter.isDeferredLoaderGetter) {
-      // TODO(ahe): Support deferred load.
-      return new ir.InvalidExpression();
+      // This is the LoadLibrary call.
+      var deferredLibrary = new ir.DeferredImport(

[sra1, 2017/02/14 03:14:06]

I would expect there to be a single shared DeferredImport.
There is a list of them in the Library.
How to they get added there?

[Emily Fortuna, 2017/02/14 20:56:28]

Changed to PutIfAbsent. I'm not convinced this is an improvement though. It adds
a whole bunch of checks.

+          kernel.libraries[getter.prefix.deferredImport.importedLibrary],
+          getter.prefix.name);
+      assert(deferredLibrary != null);
+      return new ir.LoadLibrary(deferredLibrary);
     }
-    return buildStaticGet(getter);
+    var expression = buildStaticGet(getter);
+    return expression;
   }
 
   @override
   ir.Expression handleStaticGetterInvoke(Send node, FunctionElement getter,
       NodeList arguments, CallStructure callStructure, _) {
+    var expression;
     if (getter.isDeferredLoaderGetter) {
-      // TODO(ahe): Support deferred load.
-      return new ir.InvalidExpression();
+      var deferredLibrary = new ir.DeferredImport(
+          kernel.libraries[getter.prefix.deferredImport.importedLibrary],
+          getter.prefix.name);
+      assert(deferredLibrary != null);
+      expression = new ir.LoadLibrary(deferredLibrary);

[sra1, 2017/02/14 03:14:06]

This code is the same as above.
I'd put it in a separate function so that if we threw our LoadLibrary and
directly make a js_runtime call, it would be in one place.

[Emily Fortuna, 2017/02/14 20:56:28]

done. See above.

+    } else {
+      expression = buildStaticGet(getter);
     }
-    return associateNode(
-        buildCall(buildStaticGet(getter), callStructure, arguments), node);
+    return associateNode(buildCall(expression, callStructure, arguments), node);
   }
 
   @override
   ir.Expression handleStaticGetterSet(
       SendSet node, FunctionElement getter, Node rhs, _) {
     return buildStaticAccessor(getter)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
@@ skipping 549 matching lines @@
           return new IrFunction.constructor(
               node, <ir.Initializer>[new ir.InvalidInitializer()]);
         } else {
           node.body = new ir.InvalidStatement()..parent = node;
           return new IrFunction.procedure(ir.ProcedureKind.Method, node);
         }
       } else if (currentElement.isSynthesized) {
         if (currentElement.isGenerativeConstructor) {
           return buildGenerativeConstructor(currentElement, null, null);
         } else {
-          return internalError(currentElement, "Unhandled synthetic function.");
+          return internalError(currentElement,
+              "Unhandled synthetic function.");
         }
       } else {
         Node node = currentElement.node;
         if (node.isErroneous) {
           return internalError(currentElement, "Unexpected syntax error.");
         } else {
           return node.accept(this);
         }
       }
     });
@@ skipping 37 matching lines @@
       : this(null, true, node, initializers);
 
   accept(ir.Visitor v) => throw "unsupported";
 
   visitChildren(ir.Visitor v) => throw "unsupported";
 
   String toString() {
     return "IrFunction($kind, $isConstructor, $node, $initializers)";
   }
 }