anchor.diff:                                     compiledArguments[argumentIndex++]);
       }
   
  -    if (function.isConstructor()) {
  -      ClassElement enclosing = function.getEnclosingClass();
  -      if (backend.needsRti(enclosing)) {
  -        assert(currentNode is NewExpression);
  -        InterfaceType type = elements.getType(currentNode);
  -        Link<DartType> typeVariable = enclosing.typeVariables;
  -        type.typeArguments.forEach((DartType argument) {
  -          HInstruction instruction =
  -              analyzeTypeArgument(argument, currentNode);
  -          newLocalsHandler.updateLocal(typeVariable.head.element, instruction);
  -          typeVariable = typeVariable.tail;
  -        });
  -        while (!typeVariable.isEmpty) {
  -          newLocalsHandler.updateLocal(typeVariable.head.element,
  -                                       graph.addConstantNull(constantSystem));
  -          typeVariable = typeVariable.tail;
  -        }
  -      }
  -    }
  +    ClassElement enclosing = function.getEnclosingClass();
  +    FunctionSignature signature = function.computeSignature(compiler);
  +    int parameterCount = signature.parameterCount;
  +    // If [function] is a generative constructor body, we need to add
  +    // 1 for the new instance.
  +    int typeArgumentIndex = parameterCount + (isInstanceMember ? 1 : 0);
  +    if ((function.isConstructor() || function.isGenerativeConstructorBody())
  +        && backend.needsRti(enclosing)) {
  +      enclosing.typeVariables.forEach((TypeVariableType typeVariable) {
  +        HInstruction argument = compiledArguments[typeArgumentIndex++];
  +        newLocalsHandler.updateLocal(typeVariable.element, argument);
  +      });
  +    }
  +    assert(typeArgumentIndex == compiledArguments.length);
   
       // Check the type of the arguments.  This must be done after setting up the
       // type variables in the [localsHandler] because the checked types may
       // contain type variables.
  -    FunctionSignature signature = function.computeSignature(compiler);
       signature.orderedForEachParameter((Element parameter) {
         HInstruction argument = compiledArguments[argumentIndex++];
         newLocalsHandler.updateLocal(parameter, argument);
         potentiallyCheckType(argument, parameter.computeType(compiler));
       });
  +    assert(argumentIndex == parameterCount + (isInstanceMember ? 1 : 0));
   
       // TODO(kasperl): Bad smell. We shouldn't be constructing elements here.
       returnElement = new ElementX(const SourceString("result"),
  
positive.code:    *
     * Invariant: [function] must be an implementation element.
     */
    final PartialFunctionElement function;
    final Element oldReturnElement;
    final DartType oldReturnType;
    final TreeElements oldElements;
  
negative.code:     List<HInstruction> compiledArguments;
      bool isInstanceMember = function.isInstanceMember();
  
      if (isInstanceMember && !function.isGenerativeConstructorBody()) {
        assert(providedArguments != null);
        compiledArguments = new List<HInstruction>();
        compiledArguments.add(providedArguments[0]);
  