Re-apply: Inside a generative constructor, "this" is created at the very end. So we have to use the…

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 override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 167 matching lines @@
   }
 
   /**
    * If the scope (function or loop) [node] has captured variables then this
    * method creates a box and sets up the redirections.
    */
   void enterScope(Node node, Element element) {
     // See if any variable in the top-scope of the function is captured. If yes
     // we need to create a box-object.
     ClosureScope scopeData = closureData.capturingScopes[node];
-    if (scopeData != null) {
-      HInstruction box;
-      // The scope has captured variables.
-      if (element != null && element.isGenerativeConstructorBody()) {
-        // The box is passed as a parameter to a generative
-        // constructor body.
-        box = builder.addParameter(scopeData.boxElement);
+    if (scopeData == null) return;
+    HInstruction box;
+    // The scope has captured variables.
+    if (element != null && element.isGenerativeConstructorBody()) {
+      // The box is passed as a parameter to a generative
+      // constructor body.
+      box = builder.addParameter(scopeData.boxElement);
+    } else {
+      box = createBox();
+    }
+    // Add the box to the known locals.
+    directLocals[scopeData.boxElement] = box;
+    // Make sure that accesses to the boxed locals go into the box. We also
+    // need to make sure that parameters are copied into the box if necessary.
+    scopeData.capturedVariableMapping.forEach((Element from, Element to) {
+      // The [from] can only be a parameter for function-scopes and not
+      // loop scopes.
+      if (from.isParameter() && !element.isGenerativeConstructorBody()) {
+        // Now that the redirection is set up, the update to the local will
+        // write the parameter value into the box.
+        // Store the captured parameter in the box. Get the current value
+        // before we put the redirection in place.
+        // We don't need to update the local for a generative
+        // constructor body, because it receives a box that already
+        // contains the updates as the last parameter.
+        HInstruction instruction = readLocal(from);
+        redirectElement(from, to);
+        updateLocal(from, instruction);
       } else {
-        box = createBox();
+        redirectElement(from, to);
       }
-      // Add the box to the known locals.
-      directLocals[scopeData.boxElement] = box;
-      // Make sure that accesses to the boxed locals go into the box. We also
-      // need to make sure that parameters are copied into the box if necessary.
-      scopeData.capturedVariableMapping.forEach((Element from, Element to) {
-        // The [from] can only be a parameter for function-scopes and not
-        // loop scopes.
-        if (from.isParameter() && !element.isGenerativeConstructorBody()) {
-          // Now that the redirection is set up, the update to the local will
-          // write the parameter value into the box.
-          // Store the captured parameter in the box. Get the current value
-          // before we put the redirection in place.
-          // We don't need to update the local for a generative
-          // constructor body, because it receives a box that already
-          // contains the updates as the last parameter.
-          HInstruction instruction = readLocal(from);
-          redirectElement(from, to);
-          updateLocal(from, instruction);
-        } else {
-          redirectElement(from, to);
-        }
-      });
-    }
+    });
   }
 
   /**
    * Replaces the current box with a new box and copies over the given list
    * of elements from the old box into the new box.
    */
   void updateCaptureBox(Element boxElement, List<Element> toBeCopiedElements) {
     // Create a new box and copy over the values from the old box into the
     // new one.
     HInstruction oldBox = readLocal(boxElement);
@@ skipping 906 matching lines @@
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [constructor] and [constructors] must all be implementation
    * elements.
    */
   void inlineSuperOrRedirect(FunctionElement constructor,
                              Selector selector,
                              Link<Node> arguments,
                              List<FunctionElement> constructors,
                              Map<Element, HInstruction> fieldValues,
-                             FunctionElement inlinedFromElement) {
+                             FunctionElement inlinedFromElement,
+                             Node callNode) {
     compiler.withCurrentElement(constructor, () {
       assert(invariant(constructor, constructor.isImplementation));
       constructors.addLast(constructor);
 
       List<HInstruction> compiledArguments = new List<HInstruction>();
       bool succeeded =
           inlinedFrom(inlinedFromElement,
                        () => addStaticSendArgumentsToList(selector,
                                                           arguments,
                                                           constructor,
                                                           compiledArguments));
       if (!succeeded) {
         // Non-matching super and redirects are compile-time errors and thus
         // checked by the resolver.
         compiler.internalError(
             "Parameters and arguments didn't match for super/redirect call",
             element: constructor);
       }
 
+      ClassElement superclass = constructor.getEnclosingClass();
+      if (compiler.world.needsRti(superclass)) {
+        // If [superclass] needs RTI, we have to give a value to its
+        // type parameters. Those values are in the [supertype]
+        // declaration of [subclass].
+        ClassElement subclass = inlinedFromElement.getEnclosingClass();
+        DartType supertype = subclass.supertype;
+        Link<DartType> typeVariables = superclass.typeVariables;
+        supertype.typeArguments.forEach((DartType argument) {
+          localsHandler.updateLocal(typeVariables.head.element,
+              analyzeTypeArgument(argument, callNode));
+          typeVariables = typeVariables.tail;
+        });
+        // If the supertype is a raw type, we need to set to null the
+        // type variables.
+        assert(typeVariables.isEmpty
+               || superclass.typeVariables == typeVariables);
+        while (!typeVariables.isEmpty) {
+          localsHandler.updateLocal(typeVariables.head.element,
+              graph.addConstantNull(constantSystem));
+          typeVariables = typeVariables.tail;
+        }
+      }
+
       inlinedFrom(constructor, () {
         buildFieldInitializers(constructor.enclosingElement.implementation,
                                fieldValues);
       });
 
       int index = 0;
       FunctionSignature params = constructor.computeSignature(compiler);
       params.orderedForEachParameter((Element parameter) {
         HInstruction argument = compiledArguments[index++];
         // Because we are inlining the initializer, we must update
@@ skipping 62 matching lines @@
         assert(link.head is Send);
         if (link.head is !SendSet) {
           // A super initializer or constructor redirection.
           Send call = link.head;
           assert(Initializers.isSuperConstructorCall(call) ||
                  Initializers.isConstructorRedirect(call));
           FunctionElement target = elements[call];
           Selector selector = elements.getSelector(call);
           Link<Node> arguments = call.arguments;
           inlineSuperOrRedirect(target, selector, arguments, constructors,
-                                fieldValues, constructor);
+                                fieldValues, constructor, call);
           foundSuperOrRedirect = true;
         } else {
           // A field initializer.
           SendSet init = link.head;
           Link<Node> arguments = init.arguments;
           assert(!arguments.isEmpty && arguments.tail.isEmpty);
           inlinedFrom(constructor, () {
             visit(arguments.head);
           });
           fieldValues[elements[init]] = pop();
@@ skipping 14 matching lines @@
         // TODO(johnniwinther): Should we find injected constructors as well?
         FunctionElement target = superClass.lookupConstructor(selector);
         if (target == null) {
           compiler.internalError("no default constructor available");
         }
         inlineSuperOrRedirect(target.implementation,
                               selector,
                               const Link<Node>(),
                               constructors,
                               fieldValues,
-                              constructor);
+                              constructor,
+                              functionNode);
       }
     }
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
@@ skipping 87 matching lines @@
         includeSuperMembers: true);
 
     InterfaceType type = classElement.computeType(compiler);
     HType ssaType = new HType.nonNullExactClass(type, compiler);
     HForeignNew newObject = new HForeignNew(classElement,
                                             ssaType,
                                             constructorArguments);
     add(newObject);
 
     // Create the runtime type information, if needed.
-    List<HInstruction> inputs = <HInstruction>[];
     if (compiler.world.needsRti(classElement)) {
+      List<HInstruction> rtiInputs = <HInstruction>[];
       classElement.typeVariables.forEach((TypeVariableType typeVariable) {
-        inputs.add(localsHandler.directLocals[typeVariable.element]);
+        rtiInputs.add(localsHandler.readLocal(typeVariable.element));
       });
-      callSetRuntimeTypeInfo(classElement, inputs, newObject);
+      callSetRuntimeTypeInfo(classElement, rtiInputs, newObject);
     }
 
     // Generate calls to the constructor bodies.
     for (int index = constructors.length - 1; index >= 0; index--) {
       FunctionElement constructor = constructors[index];
       assert(invariant(functionElement, constructor.isImplementation));
       ConstructorBodyElement body = getConstructorBody(constructor);
       if (body == null) continue;
       List bodyCallInputs = <HInstruction>[];
       bodyCallInputs.add(newObject);
-      FunctionSignature functionSignature = body.computeSignature(compiler);
-      functionSignature.orderedForEachParameter((parameter) {
-        if (!localsHandler.isBoxed(parameter)) {
-          // The parameter will be a field in the box passed as the
-          // last parameter. So no need to pass it.
-          bodyCallInputs.add(localsHandler.readLocal(parameter));
-        }
-      });
-
-      // If parameters are checked, we pass the already computed
-      // boolean to the constructor body.
       TreeElements elements =
           compiler.enqueuer.resolution.getCachedElements(constructor);
       Node node = constructor.parseNode(compiler);
       ClosureClassMap parameterClosureData =
           compiler.closureToClassMapper.getMappingForNestedFunction(node);
+
+
+      FunctionSignature functionSignature = body.computeSignature(compiler);
       functionSignature.orderedForEachParameter((parameter) {
+        // if [parameter] is boxed, it will be a field in the box passed as the
+        // last parameter. So no need to direclty pass it.
+        if (!localsHandler.isBoxed(parameter)) {
+          bodyCallInputs.add(localsHandler.readLocal(parameter));
+        }
+        // If [parameter] is checked, we pass the already computed
+        // boolean to the constructor body.
         if (elements.isParameterChecked(parameter)) {
           Element fieldCheck =
               parameterClosureData.parametersWithSentinel[parameter];
           bodyCallInputs.add(localsHandler.readLocal(fieldCheck));
         }
       });
 
-      // If there are locals that escape (ie used in closures), we
+      ClassElement currentClass = constructor.getEnclosingClass();
+      if (compiler.world.needsRti(currentClass)) {
+        // If [currentClass] needs RTI, we add the type variables as
+        // parameters of the generative constructor body.
+        currentClass.typeVariables.forEach((DartType argument) {
+          bodyCallInputs.add(localsHandler.readLocal(argument.element));
+        });
+      }
+
+      // If there are locals that escape (ie mutated in closures), we
       // pass the box to the constructor.
       ClosureScope scopeData = parameterClosureData.capturingScopes[node];
       if (scopeData != null) {
         bodyCallInputs.add(localsHandler.readLocal(scopeData.boxElement));
       }
 
       // TODO(ahe): The constructor name is statically resolved. See
       // SsaCodeGenerator.visitInvokeDynamicMethod. Is there a cleaner
       // way to do this?
       SourceString name =
@@ skipping 110 matching lines @@
 
       returnType = signature.returnType;
     } else {
       // Otherwise it is a lazy initializer which does not have parameters.
       assert(element is VariableElement);
     }
 
     // Add the type parameters of the class as parameters of this
     // method.
     var enclosing = element.enclosingElement;
-    if (element.isConstructor() && compiler.world.needsRti(enclosing)) {
+    if ((element.isConstructor() || element.isGenerativeConstructorBody())
+        && compiler.world.needsRti(enclosing)) {
       enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
         HParameterValue param = addParameter(typeVariable.element);
         localsHandler.directLocals[typeVariable.element] = param;
       });
     }
   }
 
   HInstruction potentiallyCheckType(
       HInstruction original, DartType type,
       { int kind: HTypeConversion.CHECKED_MODE_CHECK }) {
@@ skipping 1523 matching lines @@
   /**
    * Helper to create an instruction that gets the value of a type variable.
    */
   HInstruction addTypeVariableReference(TypeVariableType type) {
     Element member = currentElement;
     if (member.enclosingElement.isClosure()) {
       ClosureClassElement closureClass = member.enclosingElement;
       member = closureClass.methodElement;
       member = member.getOutermostEnclosingMemberOrTopLevel();
     }
-    if (member.isFactoryConstructor()) {
+    if (member.isConstructor() || member.isGenerativeConstructorBody()) {
       // The type variable is stored in a parameter of the method.
       return localsHandler.readLocal(type.element);
-    } else if (member.isInstanceMember() ||
-               member.isGenerativeConstructor()) {
+    } else if (member.isInstanceMember()) {
       // The type variable is stored on the object.  Generate code to extract
       // the type arguments from the object, substitute them as an instance
       // of the type we are testing against (if necessary), and extract the
       // type argument by the index of the variable in the list of type
       // variables for that class.
       int index = RuntimeTypeInformation.getTypeVariableIndex(type);
       HInstruction thisObject = localsHandler.readThis();
       String substitutionNameString =
           backend.namer.substitutionName(member.getEnclosingClass());
       HInstruction substitutionName = graph.addConstantString(
@@ skipping 1855 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }