Land Alexander's change that throw on abstract class instantiations.

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 101 matching lines @@
   }
 
   Element getExceptionUnwrapper() {
     return compiler.findHelper(const SourceString('unwrapException'));
   }
 
   Element getThrowRuntimeError() {
     return compiler.findHelper(const SourceString('throwRuntimeError'));
   }
 
+  Element getThrowAbstractClassInstantiationError() {
+    return compiler.findHelper(
+        const SourceString('throwAbstractClassInstantiationError'));
+  }
+
   Element getClosureConverter() {
     return compiler.findHelper(const SourceString('convertDartClosureToJS'));
   }
 
   Element getTraceFromException() {
     return compiler.findHelper(const SourceString('getTraceFromException'));
   }
 
   Element getEqualsInterceptor() {
     return compiler.findHelper(const SourceString('eq'));
@@ skipping 2798 matching lines @@
       // 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));
       });
     }
 
     HType elementType = computeType(constructor);
     HInstruction newInstance = new HInvokeStatic(inputs, elementType);
     pushWithPosition(newInstance, node);
 
@@ skipping 54 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);
   }
 
-  void generateRuntimeError(Node node, String message) {
+  void generateError(Node node, String message, Element helper) {
     DartString messageObject = new DartString.literal(message);
     Constant messageConstant =
         constantSystem.createString(messageObject, node);
     HInstruction errorMessage = graph.addConstant(messageConstant);
-    Element helper = interceptors.getThrowRuntimeError();
     pushInvokeHelper1(helper, errorMessage);
   }
 
+  void generateRuntimeError(Node node, String message) {
+    generateError(node, message, interceptors.getThrowRuntimeError());
+  }
+
+  void generateAbstractClassInstantiationError(Node node, String message) {
+    generateError(node,
+                  message,
+                  interceptors.getThrowAbstractClassInstantiationError());
+  }
+
   void generateThrowNoSuchMethod(Node diagnosticNode,
                                  String methodName,
                                  [Link<Node> argumentNodes,
                                   List<HInstruction> argumentValues]) {
     Element helper =
         compiler.findHelper(const SourceString('throwNoSuchMethod'));
     Constant receiverConstant =
         constantSystem.createString(new DartString.empty(), diagnosticNode);
     HInstruction receiver = graph.addConstant(receiverConstant);
     DartString dartString = new DartString.literal(methodName);
@@ skipping 1430 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;
   }
 }