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 29 matching lines @@
         AsyncMarker,
         ClassElement,
         ConstructorElement,
         Element,
         FieldElement,
         FunctionElement,
         FunctionSignature,
         GetterElement,
         InitializingFormalElement,
         JumpTarget,
+        LibraryElement,
         LocalElement,
         LocalFunctionElement,
         LocalVariableElement,
         MethodElement,
         Name,
         ParameterElement,
         PrefixElement,
         TypeVariableElement;
 import '../resolution/operators.dart'
     show AssignmentOperator, BinaryOperator, IncDecOperator, UnaryOperator;
@@ skipping 135 matching lines @@
 
   final Map<JumpTarget, ir.LabeledStatement> breakTargets =
       <JumpTarget, ir.LabeledStatement>{};
 
   final Map<LocalElement, ir.VariableDeclaration> locals =
       <LocalElement, ir.VariableDeclaration>{};
 
   final Map<CascadeReceiver, ir.VariableGet> cascadeReceivers =
       <CascadeReceiver, ir.VariableGet>{};
 
+  // This maps underlying Library elements to the corresponding DeferredImport
+  // object, via the prefix name (aka "bar" in
+  // "import foo.dart deferred as bar").

[sra1, 2017/02/14 21:55:28]

Is the 'underlying' library element the current library or the imported library?

[Emily Fortuna, 2017/02/15 01:02:31]

updated the comment -- imported library.

+  final Map<LibraryElement, Map<String, ir.DeferredImport>> deferredImports =
+      <LibraryElement, Map<String, ir.DeferredImport>>{};
+
   ir.Node associateElement(ir.Node node, Element element) {
     kernel.nodeToElement[node] = element;
     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 = getDeferredImport(prefix);
+    } 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 214 matching lines @@
     return buildStaticAccessor(function)
         .buildAssignment(visitForValue(rhs), voidContext: isVoidContext);
   }
 
   @override
   IrFunction visitStaticGetterDeclaration(
       FunctionExpression node, MethodElement getter, Node body, _) {
     return buildIrFunction(ir.ProcedureKind.Getter, getter, body);
   }
 
+  ir.DeferredImport getDeferredImport(PrefixElement prefix) {
+    ir.DeferredImport deferredImport;
+    var importedLibraryElement = prefix.deferredImport.importedLibrary;
+    if (deferredImports.containsKey(importedLibraryElement)) {
+      var prefixToDeferredImport = deferredImports[importedLibraryElement];

[sra1, 2017/02/14 21:55:28]

Nowadays I find ??= more convenient

var map = deferredImports[importedLibraryElement] ??= <...>{};
return deferredImports[prefix.name] ??= new ...

[Emily Fortuna, 2017/02/15 01:02:31]

Done.

+      deferredImport =
+          prefixToDeferredImport.putIfAbsent(prefix.name, () {
+        return new ir.DeferredImport(kernel.libraries[importedLibraryElement],
+            prefix.name);
+      });
+    } else {
+      deferredImport = new ir.DeferredImport(
+          kernel.libraries[importedLibraryElement], prefix.name);
+      deferredImports[importedLibraryElement] = {prefix.name: deferredImport};

[sra1, 2017/02/14 21:55:28]

Type parameters on literal.

[Emily Fortuna, 2017/02/15 01:02:31]

Done.

+    }
+    return deferredImport;
+  }
+
   @override
   ir.Expression handleStaticGetterGet(Send node, FunctionElement getter, _) {
     if (getter.isDeferredLoaderGetter) {
-      // TODO(ahe): Support deferred load.
-      return new ir.InvalidExpression();
+      return new ir.LoadLibrary(getDeferredImport(getter.enclosingElement));
     }
-    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();
+      expression = new ir.LoadLibrary(getDeferredImport(
+            getter.enclosingElement));
+    } 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 607 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)";
   }
 }