[dart2dart] Don't go inside TypeAnnotation.typeName, otherwise in "new lib.A()" expression

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.
 
 class LocalPlaceholder {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
   int hashCode() => identifier.hashCode();
   String toString() =>
@@ skipping 72 matching lines @@
       }
     }
   }
 
   visitStaticSend(Send node) {
     final element = elements[node];
     if (Elements.isUnresolved(element) || element === compiler.assertMethod) {
       return;
     }
     if (element.isConstructor() || element.isFactoryConstructor()) {
-      // Rename named constructor in redirection position:
-      // class C { C.named(); C.redirecting() : this.named(); }
-      if (node.receiver is Identifier
-          && node.receiver.asIdentifier().isThis()) {
-        assert(node.selector is Identifier);
-        collector.tryMakeMemberPlaceholder(node.selector);
-      }
       // 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.
       FunctionElement functionElement = element;
       Link<Element> optionalParameters =
           functionElement.functionSignature.optionalParameters;
       for (final argument in node.argumentsNode) {
@@ skipping 356 matching lines @@
           typeElement === dynamicTypeElement)) {
         makeNullPlaceholder(node.typeName.receiver);
       } else {
         if (typeElement !== dynamicTypeElement) {
           makeTypePlaceholder(target, type);
         } else {
           if (!isDynamicType(node)) makeUnresolvedPlaceholder(target);
         }
       }
     }
-    node.visitChildren(this);
+    // Visit only type arguments, otherwise in case of lib.Class type annotation
+    // typeName is Send and we go to visitGetterSend, as a result "Class" is
+    // added to member placeholders.
+    visit(node.typeArguments);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     // Collect only local placeholders.
     for (Node definition in node.definitions.nodes) {
       Element definitionElement = treeElements[definition];
       // definitionElement may be null if we're inside variable definitions
       // of a function that is a parameter of another function.
       // TODO(smok): Fix this when resolver correctly deals with
       // such cases.
@@ skipping 36 matching lines @@
       if (topmostEnclosingFunction === null) {
         topmostEnclosingFunction = element;
       }
       if (element !== currentElement) {
         if (node.name !== null) {
           assert(node.name is Identifier);
           tryMakeLocalPlaceholder(element, node.name);
         }
       }
     }
-    node.visitChildren(this);
+    visit(node.modifiers);

[Roman, 2012/10/02 14:57:10]

I know you don't like calling explicitly visit() for children, but it is cleaner
this way. As a side effect we don't rename constructors as member identifiers.

+    // We don't want to visit Send for function name, it appears as
+    // getter send and we end up renaming constructor as member identifier.
+    if (node.name is Identifier) {
+      visitIdentifier(node.name);
+    }
+    visit(node.returnType);
+    visit(node.parameters);
+    visit(node.initializers);
+    visit(node.body);
     // Make sure we don't omit return type of methods which names are
     // identifiers, because the following works fine:
     // int interface() => 1;
     // But omitting 'int' makes VM unhappy.
     // TODO(smok): Remove it when http://dartbug.com/5278 is fixed.
     if (node.name === null || !isKeyword(node.name.asIdentifier())) {
       makeOmitDeclarationTypePlaceholder(node.returnType);
     }
     collectFunctionParameters(node.parameters);
   }
@@ skipping 64 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }