Implement redirecting constructors.

dart/sdk/lib/_internal/compiler/implementation/resolution/members.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.
 
 part of resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 1852 matching lines @@
       visit(link.head);
     }
   }
 
   visitOperator(Operator node) {
     unimplemented(node, 'operator');
   }
 
   visitReturn(Return node) {
     if (node.isRedirectingFactoryBody) {
-      useElement(node.expression, resolveRedirectingFactory(node));
+      handleRedirectingFactoryBody(node);
     } else {
       visit(node.expression);
     }
   }
 
+  void handleRedirectingFactoryBody(Return node) {
+    Element redirectionTarget = resolveRedirectingFactory(node);
+    var type = mapping.getType(node.expression);
+    if (type is InterfaceType && !type.arguments.isEmpty) {
+      unimplemented(node.expression, 'type arguments on redirecting factory');
+    }
+    useElement(node.expression, redirectionTarget);
+    assert(invariant(node, enclosingElement.isFactoryConstructor()));
+    FunctionElement constructor = enclosingElement;
+    if (constructor.modifiers.isConst() &&
+        !redirectionTarget.modifiers.isConst()) {
+      error(node, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
+    }
+    // TODO(ahe): Check that this doesn't lead to a cycle.  For now,
+    // just make sure that the redirection target isn't itself a
+    // redirecting factory.
+    { // This entire block is temporary code per the above TODO.
+      FunctionElement targetImplementation = redirectionTarget.implementation;
+      FunctionExpression function = targetImplementation.parseNode(compiler);
+      if (function.body != null && function.body.asReturn() != null
+          && function.body.asReturn().isRedirectingFactoryBody) {
+        unimplemented(node.expression, 'redirecing to redirecting factory');
+      }
+    }
+    constructor.defaultImplementation = redirectionTarget;
+    world.registerStaticUse(redirectionTarget);
+  }
+
   visitThrow(Throw node) {
     if (!inCatchBlock && node.expression == null) {
       error(node, MessageKind.THROW_WITHOUT_EXPRESSION);
     }
     visit(node.expression);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     visit(node.type);
     VariableDefinitionsVisitor visitor =
@@ skipping 1144 matching lines @@
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }