[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) {

[Anton Muhin, 2012/10/30 15:23:44]

it looks like as of now in all the call sites you pass a constant as
isRedirectingCall.

I would suggest to add named constructor ConstructorPlace.redirecting and
corresponding helper method, that would make code easier to read imho

[Roman, 2012/10/30 15:52:09]

Done.

+    assert(isRedirectingCall != (type != null));
+  }
 }
 
 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.makeConstructorPlaceholder(node.selector, element, null, true);

[Anton Muhin, 2012/10/30 15:23:44]

my original understanding of constructor placeholders was a collection of
constructor declarations to rename.

Now it includes invocations too.

Should they go into the same place?

Cannot we add redirecting constructor invocations into member renames where they
apparently should belong?

[Roman, 2012/10/30 15:52:09]

1) We cannot add declarations to one placeholder type and invocations to
another, that way it would be quite difficult to rename them consistently.
2) Originally both constructor invocations and declarations made their way into
constructor placeholders, invocations - from visitNewExpression. This CL makes
constructor placeholders for redirecting invocations.

+    } 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.makeConstructorPlaceholder(
+            node.selector, element, null, true);
       }
       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:

[Anton Muhin, 2012/10/30 15:23:44]

cannot this comment go away now?

[Roman, 2012/10/30 15:52:09]

Done.

       // 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, false);
     } 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 131 matching lines @@
       return currentLocalPlaceholders.putIfAbsent(name, () {
         LocalPlaceholder localPlaceholder = new LocalPlaceholder(name);
         currentFunctionScope.localPlaceholders.add(localPlaceholder);
         return localPlaceholder;
       });
     }
 
     getLocalPlaceholder().nodes.add(identifier);
   }
 
-  void makeConstructorPlaceholder(Node node, Element element, DartType type) {
+  void makeConstructorPlaceholder(Node node, Element element, DartType type,
+      bool isRedirecting) {
     constructorPlaceholders
         .putIfAbsent(element, () => <ConstructorPlaceholder>[])
-            .add(new ConstructorPlaceholder(node, type));
+            .add(new ConstructorPlaceholder(node, type, isRedirecting));
   }
 
   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.
 
   visitNewExpression(NewExpression node) {
     Send send = node.send;
     InterfaceType type = treeElements.getType(node);
     assert(type != null);
     Element constructor = treeElements[send];
     assert(constructor != null);
     assert(send.receiver == null);
     if (constructor is !ErroneousElement) {
-      makeConstructorPlaceholder(node.send.selector, constructor, type);
+      makeConstructorPlaceholder(node.send.selector, constructor, type, false);
       // TODO(smok): Should this be in visitNamedArgument?
       // Field names can be exposed as names of optional arguments, e.g.
       // class C {
       //   final field;
       //   C([this.field]);
       // }
       // Do not forget to rename them as well.
       Link<Element> optionalParameters =
           constructor.functionSignature.optionalParameters;
       for (final argument in send.argumentsNode) {
@@ skipping 234 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }