[dart2dart] Make sure we collect element placeholders only for identifiers by ensuring

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 125 matching lines @@
     collector.internalError(reason, node);
   }
 }
 
 class PlaceholderCollector extends Visitor {
   final Compiler compiler;
   final Set<String> fixedMemberNames; // member names which cannot be renamed.
   final Map<Element, ElementAst> elementAsts;
   final Set<Node> nullNodes;  // Nodes that should not be in output.
   final Set<Identifier> unresolvedNodes;
-  final Map<Element, Set<Node>> elementNodes;
+  final Map<Element, Set<Identifier>> elementNodes;
   final Map<FunctionElement, FunctionScope> functionScopes;
   final Map<LibraryElement, Set<Identifier>> privateNodes;
   final List<DeclarationTypePlaceholder> declarationTypePlaceholders;
   final Map<String, Set<Identifier>> memberPlaceholders;
   Map<String, LocalPlaceholder> currentLocalPlaceholders;
   Element currentElement;
   FunctionElement topmostEnclosingFunction;
   TreeElements treeElements;
 
   LibraryElement get coreLibrary => compiler.coreLibrary;
   FunctionElement get entryFunction => compiler.mainApp.find(Compiler.MAIN);
 
   get currentFunctionScope => functionScopes.putIfAbsent(
       topmostEnclosingFunction, () => new FunctionScope());
 
   PlaceholderCollector(this.compiler, this.fixedMemberNames, this.elementAsts) :
       nullNodes = new Set<Node>(),
       unresolvedNodes = new Set<Identifier>(),
-      elementNodes = new Map<Element, Set<Node>>(),
+      elementNodes = new Map<Element, Set<Identifier>>(),
       functionScopes = new Map<FunctionElement, FunctionScope>(),
       privateNodes = new Map<LibraryElement, Set<Identifier>>(),
       declarationTypePlaceholders = new List<DeclarationTypePlaceholder>(),
       memberPlaceholders = new Map<String, Set<Identifier>>();
 
   void tryMakeConstructorNamePlaceholder(
       FunctionExpression constructor, ClassElement element) {
     Node nameNode = constructor.name;
     if (nameNode is Send) nameNode = nameNode.receiver;
     if (nameNode.asIdentifier().token.slowToString()
@@ skipping 112 matching lines @@
     assert(node !== null);
     if (node.source.isPrivate()) return;
     if (node is Operator) return;
     final identifier = node.source.slowToString();
     if (fixedMemberNames.contains(identifier)) return;
     memberPlaceholders.putIfAbsent(
         identifier, () => new Set<Identifier>()).add(node);
   }
 
   void makeTypePlaceholder(Node node, DartType type) {
+    if (node is Send) {
+      // Prefix.
+      assert(node.receiver is Identifier);
+      assert(node.selector is Identifier);
+      makeNullPlaceholder(node.receiver);

[Anton Muhin, 2012/10/04 15:34:37]

is it okay if we use a name with a prefix from platform lib?

[Roman, 2012/10/04 16:05:59]

We never use existing prefixes in the renamer anyway. For platform library
elements we just generate a string 'p.Map', for example.
But now I'm thinking that ideally we should probably record a prefix and in
renamer decide whether we want to keep that prefix or strip it completely. But
that would require refactoring of how we currently import things.

[Anton Muhin, 2012/10/04 16:07:14]

Fair.

On 2012/10/04 16:05:59, Roman wrote:

+      node = node.selector;
+    }
     makeElementPlaceholder(node, type.element);
   }
 
   void makeOmitDeclarationTypePlaceholder(TypeAnnotation type) {
     if (type === null) return;
     declarationTypePlaceholders.add(
         new DeclarationTypePlaceholder(type, false));
   }
 
   void makeVarDeclarationTypePlaceholder(VariableDefinitions node) {
     // TODO(smok): Maybe instead of calling this method and
     // makeDeclaratioTypePlaceholder have type declaration placeholder
     // collector logic in visitVariableDefinitions when resolver becomes better
     // and/or catch syntax changes.
     if (node.type === null) return;
     Element definitionElement = treeElements[node.definitions.nodes.head];
     bool requiresVar = !node.modifiers.isFinalOrConst();
     declarationTypePlaceholders.add(
         new DeclarationTypePlaceholder(node.type, requiresVar));
   }
 
   void makeNullPlaceholder(Node node) {
     assert(node is Identifier || node is Send);
     nullNodes.add(node);
   }
 
-  void makeElementPlaceholder(Node node, Element element) {
+  void makeElementPlaceholder(Identifier node, Element element) {
     assert(element !== null);
     if (element === entryFunction) return;
     if (element.getLibrary() === coreLibrary) return;
     if (element.getLibrary().isPlatformLibrary && !element.isTopLevel()) {
       return;
     }
     if (element == compiler.types.dynamicType.element) {
       internalError(
           'Should never make element placeholder for dynamic type element',
           node);
     }
-    elementNodes.putIfAbsent(element, () => new Set<Node>()).add(node);
+    elementNodes.putIfAbsent(element, () => new Set<Identifier>()).add(node);
   }
 
   void makePrivateIdentifier(Identifier node) {
     assert(node !== null);
     privateNodes.putIfAbsent(
         currentElement.getLibrary(), () => new Set<Identifier>()).add(node);
   }
 
   void makeUnresolvedPlaceholder(Node node) {
     unresolvedNodes.add(node);
@@ skipping 112 matching lines @@
       // Corner case: dart:core type with a prefix.
       // Most probably there are some additional problems with
       // coreLibPrefix.topLevels.
       Element typeElement = type.element;
       Element dynamicTypeElement = compiler.types.dynamicType.element;
       if (hasPrefix &&
           (typeElement.getLibrary() === coreLibrary ||
           typeElement === dynamicTypeElement)) {
         makeNullPlaceholder(node.typeName.asSend().receiver);
       } else {
+        if (hasPrefix) {
+          assert(node.typeName is Send);
+          assert(node.typeName.receiver is Identifier);
+          assert(node.typeName.selector is Identifier);
+          makeNullPlaceholder(node.typeName.receiver);

[Anton Muhin, 2012/10/04 15:34:37]

ditto

+        }
         if (typeElement !== dynamicTypeElement) {
           makeTypePlaceholder(target, type);
         } else {
           if (!isDynamicType(node)) makeUnresolvedPlaceholder(target);
         }
       }
     }
     // 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) {
@@ skipping 138 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }