[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 416 matching lines @@
     } else {
       typeDeclarationElement = currentElement.getEnclosingClass();
     }
     if (typeDeclarationElement !== null && isPlainTypeName(node)
         && tryResolveAndCollectTypeVariable(
                typeDeclarationElement, node.typeName)) {
       return;
     }
     // We call [resolveReturnType] to allow having 'void'.
     final type = compiler.resolveReturnType(currentElement, node);
+    bool hasPrefix = false;
     if (type is InterfaceType || type is TypedefType) {
       Node target = node.typeName;
-      bool hasPrefix = false;
       if (node.typeName is Send) {
         final send = node.typeName.asSend();
         Identifier receiver = send.receiver;
         Identifier selector = send.selector;
         Element potentialPrefix =
             currentElement.getLibrary().findLocal(receiver.source);
         if (potentialPrefix !== null && potentialPrefix.isPrefix()) {
           // prefix.Class case.
           hasPrefix = true;
         } else {
@@ skipping 16 matching lines @@
           typeElement === dynamicTypeElement)) {
         makeNullPlaceholder(node.typeName.receiver);
       } else {
         if (typeElement !== dynamicTypeElement) {
           makeTypePlaceholder(target, type);
         } else {
           if (!isDynamicType(node)) makeUnresolvedPlaceholder(target);
         }
       }
     }
-    node.visitChildren(this);
+    // Trying to differentiate new A.foo() and lib.A cases. In the latter case
+    // we don't want to go deeper into typeName.
+    if (hasPrefix) {
+      // 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);
+    } else {
+      node.visitChildren(this);
+    }
   }
 
   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 121 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }