Mark the local for this as used if a constructor call needs type variables.

lib/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.
 
 class Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 310 matching lines @@
       updateLocal(boxedVariable, oldValue);
     }
     updateLocal(boxElement, newBox);
   }
 
   void startFunction(FunctionElement function,
                      FunctionExpression node) {
     Compiler compiler = builder.compiler;
     closureData = compiler.closureToClassMapper.computeClosureToClassMapping(
             node, builder.elements);
-
     FunctionSignature signature = function.computeSignature(compiler);
     signature.forEachParameter((Element element) {
       HInstruction parameter = new HParameterValue(element);
       builder.add(parameter);
       builder.parameters[element] = parameter;
       directLocals[element] = parameter;
       parameter.guaranteedType =
         builder.mapInferredType(typesTask.getGuaranteedTypeOfElement(element));
     });
 
@@ skipping 2120 matching lines @@
   }
 
   HInstruction analyzeTypeArgument(DartType argument, Node currentNode) {
     if (argument.element.isTypeVariable()) {
       if (work.element.isFactoryConstructor()
           || work.element.isGenerativeConstructor()) {
         // The type variable is stored in a parameter of the
         // factory.
         return localsHandler.readLocal(argument.element);
       } else if (work.element.isInstanceMember()) {
+        Element thisElement = localsHandler.closureData.thisElement;
+        if (!localsHandler.hasValueForDirectLocal(thisElement)) {
+          HInstruction thisValue = new HThis();

[ngeoffray, 2012/09/03 12:57:23]

I don't think this is right, you should use [thisInstruction]

[karlklose, 2012/09/03 13:55:19]

This was actually unnecessary. Removed.

+          add(thisValue);
+        }
         // The type variable is stored in [this].
         pushInvokeHelper1(interceptors.getGetRuntimeTypeInfo(),
                           localsHandler.readThis());
         HInstruction typeInfo = pop();
         HInstruction foreign = new HForeign(
             new LiteralDartString('#.$argument'),
             new LiteralDartString('String'),
             <HInstruction>[typeInfo]);
         add(foreign);
         return foreign;
@@ skipping 39 matching lines @@
     var inputs = <HInstruction>[];
     inputs.add(target);
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                   constructor, inputs);
     if (!succeeded) {
       // TODO(ngeoffray): Match the VM behavior and throw an
       // exception at runtime.
       compiler.cancel('Unimplemented non-matching static call', node: node);
     }
 
-    TypeAnnotation annotation = getTypeAnnotationFromSend(node);
-    elements.getType(annotation).arguments.forEach((DartType argument) {
+    TypeAnnotation annotation = node.getTypeAnnotation();
+    if (annotation == null) {
+      compiler.internalError("malformed send in new expression");
+    }
+    InterfaceType type = elements.getType(annotation);
+    type.arguments.forEach((DartType argument) {
       inputs.add(analyzeTypeArgument(argument, node));
     });
 
     HType elementType = computeType(constructor);
     HInstruction newInstance = new HInvokeStatic(inputs, elementType);
     pushWithPosition(newInstance, node);
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
@@ skipping 39 matching lines @@
 
   visitGetterSend(Send node) {
     generateGetter(node, elements[node]);
   }
 
   // TODO(antonm): migrate rest of SsaBuilder to internalError.
   internalError(String reason, [Node node]) {
     compiler.internalError(reason, node: node);
   }
 
-  // TODO(karlklose): share with resolver.
-  TypeAnnotation getTypeAnnotationFromSend(Send send) {
-    if (send.selector is TypeAnnotation) {
-      return send.selector;
-    } else if (send.selector is Send) {
-      Send selector = send.selector;
-      if (selector.receiver is TypeAnnotation) {
-        return selector.receiver;
-      }
-    } else {
-      compiler.internalError("malformed send in new expression");
-    }
-  }
-
   void generateRuntimeError(Node node, String message) {
     DartString messageObject = new DartString.literal(message);
     HInstruction errorMessage = graph.addConstantString(messageObject, node);
     Element helper = interceptors.getThrowRuntimeError();
     pushInvokeHelper1(helper, errorMessage);
   }
 
   visitNewExpression(NewExpression node) {
     Element element = elements[node.send];
     if (element != null && element.isErroneous()) {
@@ skipping 1328 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;
   }
 }