cpsir: add support for deferred code

pkg/compiler/lib/src/cps_ir/cps_ir_builder_task.dart

 // Copyright (c) 2013, 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.
 
 library dart2js.ir_builder_task;
 
 import '../closure.dart' as closurelib;
 import '../closure.dart' hide ClosureScope;
 import '../common.dart';
 import '../common/names.dart' show
@@ skipping 688 matching lines @@
       // in production mode.
       // Assertions can only occur in expression statements, so no value needs
       // to be returned.
       return null;
     }
   }
 
   // ## Sends ##
   @override
   void previsitDeferredAccess(ast.Send node, PrefixElement prefix, _) {
-    giveup(node, 'deferred access is not implemented');
+    if (prefix != null) buildCheckDeferredIsLoaded(prefix, node);
+  }
+
+  /// Create a call to check that a deferred import has already been loaded.
+  ir.Primitive buildCheckDeferredIsLoaded(PrefixElement prefix, ast.Send node) {
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildCall(node, node.selector);
+    JavaScriptBackend backend = compiler.backend;
+    return irBuilder.buildStaticFunctionInvocation(
+        backend.helpers.checkDeferredIsLoaded,
+        CallStructure.TWO_ARGS, <ir.Primitive>[
+          irBuilder.buildStringConstant(
+              compiler.deferredLoadTask.getImportDeferName(node, prefix)),
+          irBuilder.buildStringConstant('${prefix.deferredImport.uri}'),
+        ], sourceInformation: sourceInformation);
   }
 
   ir.Primitive visitNamedArgument(ast.NamedArgument node) {
     assert(irBuilder.isOpen);
     return visit(node.expression);
   }
 
   @override
   ir.Primitive visitExpressionInvoke(ast.Send node,
                                      ast.Node expression,
@@ skipping 98 matching lines @@
       MethodElement function,
       _) {
     return irBuilder.buildStaticFunctionGet(function);
   }
 
   @override
   ir.Primitive handleStaticGetterGet(
       ast.Send node,
       FunctionElement getter,
       _) {
-    return irBuilder.buildStaticGetterGet(
-        getter, sourceInformationBuilder.buildGet(node));
+    return buildStaticGetterGet(getter, node);
+  }
+
+  /// Create a getter invocation of the static getter [getter]. This also
+  /// handles the special case where [getter] is the `loadLibrary`
+  /// pseudo-function on library prefixes of deferred imports.
+  ir.Primitive buildStaticGetterGet(MethodElement getter, ast.Send node) {
+    SourceInformation sourceInformation =
+        sourceInformationBuilder.buildGet(node);
+    if (getter.isDeferredLoaderGetter) {
+      PrefixElement prefix = getter.enclosingElement;
+      ir.Primitive loadId = irBuilder.buildStringConstant(
+          compiler.deferredLoadTask.getImportDeferName(node, prefix));
+      return irBuilder.buildStaticFunctionInvocation(
+          compiler.loadLibraryFunction,
+          CallStructure.ONE_ARG, <ir.Primitive>[loadId],
+          sourceInformation: sourceInformation);
+    } else {
+      return irBuilder.buildStaticGetterGet(getter, sourceInformation);
+    }
   }
 
   @override
   ir.Primitive visitSuperFieldGet(
       ast.Send node,
       FieldElement field,
       _) {
     return irBuilder.buildSuperFieldGet(field);
   }
 
@@ skipping 410 matching lines @@
         arguments.nodes.mapToList(visit));
   }
 
   @override
   ir.Primitive handleStaticGetterInvoke(
       ast.Send node,
       FunctionElement getter,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
-    ir.Primitive target = irBuilder.buildStaticGetterGet(getter,
-        sourceInformationBuilder.buildGet(node));
+    ir.Primitive target = buildStaticGetterGet(getter, node);
     List<ir.Primitive> arguments = <ir.Primitive>[];
     callStructure =
         translateDynamicArguments(argumentsNode, callStructure, arguments);
     return irBuilder.buildCallInvocation(
         target,
         callStructure,
         arguments,
         sourceInformation:
             sourceInformationBuilder.buildCall(node, argumentsNode));
   }
@@ skipping 449 matching lines @@
       CompoundRhs rhs,
       arg) {
     return translateCompounds(
         node,
         getValue: () {
           switch (getterKind) {
             case CompoundGetter.FIELD:
               SourceInformation src = sourceInformationBuilder.buildGet(node);
               return buildStaticFieldGet(getter, src);
             case CompoundGetter.GETTER:
-              return irBuilder.buildStaticGetterGet(
-                  getter, sourceInformationBuilder.buildGet(node));
+              return buildStaticGetterGet(getter, node);
             case CompoundGetter.METHOD:
               return irBuilder.buildStaticFunctionGet(getter);
             case CompoundGetter.UNRESOLVED:
               return buildStaticNoSuchGetter(getter);
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           switch (setterKind) {
             case CompoundSetter.FIELD:
@@ skipping 16 matching lines @@
       ast.Node rhs,
       _) {
     return translateSetIfNull(
         node,
         getValue: () {
           switch (getterKind) {
             case CompoundGetter.FIELD:
               SourceInformation src = sourceInformationBuilder.buildGet(node);
               return buildStaticFieldGet(getter, src);
             case CompoundGetter.GETTER:
-              return irBuilder.buildStaticGetterGet(
-                  getter, sourceInformationBuilder.buildGet(node));
+              return buildStaticGetterGet(getter, node);
             case CompoundGetter.METHOD:
               return irBuilder.buildStaticFunctionGet(getter);
             case CompoundGetter.UNRESOLVED:
               return buildStaticNoSuchGetter(getter);
           }
         },
         rhs: rhs,
         setValue: (ir.Primitive result) {
           switch (setterKind) {
             case CompoundSetter.FIELD:
@@ skipping 1556 matching lines @@
   }
 
   @override
   ir.Primitive handleConstructorInvoke(
       ast.NewExpression node,
       ConstructorElement constructor,
       DartType type,
       ast.NodeList argumentsNode,
       CallStructure callStructure,
       _) {
+
+    ast.Send send = node.send;
+    // If an allocation refers to a type using a deferred import prefix (e.g.
+    // `new lib.A()`), we must ensure that the deferred import has already been
+    // loaded.
+    var prefix = compiler.deferredLoadTask.deferredPrefixElement(
+        send, elements);
+    if (prefix != null) buildCheckDeferredIsLoaded(prefix, send);

[asgerf, 2016/01/06 02:34:21]

I think we need to evaluate the arguments before this check.

Spec p. 70:
"First, the argument list (a1, . . . , an, xn+1 : an+1, . . . , xn+k : an+k) is
evaluated.
If T is a deferred type with prefix p, then if p has not been successfully
loaded, a dynamic error occurs."

[Siggi Cherem (dart-lang), 2016/01/06 03:08:00]

Interesting - that's how I thought it should be and how I had it initially, but
I changed it because this test is checking the opposite:

https://github.com/dart-lang/sdk/blob/master/tests/language/deferred_not_load...

If you don't mind, I'm thinking of keeping the semantics to match what we do in
SSA and in the vm for now and separately fix this issue. In particular, I think
the fix in the case of `new` calls is simple, but to fix static calls we'll need
to do some changes in the semantic visitor (for previsitDeferredAccess) that I
rather do separately.

I just filed https://github.com/dart-lang/sdk/issues/25355 with more details.

+
     List<ir.Primitive> arguments = argumentsNode.nodes.mapToList(visit);
     // Use default values from the effective target, not the immediate target.
     ConstructorElement target = constructor.effectiveTarget;
-    callStructure =
-        normalizeStaticArguments(callStructure, target, arguments);
+
+    // We also emit deferred import checks when using redirecting factories that
+    // refer to deferred prefixes.
+    if (constructor.isRedirectingFactory && !constructor.isCyclicRedirection) {
+      ConstructorElement current = constructor;
+      while (current.isRedirectingFactory) {
+        var prefix = current.redirectionDeferredPrefix;
+        if (prefix != null) buildCheckDeferredIsLoaded(prefix, send);
+        current = current.immediateRedirectionTarget;
+      }
+    }
+
+    callStructure = normalizeStaticArguments(callStructure, target, arguments);
     TypeMask allocationSiteType;
-    ast.Node send = node.send;
+
     if (Elements.isFixedListConstructorCall(constructor, send, compiler) ||
         Elements.isGrowableListConstructorCall(constructor, send, compiler) ||
         Elements.isFilledListConstructorCall(constructor, send, compiler) ||
         Elements.isConstructorOfTypedArraySubclass(constructor, compiler)) {
       allocationSiteType = getAllocationSiteType(send);
     }
     return irBuilder.buildConstructorInvocation(
         target,
         callStructure,
         constructor.computeEffectiveTargetType(type),
@@ skipping 300 matching lines @@
       callStructure = translateStaticArguments(argumentsNode, function,
           callStructure, arguments);
       return irBuilder.buildStaticFunctionInvocation(function,
           callStructure,
           arguments,
           sourceInformation:
               sourceInformationBuilder.buildCall(node, node.selector));
     }
   }
 }