Insert the right checks for redirecting factories to deferred constructors.

pkg/compiler/lib/src/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;
 
 class SsaFunctionCompiler implements FunctionCompiler {
   SsaCodeGeneratorTask generator;
   SsaBuilderTask builder;
   SsaOptimizerTask optimizer;
@@ skipping 3209 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 for [prefixElement].
+  /// If [prefixElement] is [null] ndo nothing.
+  void generateIsDeferredLoadedCheckIfNeeded(PrefixElement prefixElement,
+                                             ast.Node location) {
+    if (prefixElement == null) return;
+    String loadId =
+        compiler.deferredLoadTask.importDeferName[prefixElement.deferredImport];
+    HInstruction loadIdConstant = addConstantString(loadId);
+    String uri = prefixElement.deferredImport.uri.dartString.slowToString();
+    HInstruction uriConstant = addConstantString(uri);
+    Element helper = backend.getCheckDeferredIsLoaded();
+    pushInvokeStatic(location, helper, [loadIdConstant, uriConstant]);
+    pop();
+  }
+
   /// 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 generateIsDeferredLoadedCheckOfSend(ast.Send node) {
+    generateIsDeferredLoadedCheckIfNeeded(
+        compiler.deferredLoadTask.deferredPrefixElement(node, elements),
+        node);
   }
 
   /// Generate read access of an unresolved static or top level entity.
   void generateStaticUnresolvedGet(ast.Send node, Element element) {
     if (element is ErroneousElement) {
       // An erroneous element indicates an unresolved static getter.
       generateThrowNoSuchMethod(
           node,
           noSuchMethodTargetSymbolString(element, 'get'),
           argumentNodes: const Link<ast.Node>());
@@ skipping 31 matching lines @@
     if (!type.containsAll(compiler.world) &&
         !instruction.isConstantNull()) {
       // TODO(13429): The inferrer should know that an element
       // cannot be null.
       instruction.instructionType = type.nonNullable();
     }
   }
 
   /// Read a static or top level [field].
   void generateStaticFieldGet(ast.Send node, FieldElement field) {
-    generateIsDeferredLoadedCheckIfNeeded(node);
+    generateIsDeferredLoadedCheckOfSend(node);
 
     ConstantExpression constant =
         backend.constants.getConstantForVariable(field);
     if (constant != null) {
       if (!field.isAssignable) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         generateStaticConstGet(node, field, constant);
       } else {
         // TODO(5346): Try to avoid the need for calling [declaration] before
         // creating an [HStatic].
         HInstruction instruction = new HStatic(
             field.declaration,
             TypeMaskFactory.inferredTypeForElement(field, compiler));
         push(instruction);
       }
     } else {
       HInstruction instruction = new HLazyStatic(
           field,
           TypeMaskFactory.inferredTypeForElement(field, compiler));
       push(instruction);
     }
   }
 
   /// Generate a getter invocation of the static or top level [getter].
   void generateStaticGetterGet(ast.Send node, MethodElement getter) {
     if (getter.isDeferredLoaderGetter) {
       generateDeferredLoaderGet(node, getter);
     } else {
-      generateIsDeferredLoadedCheckIfNeeded(node);
+      generateIsDeferredLoadedCheckOfSend(node);
       pushInvokeStatic(node, getter, <HInstruction>[]);
     }
   }
 
   /// Generate a dynamic getter invocation.
   void generateDynamicGet(ast.Send node) {
     HInstruction receiver = generateInstanceSendReceiver(node);
     generateInstanceGetterWithCompiledReceiver(
         node, elements.getSelector(node), receiver);
   }
 
   /// Generate a closurization of the static or top level [function].
   void generateStaticFunctionGet(ast.Send node, MethodElement function) {
-    generateIsDeferredLoadedCheckIfNeeded(node);
+    generateIsDeferredLoadedCheckOfSend(node);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     // creating an [HStatic].
     push(new HStatic(function.declaration, backend.nonNullType));
     // TODO(ahe): This should be registered in codegen.
     registry.registerGetOfStaticFunction(function.declaration);
   }
 
   /// Read a local variable, function or parameter.
   void handleLocalGet(LocalElement local) {
     stack.add(localsHandler.readLocal(local));
@@ skipping 1291 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);
+    generateIsDeferredLoadedCheckOfSend(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
@@ skipping 44 matching lines @@
     if (isSymbolConstructor) {
       constructor = compiler.symbolValidatedConstructor;
       assert(invariant(send, constructor != null,
                        message: 'Constructor Symbol.validated is missing'));
       callStructure = compiler.symbolValidatedConstructorSelector.callStructure;
       assert(invariant(send, callStructure != null,
                        message: 'Constructor Symbol.validated is missing'));
     }
 
     bool isRedirected = constructorDeclaration.isRedirectingFactory;
+    if (!constructorDeclaration.isCyclicRedirection) {
+      // Insert a check for every deferred redirection on the path to the
+      // final target.
+      ConstructorElement target = constructorDeclaration;
+      while (target.isRedirectingFactory) {
+        if (constructorDeclaration.redirectionDeferredPrefix != null) {
+          generateIsDeferredLoadedCheckIfNeeded(
+              target.redirectionDeferredPrefix,
+              node);
+        }
+        target = target.immediateRedirectionTarget;
+      }
+    }
     InterfaceType type = elements.getType(node);
     InterfaceType expectedType =
         constructorDeclaration.computeEffectiveTargetType(type);
     expectedType = localsHandler.substInContext(expectedType);
 
     if (compiler.elementHasCompileTimeError(constructor)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(compiler));
       return;
     }
@@ skipping 173 matching lines @@
 
   visitStaticSend(ast.Send node) {
     internalError(node, "Unexpected visitStaticSend");
   }
 
   /// Generate an invocation to the static or top level [function].
   void generateStaticFunctionInvoke(
       ast.Send node,
       FunctionElement function,
       CallStructure callStructure) {
-    generateIsDeferredLoadedCheckIfNeeded(node);
+    generateIsDeferredLoadedCheckOfSend(node);
 
     List<HInstruction> inputs = makeStaticArgumentList(
         callStructure,
         node.arguments,
         function.implementation);
 
     if (function == compiler.identicalFunction) {
       pushWithPosition(
           new HIdentity(inputs[0], inputs[1], null, backend.boolType), node);
       return;
@@ skipping 194 matching lines @@
       ConstantExpression constant,
       ast.NodeList arguments,
       CallStructure callStructure,
       _) {
     generateConstantTypeLiteral(node);
     generateTypeLiteralCall(node);
   }
 
   /// Generate the constant value for a constant type literal.
   void generateConstantTypeLiteral(ast.Send node) {
-    generateIsDeferredLoadedCheckIfNeeded(node);
+    generateIsDeferredLoadedCheckOfSend(node);
     // TODO(karlklose): add type representation
     if (node.isCall) {
       // The node itself is not a constant but we register the selector (the
       // identifier that refers to the class/typedef) as a constant.
       stack.add(addConstant(node.selector));
     } else {
       stack.add(addConstant(node));
     }
   }
 
@@ skipping 303 matching lines @@
       rhs = pop();
     }
     visitBinarySend(receiver, rhs,
                     elements.getOperatorSelectorInComplexSendSet(node),
                     node,
                     location: node.assignmentOperator);
   }
 
   @override
   handleSendSet(ast.SendSet node) {
-    generateIsDeferredLoadedCheckIfNeeded(node);
+    generateIsDeferredLoadedCheckOfSend(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 2152 matching lines @@
     if (unaliased is TypedefType) throw 'unable to unalias $type';
     unaliased.accept(this, builder);
   }
 
   void visitDynamicType(DynamicType type, SsaBuilder builder) {
     JavaScriptBackend backend = builder.compiler.backend;
     ClassElement cls = backend.findHelper('DynamicRuntimeType');
     builder.push(new HDynamicType(type, new TypeMask.exact(cls, classWorld)));
   }
 }