Unify parsing of constructor references.

dart/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 2880 matching lines @@
     add(runtimeInfo);
 
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = interceptors.getSetRuntimeTypeInfo();
     HInstruction typeInfoSetter = new HStatic(typeInfoSetterElement);
     add(typeInfoSetter);
     add(new HInvokeStatic(
         <HInstruction>[typeInfoSetter, newObject, runtimeInfo]));
   }
 
-  visitNewSend(Send node) {
+  visitNewSend(Send node, InterfaceType type) {
     bool isListConstructor = false;
     computeType(element) {
       Element originalElement = elements[node];
       if (identical(originalElement.getEnclosingClass(), compiler.listClass)) {
         isListConstructor = true;
         if (node.arguments.isEmpty()) {
           return HType.EXTENDABLE_ARRAY;
         } else {
           return HType.MUTABLE_ARRAY;
         }
@@ skipping 22 matching lines @@
     // calling [addStaticSendArgumentsToList].
     bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                   constructor.implementation,
                                                   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 = node.getTypeAnnotation();
-    if (annotation == null) {
-      compiler.internalError("malformed send in new expression");
-    }
-    InterfaceType type = elements.getType(annotation);
     if (type.element.modifiers.isAbstract() &&
         constructor.isGenerativeConstructor()) {
       generateAbstractClassInstantiationError(node, type.name.slowToString());
       return;
     }
     if (compiler.world.needsRti(constructor.enclosingElement)) {
       type.arguments.forEach((DartType argument) {
         inputs.add(analyzeTypeArgument(argument, node));
       });
     }
@@ skipping 132 matching lines @@
       } else {
         compiler.internalError('unexpected unresolved constructor call',
                                node: node);
       }
     } else if (node.isConst()) {
       // TODO(karlklose): add type representation
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
       stack.add(graph.addConstant(constant));
     } else {
-      visitNewSend(node.send);
+      visitNewSend(node.send, elements.getType(node));
     }
   }
 
   visitSendSet(SendSet node) {
     Operator op = node.assignmentOperator;
     if (node.isSuperCall) {
       Element element = elements[node];
       if (element == null) return generateSuperNoSuchMethodSend(node);
       HInstruction target = new HStatic(element);
       HInstruction context = localsHandler.readThis();
@@ skipping 1386 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;
   }
 }