Insert checks before deferred calls and accesses.

sdk/lib/_internal/compiler/implementation/ssa/builder.dart

 // Copyright (c) 2012, 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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to implement [TypedElement.type] because our
  * optimizers may look at its declared type.
@@ skipping 1154 matching lines @@
 
     // Bail out early if the inlining decision is in the cache and we can't
     // inline (no need to check the hard constraints).
     bool cachedCanBeInlined =
         backend.inlineCache.canInline(function, insideLoop: insideLoop);
     if (cachedCanBeInlined == false) return false;
 
     bool meetsHardConstraints() {
       // Don't inline from one output unit to another. If something is deferred
       // it is to save space in the loading code.
-      var getOutputUnit = compiler.deferredLoadTask.outputUnitForElement;
-      if (getOutputUnit(element) !=
-          getOutputUnit(compiler.currentElement)) {
+      if (!compiler.deferredLoadTask
+          .inSameOutputUnit(element,compiler.currentElement)) {
         return false;
       }
       if (compiler.disableInlining) return false;
 
       assert(selector != null
              || Elements.isStaticOrTopLevel(element)
              || element.isGenerativeConstructorBody());
       if (selector != null && !selector.applies(function, compiler)) {
         return false;
       }
@@ skipping 1734 matching lines @@
    * [selector].
    */
   void generateInstanceGetterWithCompiledReceiver(ast.Send send,
                                                   Selector selector,
                                                   HInstruction receiver) {
     assert(Elements.isInstanceSend(send, elements));
     assert(selector.isGetter());
     pushInvokeDynamic(send, selector, [receiver]);
   }
 
+  /// Inserts a call to checkDeferredIsLoaded if the send has a prefix that
+  /// resolves to a deferred library.
+  void generateIsDeferredLoadedCheckIfNeeded(ast.Send node) {
+    DeferredLoadTask deferredTask = compiler.deferredLoadTask;
+    PrefixElement prefixElement =
+         deferredTask.deferredPrefixElement(node, elements);
+    if (prefixElement != null) {
+      String loadId =
+          deferredTask.importDeferName[prefixElement.deferredImport];
+      HInstruction loadIdConstant = addConstantString(loadId);
+      String uri = prefixElement.deferredImport.uri.dartString.slowToString();
+      HInstruction uriConstant = addConstantString(uri);
+      Element helper = backend.getCheckDeferredIsLoaded();
+      pushInvokeStatic(node, helper, [loadIdConstant, uriConstant]);
+      pop();
+    }
+  }
+
   void generateGetter(ast.Send send, Element element) {
     if (element != null && element.isForeign(compiler)) {
       visitForeignGetter(send);
     } else if (Elements.isStaticOrTopLevelField(element)) {
       Constant value;
       if (element.isField() && !element.isAssignable()) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         value = backend.constants.getConstantForVariable(element);
       }
@@ skipping 960 matching lines @@
     // The new object will now be referenced through the
     // `setRuntimeTypeInfo` call. We therefore set the type of that
     // instruction to be of the object's type.
     assert(stack.last is HInvokeStatic || stack.last == newObject);
     stack.last.instructionType = newObject.instructionType;
     return pop();
   }
 
   handleNewSend(ast.NewExpression node) {
     ast.Send send = node.send;
+    generateIsDeferredLoadedCheckIfNeeded(send);
+
     bool isFixedList = false;
     bool isFixedListConstructorCall =
         Elements.isFixedListConstructorCall(elements[send], send, compiler);
     bool isGrowableListConstructorCall =
         Elements.isGrowableListConstructorCall(elements[send], send, compiler);
 
     TypeMask computeType(element) {
       Element originalElement = elements[send];
       if (isFixedListConstructorCall
           || Elements.isFilledListConstructorCall(
@@ skipping 231 matching lines @@
     }
     if (element.isErroneous()) {
       // An erroneous element indicates that the funciton could not be resolved
       // (a warning has been issued).
       generateThrowNoSuchMethod(node,
                                 getTargetName(element),
                                 argumentNodes: node.arguments);
       return;
     }
     invariant(element, !element.isGenerativeConstructor());
+    generateIsDeferredLoadedCheckIfNeeded(node);
     if (element.isFunction()) {
       var inputs = <HInstruction>[];
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [addStaticSendArgumentsToList].
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element.implementation,
                                                     inputs);
       if (!succeeded) {
         generateWrongArgumentCountError(node, element, node.arguments);
         return;
@@ skipping 55 matching lines @@
       HInstruction target = pop();
       Selector selector = elements.getSelector(node);
       List<HInstruction> inputs = <HInstruction>[target];
       addDynamicSendArgumentsToList(node, inputs);
       Selector closureSelector = new Selector.callClosureFrom(selector);
       push(new HInvokeClosure(closureSelector, inputs, backend.dynamicType));
     }
   }
 
   visitGetterSend(ast.Send node) {
+    generateIsDeferredLoadedCheckIfNeeded(node);
     generateGetter(node, elements[node]);
   }
 
   // TODO(antonm): migrate rest of SsaFromAstMixin to internalError.
   internalError(String reason, {ast.Node node}) {
     compiler.internalError(node, reason);
   }
 
   void generateError(ast.Node node, String message, Element helper) {
     HInstruction errorMessage = addConstantString(message);
@@ skipping 248 matching lines @@
     } else {
       visit(arguments.head);
       assert(arguments.tail.isEmpty);
       rhs = pop();
     }
     visitBinary(receiver, node.assignmentOperator, rhs,
                 elements.getOperatorSelectorInComplexSendSet(node), node);
   }
 
   visitSendSet(ast.SendSet node) {
+    generateIsDeferredLoadedCheckIfNeeded(node);
     Element element = elements[node];
     if (!Elements.isUnresolved(element) && element.impliesType()) {
       ast.Identifier selector = node.selector;
       generateThrowNoSuchMethod(node, selector.source,
                                 argumentNodes: node.arguments);
       return;
     }
     ast.Operator op = node.assignmentOperator;
     if (node.isSuperCall) {
       HInstruction result;
@@ skipping 1742 matching lines @@
     DartType unaliased = type.unalias(builder.compiler);
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     ClassElement cls = builder.compiler.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls)));
   }
 }