Translate constructors without bad references.

pkg/compiler/lib/src/cps_ir/cps_ir_builder.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.
 
 library dart2js.ir_builder;
 
 import '../constants/expressions.dart';
 import '../constants/values.dart' show PrimitiveConstantValue;
 import '../dart_types.dart';
 import '../dart2jslib.dart';
@@ skipping 350 matching lines @@
   /// The delimited visitor has its own compile-time environment mapping
   /// local variables to their values, which is initially a copy of the parent
   /// environment.  It has its own context for building an IR expression, so
   /// the built expression is not plugged into the parent's context.
   IrBuilder makeDelimitedBuilder() {
     return _makeInstance()
         ..state = state
         ..environment = new Environment.from(environment);
   }
 
+  /// Construct a builder for making constructor field initializers.
+  IrBuilder makeInitializerBuilder() {
+    return _makeInstance()
+        ..state = new IrBuilderDelimitedState(state.constantSystem,
+                                              state.currentElement)
+        ..environment = new Environment.from(environment);
+  }
+
   /// Construct a visitor for a recursive continuation.
   ///
   /// The recursive continuation builder has fresh parameters (i.e. SSA phis)
   /// for all the local variables in the parent, because the invocation sites
   /// of the continuation are not all known when the builder is created.  The
   /// recursive invocations will be passed values for all the local variables,
   /// which may be eliminated later if they are redundant---if they take on
   /// the same value at all invocation sites.
   IrBuilder makeRecursiveBuilder() {
     IrBuilder inner = _makeInstance()
@@ skipping 278 matching lines @@
       return new ir.FunctionDefinition.abstract(
                 element, state.functionParameters, defaults);
     } else {
       ir.RunnableBody body = makeRunnableBody();
       return new ir.FunctionDefinition(
           element, state.functionParameters, body,
           state.localConstants, defaults);
     }
   }
 
+  /// Create a constructor definition without a body, for representing
+  /// external constructors declarations.
+  ir.ConstructorDefinition makeAbstractConstructorDefinition(
+      List<ConstantExpression> defaults) {
+    FunctionElement element = state.currentElement;
+    assert(invariant(element, _root == null,
+        message: "Non-empty body for external constructor $element: $_root"));
+    assert(invariant(element, state.localConstants.isEmpty,
+        message: "Local constants for external constructor $element: "
+                 "${state.localConstants}"));
+    return new ir.ConstructorDefinition.abstract(
+        element, state.functionParameters, defaults);
+  }
+
   ir.ConstructorDefinition makeConstructorDefinition(
       List<ConstantExpression> defaults, List<ir.Initializer> initializers) {
     FunctionElement element = state.currentElement;
-    if (element.isExternal) {
-      assert(invariant(element, _root == null,
-          message: "Non-empty body for external constructor $element: $_root"));
-      assert(invariant(element, state.localConstants.isEmpty,
-          message: "Local constants for external constructor $element: "
-                   "${state.localConstants}"));
-      return new ir.ConstructorDefinition.abstract(
-                element, state.functionParameters, defaults);
-    }
     ir.RunnableBody body = makeRunnableBody();
     return new ir.ConstructorDefinition(
         element, state.functionParameters, body, initializers,
         state.localConstants, defaults);
   }
 
   /// Create a super invocation where the method name and the argument structure
   /// are defined by [selector] and the argument values are defined by
   /// [arguments].
   ir.Primitive buildSuperInvocation(Element target,
@@ skipping 1420 matching lines @@
   final Map<Local, ClosureLocation> freeVariables;
 
   ClosureEnvironment(this.selfReference, this.thisLocal, this.freeVariables);
 }
 
 class TryStatementInfo {
   final Set<LocalVariableElement> declared = new Set<LocalVariableElement>();
   final Set<LocalVariableElement> boxedOnEntry =
       new Set<LocalVariableElement>();
 }