Translate constructors without bad references.

pkg/compiler/lib/src/cps_ir/cps_ir_builder_visitor.dart

 // Copyright (c) 2013, 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 dart2js.ir_builder;
 
 /**
  * This task iterates through all resolved elements and builds [ir.Node]s. The
  * nodes are stored in the [nodes] map and accessible through [hasIr] and
  * [getIr].
@@ skipping 176 matching lines @@
     signature.orderedOptionalParameters.forEach((ParameterElement element) {
       defaults.add(getConstantForVariable(element));
     });
 
     List<ir.Initializer> initializers;
     if (element.isSynthesized) {
       assert(element is ConstructorElement);
       return irBuilder.makeConstructorDefinition(const <ConstantExpression>[],
           const <ir.Initializer>[]);
     } else if (element.isGenerativeConstructor) {
-      initializers = buildConstructorInitializers(node, element);
-      visit(node.body);
-      return irBuilder.makeConstructorDefinition(defaults, initializers);
+      if (element.isExternal) {
+        return irBuilder.makeAbstractConstructorDefinition(defaults);
+      } else {
+        initializers = buildConstructorInitializers(node, element);
+        visit(node.body);
+        return irBuilder.makeConstructorDefinition(defaults, initializers);
+      }
     } else {
       visit(node.body);
       return irBuilder.makeFunctionDefinition(defaults);
     }
   }
 
   List<ir.Initializer> buildConstructorInitializers(
       ast.FunctionExpression function, ConstructorElement element) {
     List<ir.Initializer> result = <ir.Initializer>[];
     FunctionSignature signature = element.functionSignature;
 
     void tryAddInitializingFormal(ParameterElement parameterElement) {
       if (parameterElement.isInitializingFormal) {
         InitializingFormalElement initializingFormal = parameterElement;
-        withBuilder(irBuilder.makeDelimitedBuilder(), () {
+        withBuilder(irBuilder.makeInitializerBuilder(), () {
           ir.Primitive value = irBuilder.buildLocalGet(parameterElement);
           result.add(irBuilder.makeFieldInitializer(
               initializingFormal.fieldElement,
               irBuilder.makeRunnableBody(value)));
         });
       }
     }
 
     // TODO(sigurdm): Preserve initializing formals as initializing formals.
     signature.orderedForEachParameter(tryAddInitializingFormal);
 
     if (function.initializers == null) return result;
     bool explicitSuperInitializer = false;
     for(ast.Node initializer in function.initializers) {
       if (initializer is ast.SendSet) {
         // Field initializer.
         FieldElement field = elements[initializer];
-        withBuilder(irBuilder.makeDelimitedBuilder(), () {
+        withBuilder(irBuilder.makeInitializerBuilder(), () {
           ir.Primitive value = visit(initializer.arguments.head);
           ir.RunnableBody body = irBuilder.makeRunnableBody(value);
           result.add(irBuilder.makeFieldInitializer(field, body));
         });
       } else if (initializer is ast.Send) {
         // Super or this initializer.
         if (ast.Initializers.isConstructorRedirect(initializer)) {
           giveup(initializer, "constructor redirect (this) initializer");
         }
         ConstructorElement constructor = elements[initializer].implementation;
         Selector selector = elements.getSelector(initializer);
         List<ir.RunnableBody> arguments =
             initializer.arguments.mapToList((ast.Node argument) {
-          return withBuilder(irBuilder.makeDelimitedBuilder(), () {
+          return withBuilder(irBuilder.makeInitializerBuilder(), () {
             ir.Primitive value = visit(argument);
             return irBuilder.makeRunnableBody(value);
           });
         });
         result.add(irBuilder.makeSuperInitializer(constructor,
                                                   arguments,
                                                   selector));
         explicitSuperInitializer = true;
       } else {
         compiler.internalError(initializer,
@@ skipping 1684 matching lines @@
   SourceInformation buildCall(ast.Node node) {
     return new PositionSourceInformation(
         new TokenSourceLocation(sourceFile, node.getBeginToken(), name));
   }
 
   @override
   SourceInformationBuilder forContext(AstElement element) {
     return new PositionSourceInformationBuilder(element);
   }
 }