Process private identifier in visitIdentifier.

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 implements Hashable {
   final String identifier;
   final Set<Node> nodes;
   LocalPlaceholder(this.identifier) : nodes = new Set<Node>();
   int hashCode() => identifier.hashCode();
   String toString() =>
       'local_placeholder[id($identifier), nodes($nodes)]';
 }
 
 class SendVisitor extends ResolvedVisitor {
   final PlaceholderCollector collector;
 
   SendVisitor(this.collector, TreeElements elements) : super(elements);
 
+  visitDynamicSend(Send node) {}
   visitSuperSend(Send node) {}
   visitOperatorSend(Send node) {}
   visitForeignSend(Send node) {}
 
   visitClosureSend(Send node) {
     final element = elements[node];
     if (element !== null) {
       collector.tryMakeLocalPlaceholder(element, node.selector);
     }
   }
 
-  visitDynamicSend(Send node) {
-    tryRenamePrivateSelector(node);
-  }
-
   visitGetterSend(Send node) {
     final element = elements[node];
     // element === null means dynamic property access.
-    if (element === null || element.isMember()) {
-      tryRenamePrivateSelector(node);
-      return;
-    }
+    if (element === null) return;
     // We don't want to rename non top-level element access
     // unless it's a local variable.
     if (element.isPrefix()) {
       // Node is prefix part in case of source 'lib.somesetter = 5;'
       collector.makeNullPlaceholder(node);
       return;
     } else if (!element.isTopLevel()) {
       // May get FunctionExpression here in selector
       // in case of A(int this.f());
       if (node.selector is Identifier) {
@@ skipping 23 matching lines @@
     if (node.receiver !== null) {
       assert(elements[node.receiver].isPrefix());
       // Hack: putting null into map overrides receiver of original node.
       collector.makeNullPlaceholder(node.receiver);
     }
   }
 
   internalError(String reason, [Node node]) {
     collector.internalError(reason, node);
   }
-
-  tryRenamePrivateSelector(Send node) {
-    collector.tryMakePrivateIdentifier(node.selector.asIdentifier());
-  }
 }
 
 class PlaceholderCollector extends AbstractVisitor {
   final Compiler compiler;
   final Set<Node> nullNodes;  // Nodes that should not be in output.
   final Set<Identifier> unresolvedNodes;
   final Map<Element, Set<Node>> elementNodes;
   final Map<FunctionElement, Set<LocalPlaceholder>> localPlaceholders;
   final Map<LibraryElement, Set<Identifier>> privateNodes;
   Map<String, LocalPlaceholder> currentLocalPlaceholders;
@@ skipping 47 matching lines @@
       // Example:
       // interface I { I(); }
       // class C implements I { C(); }  don't rename this case.
       // OR I.named() inside C, rename first part.
       if (element.defaultImplementation !== null
           && element.defaultImplementation !== element) {
         FunctionElement implementingFactory = element.defaultImplementation;
         tryMakeConstructorNamePlaceholder(implementingFactory.cachedNode,
             element.getEnclosingClass());
       }
-
-      // Process Ctor(this._field) correctly.
-      for (Node parameter in node.parameters) {
-        VariableDefinitions definitions = parameter.asVariableDefinitions();
-        if (definitions !== null) {
-          for (Node definition in definitions.definitions) {
-            Send send = definition.asSend();
-            if (send !== null) {
-              assert(send.receiver is Identifier);
-              assert(send.receiver.asIdentifier().isThis());
-              if (send.selector is Identifier) {
-                tryMakePrivateIdentifier(send.selector.asIdentifier());
-              } else if (send.selector is FunctionExpression) {
-                // C(int this.f()) case where f is field of function type.
-                tryMakePrivateIdentifier(
-                    send.selector.asFunctionExpression().name.asIdentifier());
-              } else {
-                unreachable();
-              }
-            } else {
-              assert(definition is Identifier
-                  || definition is FunctionExpression);
-            }
-          }
-        } else {
-          assert(parameter is NodeList);
-          // We don't have to rename privates in optionals.
-        }
-      }
     } else if (element.isTopLevel()) {
       // 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 (node.name !== null) {
-        Identifier identifier = node.name.asIdentifier();
-        // operator <blah> names shouldn't be renamed.
-        if (identifier !== null) tryMakePrivateIdentifier(identifier);
-      }
     }
   }
 
   void collectFieldDeclarationPlaceholders(
       Element element, VariableDefinitions node) {
-    if (element.isInstanceMember()) {
-      for (Node definition in node.definitions) {
-        if (definition is Identifier) {
-          tryMakePrivateIdentifier(definition.asIdentifier());
-        } else if (definition is SendSet) {
-          tryMakePrivateIdentifier(
-              definition.asSendSet().selector.asIdentifier());
-        } else {
-          unreachable();
-        }
-      }
-    } else if (element.isTopLevel()) {
+    if (element.isTopLevel()) {
       Node fieldNode = element.parseNode(compiler);
       if (fieldNode is Identifier) {
         makeElementPlaceholder(fieldNode, element);
       } else if (fieldNode is SendSet) {
         makeElementPlaceholder(fieldNode.selector, element);
       } else {
         unreachable();
       }
     }
   }
@@ skipping 18 matching lines @@
       elementNode = currentElement.parseNode(compiler);
     } else {
       unreachable();
     }
     currentLocalPlaceholders = new Map<String, LocalPlaceholder>();
     compiler.withCurrentElement(element, () {
       elementNode.accept(this);
     });
   }
 
-  void tryMakePrivateIdentifier(Identifier identifier) {
-    if (identifier.source.isPrivate()) makePrivateIdentifier(identifier);
-  }
-
   void tryMakeLocalPlaceholder(Element element, Identifier node) {
     // TODO(smok): Maybe we should rename privates as well, their privacy
     // should not matter if they are local vars.
     if (node.source.isPrivate()) return;
     if (element.isVariable()
         || (element.isFunction() && !Elements.isStaticOrTopLevel(element))) {
       makeLocalPlaceholder(node);
     }
   }
 
@@ skipping 42 matching lines @@
     compiler.cancel(reason: 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.
 
   visitSend(Send send) {
-    Element element = treeElements[send];
-    if (element !== null && element.isErroneous()) {
-      // TODO(antonm): this is an unresolved constructor, not a dynamic send.
-      ErroneousElement erroneousElement = element;
-      compiler.cancel(reason: erroneousElement.errorMessage.toString(),
-                      node: send);
-    }
     new SendVisitor(this, treeElements).visitSend(send);
     send.visitChildren(this);
   }
 
   visitSendSet(SendSet send) {
-    if (send.selector is Identifier) {
-      tryMakePrivateIdentifier(send.selector.asIdentifier());
-    }
     final element = treeElements[send];
     if (element !== null) {
       if (element.isTopLevel()) {
         assert(element is VariableElement || element.isSetter());
         makeElementPlaceholder(send.selector, element);
       } else {
         assert(send.selector is Identifier);
         tryMakeLocalPlaceholder(element, send.selector);
       }
     }
     send.visitChildren(this);
   }
 
+  visitIdentifier(Identifier identifier) {
+    if (identifier.source.isPrivate()) makePrivateIdentifier(identifier);
+  }
+
   static bool isPlainTypeName(TypeAnnotation typeAnnotation) {
     if (typeAnnotation.typeName is !Identifier) return false;
     if (typeAnnotation.typeArguments === null) return true;
     if (typeAnnotation.typeArguments.length === 0) return true;
     return false;
   }
 
   static bool isDynamicType(TypeAnnotation typeAnnotation) {
     if (!isPlainTypeName(typeAnnotation)) return false;
     String name = typeAnnotation.typeName.asIdentifier().source.slowToString();
@@ skipping 111 matching lines @@
       visit(node.defaultClause.typeArguments);
     }
   }
 
   visitTypedef(Typedef node) {
     assert(currentElement is TypedefElement);
     makeElementPlaceholder(node.name, currentElement);
     node.visitChildren(this);
   }
 }