[dart2dart] Support cosntructor redirects.

lib/compiler/implementation/dart_backend/placeholder_collector.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 dart_backend;
 
 class LocalPlaceholder {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
   int get hashCode => identifier.hashCode;
   String toString() =>
       'local_placeholder[id($identifier), nodes($nodes)]';
 }
 
 class FunctionScope {
   final Set<String> parameterIdentifiers;
   final Set<LocalPlaceholder> localPlaceholders;
   FunctionScope()
       : parameterIdentifiers = new Set<String>(),
       localPlaceholders = new Set<LocalPlaceholder>();
   void registerParameter(Identifier node) {
     parameterIdentifiers.add(node.source.slowToString());
   }
 }
 
 class ConstructorPlaceholder {
   final Node node;
   final DartType type;
-  ConstructorPlaceholder(this.node, this.type);
+  final bool isRedirectingCall;
+  ConstructorPlaceholder(this.node, this.type)
+      : this.isRedirectingCall = false;
+  ConstructorPlaceholder.redirectingCall(this.node)
+      : this.type = null, this.isRedirectingCall = true;
 }
 
 class DeclarationTypePlaceholder {
   final TypeAnnotation typeNode;
   final bool requiresVar;
   DeclarationTypePlaceholder(this.typeNode, this.requiresVar);
 }
 
 class SendVisitor extends ResolvedVisitor {
   final PlaceholderCollector collector;
 
   get compiler => collector.compiler;
 
   SendVisitor(this.collector, TreeElements elements) : super(elements);
 
   visitOperatorSend(Send node) {}
   visitForeignSend(Send node) {}
 
   visitSuperSend(Send node) {
-    collector.tryMakeMemberPlaceholder(node.selector);
+    Element element = elements[node];
+    if (element != null && element.isConstructor()) {
+      collector.makeRedirectingConstructorPlaceholder(node.selector, element);
+    } else {
+      collector.tryMakeMemberPlaceholder(node.selector);
+    }
   }
 
   visitDynamicSend(Send node) {
     final element = elements[node];
     if (element == null || !element.isErroneous()) {
       collector.tryMakeMemberPlaceholder(node.selector);
     }
   }
 
   visitClosureSend(Send node) {
@@ skipping 30 matching lines @@
       }
     }
   }
 
   visitStaticSend(Send node) {
     final element = elements[node];
     if (Elements.isUnresolved(element)
         || identical(element, compiler.assertMethod)) {
       return;
     }
-    // TODO(smok): We should never go inside this IF, check?
     if (element.isConstructor() || element.isFactoryConstructor()) {
       // Rename named constructor in redirection position:
       // class C { C.named(); C.redirecting() : this.named(); }
-      // TODO(smok): Fix redirecting constructors.
       if (node.receiver is Identifier
           && node.receiver.asIdentifier().isThis()) {
         assert(node.selector is Identifier);
-        collector.tryMakeMemberPlaceholder(node.selector);
+        collector.makeRedirectingConstructorPlaceholder(node.selector, element);
       }
       return;
     }
     collector.makeElementPlaceholder(node.selector, element);
     // Another ugly case: <lib prefix>.<top level> is represented as
     // receiver: lib prefix, selector: top level.
     if (element.isTopLevel() && node.receiver != null) {
       assert(elements[node.receiver].isPrefix());
       // Hack: putting null into map overrides receiver of original node.
       collector.makeNullPlaceholder(node.receiver);
@@ skipping 32 matching lines @@
       nullNodes = new Set<Node>(),
       unresolvedNodes = new Set<Identifier>(),
       elementNodes = new Map<Element, Set<Node>>(),
       functionScopes = new Map<FunctionElement, FunctionScope>(),
       privateNodes = new Map<LibraryElement, Set<Identifier>>(),
       declarationTypePlaceholders = new List<DeclarationTypePlaceholder>(),
       memberPlaceholders = new Map<String, Set<Identifier>>(),
       constructorPlaceholders =
           new Map<Element, List<ConstructorPlaceholder>>();
 
-  void tryMakeConstructorPlaceholder(
-      FunctionExpression constructor, FunctionElement constructorElement) {
-    DartType type = constructorElement.getEnclosingClass().type.asRaw();
-    makeConstructorPlaceholder(constructor.name, constructorElement, type);
-  }
-
   void collectFunctionDeclarationPlaceholders(
       FunctionElement element, FunctionExpression node) {
     if (element.isGenerativeConstructor() || element.isFactoryConstructor()) {
-      // Two complicated cases for class/interface renaming:
-      // 1) class which implements constructors of other interfaces, but not
-      //    implements interfaces themselves:
-      //      0.dart: class C { I(); }
-      //      1.dart and 2.dart: interface I default C { I(); }
-      //    now we have to duplicate our I() constructor in C class with
-      //    proper names.
-      // 2) (even worse for us):
-      //      0.dart: class C { C(); }
-      //      1.dart: interface C default p0.C { C(); }
-      //    the second case is just a bug now.
-      tryMakeConstructorPlaceholder(node, element);
+      DartType type = element.getEnclosingClass().type.asRaw();
+      makeConstructorPlaceholder(node.name, element, type);
     } else if (Elements.isStaticOrTopLevel(element)) {
       // Note: this code should only rename private identifiers for class'
       // fields/getters/setters/methods.  Top-level identifiers are renamed
       // just to escape conflicts and that should be enough as we shouldn't
       // be able to resolve private identifiers for other libraries.
       makeElementPlaceholder(node.name, element);
     } else if (element.isMember()) {
       if (node.name is Identifier) {
         tryMakeMemberPlaceholder(node.name);
       } else {
@@ skipping 132 matching lines @@
         LocalPlaceholder localPlaceholder = new LocalPlaceholder(name);
         currentFunctionScope.localPlaceholders.add(localPlaceholder);
         return localPlaceholder;
       });
     }
 
     getLocalPlaceholder().nodes.add(identifier);
   }
 
   void makeConstructorPlaceholder(Node node, Element element, DartType type) {
+    assert(type != null);
     constructorPlaceholders
         .putIfAbsent(element, () => <ConstructorPlaceholder>[])
             .add(new ConstructorPlaceholder(node, type));
   }
+  void makeRedirectingConstructorPlaceholder(Node node, Element element) {
+    constructorPlaceholders
+        .putIfAbsent(element, () => <ConstructorPlaceholder>[])
+            .add(new ConstructorPlaceholder.redirectingCall(node));
+  }
 
   void internalError(String reason, {Node node}) {
     compiler.cancel(reason, node: node);
   }
 
   void unreachable() { internalError('Unreachable case'); }
 
   visit(Node node) => (node == null) ? null : node.accept(this);
 
   visitNode(Node node) { node.visitChildren(this); }  // We must go deeper.
@@ skipping 254 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }