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');
+    buildCheckDeferredIsLoaded(prefix, node,
+        sourceInformationBuilder.buildCall(node, node.selector));
+  }
+
+  ir.Primitive buildCheckDeferredIsLoaded(PrefixElement prefix, Spannable node,
+      SourceInformation sourceInformation) {
+    if (prefix == null) return null;
+    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 1854 matching lines @@
 
   FunctionElement get stringifyFunction {
     return _backend.helpers.stringInterpolationHelper;
   }
 
   FunctionElement get throwTypeErrorHelper => _backend.helpers.throwTypeError;
   Element get throwNoSuchMethod => _backend.helpers.throwNoSuchMethod;
 
   ClassElement get nullClass => _compiler.coreClasses.nullClass;
 
+  Element get loadLibraryFunction => _compiler.loadLibraryFunction;
+  String getImportDeferName(PrefixElement prefix) {
+    return _compiler.deferredLoadTask.getImportDeferName(null, prefix);
+  }
+
   DartType unaliasType(DartType type) => type.unaliased;
 
   TypeMask getTypeMaskForForeign(NativeBehavior behavior) {
     if (behavior == null) {
       return _backend.dynamicType;
     }
     return TypeMaskFactory.fromNativeBehavior(behavior, _compiler);
   }
 
   FieldElement locateSingleField(Selector selector, TypeMask type) {
@@ skipping 743 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,
+          sourceInformationBuilder.buildCall(send, send.selector));
+    }
+
     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,
+              sourceInformationBuilder.buildCall(send, send.selector));
+        }
+        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));
     }
   }
 }