Rename members and named constructors.

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() =>
@@ skipping 15 matching lines @@
   final TypeAnnotation typeNode;
   final bool requiresVar;
   DeclarationTypePlaceholder(this.typeNode, this.requiresVar);
 }
 
 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) {}
 
+  visitSuperSend(Send node) {
+    collector.tryMakeMemberPlaceholder(node.selector);
+  }
+
+  visitDynamicSend(Send node) {
+    final element = elements[node];
+    if (element === null || !element.isErroneous()) {
+      collector.tryMakeMemberPlaceholder(node.selector);
+    }
+  }
+
   visitClosureSend(Send node) {
     final element = elements[node];
     if (element !== null) {
       collector.tryMakeLocalPlaceholder(element, node.selector);
     }
   }
 
   visitGetterSend(Send node) {
     final element = elements[node];
     // element === null means dynamic property access.
-    if (element === null) return;
-    if (element.isPrefix()) {
+    if (element === null) {
+      collector.tryMakeMemberPlaceholder(node.selector);
+    } else if (element.isPrefix()) {
       // Node is prefix part in case of source 'lib.somesetter = 5;'
       collector.makeNullPlaceholder(node);
     } else if (Elements.isStaticOrTopLevel(element)) {
       // Unqualified or prefixed top level or static.
       collector.makeElementPlaceholder(node.selector, element);
     } else if (!element.isTopLevel()) {
-      // May get FunctionExpression here in selector
-      // in case of A(int this.f());
-      if (node.selector is Identifier) {
-        collector.tryMakeLocalPlaceholder(element, node.selector);
+      if (element.isInstanceMember()) {
+        collector.tryMakeMemberPlaceholder(node.selector);
       } else {
-        assert(node.selector is FunctionExpression);
+        // May get FunctionExpression here in selector
+        // in case of A(int this.f());
+        if (node.selector is Identifier) {
+          collector.tryMakeLocalPlaceholder(element, node.selector);
+        } else {
+          assert(node.selector is FunctionExpression);
+        }
       }
     }
   }
 
   visitStaticSend(Send node) {
     final element = elements[node];
-    if (element.isConstructor() || element.isFactoryConstructor()) 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) {
+        NamedArgument named = argument.asNamedArgument();
+        if (named === null) continue;
+        Identifier name = named.name;
+        String nameAsString = name.source.slowToString();
+        for (final parameter in optionalParameters) {
+          if (parameter.kind === ElementKind.FIELD_PARAMETER) {
+            if (parameter.name.slowToString() == nameAsString) {
+              collector.tryMakeMemberPlaceholder(name);
+              break;
+            }
+          }
+        }
+      }
+      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);
     }
   }
 
   internalError(String reason, [Node node]) {
     collector.internalError(reason, node);
   }
 }
 
 class PlaceholderCollector extends AbstractVisitor {
   final Compiler compiler;
+  final Set<String> fixedMemberNames; // member names which cannot be renamed.
   final Set<Node> nullNodes;  // Nodes that should not be in output.
   final Set<Identifier> unresolvedNodes;
   final Map<Element, Set<Node>> 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;
   TreeElements treeElements;
 
   LibraryElement get coreLibrary => compiler.coreLibrary;
   FunctionElement get entryFunction => compiler.mainApp.find(Compiler.MAIN);
 
-  PlaceholderCollector(this.compiler) :
+  PlaceholderCollector(this.compiler, this.fixedMemberNames) :
       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>();
+      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()
         == element.name.slowToString()) {
       makeElementPlaceholder(nameNode, element);
     }
   }
@@ skipping 31 matching lines @@
         FunctionElement implementingFactory = element.defaultImplementation;
         tryMakeConstructorNamePlaceholder(implementingFactory.cachedNode,
             element.getEnclosingClass());
       }
     } 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 {
+        assert(node.name.asSend().isOperator);
+      }
     }
   }
 
   void collectFieldDeclarationPlaceholders(
       Element element, VariableDefinitions node) {
+    Node fieldNode = element.parseNode(compiler);
+    Identifier name =
+        fieldNode is Identifier ? fieldNode : fieldNode.asSend().selector;
     if (Elements.isStaticOrTopLevel(element)) {
-      Node fieldNode = element.parseNode(compiler);
-      if (fieldNode is Identifier) {
-        makeElementPlaceholder(fieldNode, element);
-      } else if (fieldNode is SendSet) {
-        makeElementPlaceholder(fieldNode.selector, element);
-      } else {
-        unreachable();
-      }
+      makeElementPlaceholder(name, element);
+    } else if (Elements.isInstanceField(element)) {
+      tryMakeMemberPlaceholder(name);
     }
     makeVarDeclarationTypePlaceholder(node);
   }
 
   void collect(Element element, TreeElements elements) {
     treeElements = elements;
     Node elementNode;
     if (element is FunctionElement) {
       currentElement = element;
       elementNode = currentElement.parseNode(compiler);
@@ skipping 31 matching lines @@
     // should not matter if they are local vars.
     if (node.source.isPrivate()) return;
     if (element.isParameter() && isOptionalParameter()) {
       functionScopes.putIfAbsent(currentElement, () => new FunctionScope())
           .registerParameter(node);
     } else if (Elements.isLocal(element)) {
       makeLocalPlaceholder(node);
     }
   }
 
+  void tryMakeMemberPlaceholder(Identifier node) {
+    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, Type type) {
     makeElementPlaceholder(node, type.element);
   }
 
   void makeOmitDeclarationTypePlaceholder(TypeAnnotation type) {
     if (type === null) return;
     declarationTypePlaceholders.add(
         new DeclarationTypePlaceholder(type, false));
   }
 
@@ skipping 70 matching lines @@
   }
 
   visitSendSet(SendSet send) {
     final element = treeElements[send];
     if (element !== null) {
       if (Elements.isStaticOrTopLevel(element)) {
         assert(element is VariableElement || element.isSetter());
         makeElementPlaceholder(send.selector, element);
       } else {
         assert(send.selector is Identifier);
-        tryMakeLocalPlaceholder(element, send.selector);
+        if (Elements.isInstanceField(element)) {
+          tryMakeMemberPlaceholder(send.selector);
+        } else {
+          tryMakeLocalPlaceholder(element, send.selector);
+        }
+      }
+    } else {
+      if (send.receiver !== null) {
+        tryMakeMemberPlaceholder(send.selector);
       }
     }
     send.visitChildren(this);
   }
 
   visitIdentifier(Identifier identifier) {
     if (identifier.source.isPrivate()) makePrivateIdentifier(identifier);
   }
 
   static bool isPlainTypeName(TypeAnnotation typeAnnotation) {
@@ skipping 59 matching lines @@
         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.
         if (definitionElement === null) continue;
         if (definition is Send) {
           // May get FunctionExpression here in definition.selector
           // in case of A(int this.f());
           if (definition.selector is Identifier) {
-            tryMakeLocalPlaceholder(definitionElement, definition.selector);
+            if (definitionElement.kind === ElementKind.FIELD_PARAMETER) {
+              tryMakeMemberPlaceholder(definition.selector);
+            } else {
+              tryMakeLocalPlaceholder(definitionElement, definition.selector);
+            }
           } else {
             assert(definition.selector is FunctionExpression);
+            if (definitionElement.kind === ElementKind.FIELD_PARAMETER) {
+              tryMakeMemberPlaceholder(
+                  definition.selector.asFunctionExpression().name);
+            }
           }
         } else if (definition is Identifier) {
           tryMakeLocalPlaceholder(definitionElement, definition);
         } else if (definition is FunctionExpression) {
           // Skip, it will be processed in visitFunctionExpression.
         } else {
           internalError('Unexpected definition structure $definition');
         }
       }
     }
@@ skipping 83 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }