Add deferred loading to Kernel.

pkg/compiler/lib/src/ssa/builder_kernel.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 file.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
@@ skipping 575 matching lines @@
       LocalFunctionElement element = astAdapter.getElement(target);
       ClosureClassMap classMap = compiler.closureToClassMapper
           .getClosureToClassMapping(element.resolvedAst);
       return classMap.callElement;
     }
     Element element = astAdapter.getElement(target);
     return element;
   }
 
   @override
+  void visitCheckLibraryIsLoaded(ir.CheckLibraryIsLoaded checkLoad) {
+    HInstruction prefixConstant = graph.addConstantString(
+        new DartString.literal(checkLoad.import.name), closedWorld);
+    // TODO(efortuna): Optimization opportunity! Make this constant file name
+    // some sort of global constant (or a constant in the check loaded function)
+    // to look up rather than always passing in. Also note that the URI passed
+    // here is longer that in the original one, which called
+    // compiler.deferredLoadTask.getImportDeferName and then also needed the
+    // previsit function to hold the prefix element.

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

How are we going to fix this (getting the shorter name)?
The deferredLoadTask is still needed to track the chunks.
Can we call it here, or add a new entry point?

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

This is what I was talking about last week. We can do so, but it requires a
previsit function to store the prefix element until we reach this function. We
can also write a variant of the "make unique" URI function that we're doing in
the original version, but it seems like it ties us closer to the element model
with very little benefit for a lot of extra work.

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

I'm concerned that two builds will generate different code because of generated
libraries being in some different tmp directory each build.
Or if you build and I build, we get our home directory aka user names in the
generated code.

State in the TODO that we want a shorter name that is independent of the
directory in which the source tree lives.

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

Fixed it properly.

+    HInstruction uriConstant = graph.addConstantString(
+        new DartString.literal(checkLoad.import.importedLibrary.importUri),
+        closedWorld);
+    _pushStaticInvocation(astAdapter.checkDeferredIsLoaded,
+        [prefixConstant, uriConstant], astAdapter.checkDeferredIsLoadedType);
+  }
+
+  @override
+  void visitLoadLibrary(ir.LoadLibrary loadLibrary) {
+    // TODO(efortuna): Source information!
+    push(new HInvokeStatic(
+        backend.helpers.loadLibraryWrapper,
+        [
+          graph.addConstantString(
+              new DartString.literal(loadLibrary.import.name), closedWorld)
+        ],
+        commonMasks.nonNullType,
+        targetCanThrow: false));
+  }
+
+  @override
   void visitBlock(ir.Block block) {
     assert(!isAborted());
     for (ir.Statement statement in block.statements) {
       statement.accept(this);
       if (!isReachable) {
         // The block has been aborted by a return or a throw.
         if (stack.isNotEmpty) {
           compiler.reporter.internalError(
               NO_LOCATION_SPANNABLE, 'Non-empty instruction stack.');
         }
@@ skipping 1217 matching lines @@
   }
 
   @override
   void visitStaticGet(ir.StaticGet staticGet) {
     ir.Member staticTarget = staticGet.target;
     if (staticTarget is ir.Procedure &&
         staticTarget.kind == ir.ProcedureKind.Getter) {
       // Invoke the getter
       _pushStaticInvocation(staticTarget, const <HInstruction>[],
           astAdapter.returnTypeOf(staticTarget));
-    } else if (staticTarget is ir.Field && staticTarget.isConst) {
-      assert(staticTarget.initializer != null);
+    } else if (staticTarget is ir.Field &&
+        (staticTarget.isConst ||
+            staticTarget.isFinal && !_isLazyStatic(staticTarget))) {
       stack.add(graph.addConstant(
           astAdapter.getConstantFor(staticTarget.initializer), closedWorld));
     } else {
       if (_isLazyStatic(staticTarget)) {
         push(new HLazyStatic(astAdapter.getField(staticTarget),
             astAdapter.inferredTypeOf(staticTarget)));
       } else {
         push(new HStatic(astAdapter.getMember(staticTarget),
             astAdapter.inferredTypeOf(staticTarget)));
       }
@@ skipping 1382 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }