Revert revision 19282. Some tests fail.

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 1126 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,
-                             Node callNode) {
+                             FunctionElement inlinedFromElement) {
     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> typeVariable = superclass.typeVariables;
-        supertype.typeArguments.forEach((DartType argument) {
-          localsHandler.directLocals[typeVariable.head.element] =
-              analyzeTypeArgument(argument, callNode);
-          typeVariable = typeVariable.tail;
-        });
-        // Also add null to non-provided type variables.
-        while (!typeVariable.isEmpty) {
-          localsHandler.directLocals[typeVariable.head.element] =
-              graph.addConstantNull(constantSystem);
-          typeVariable = typeVariable.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, call);
+                                fieldValues, constructor);
           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,
-                              functionNode);
+                              constructor);
       }
     }
   }
 
   /**
    * Run through the fields of [cls] and add their potential
    * initializers.
    *
    * Invariant: [classElement] must be an implementation element.
    */
@@ skipping 1802 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.isConstructor()) {
+    if (member.isFactoryConstructor()) {
       // The type variable is stored in a parameter of the method.
       return localsHandler.readLocal(type.element);
-    } else if (member.isInstanceMember()) {
+    } else if (member.isInstanceMember() ||
+               member.isGenerativeConstructor()) {
       // 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;
   }
 }