anchor.diff:          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);
  
positive.code: 
    internalError(String reason, [Node node]) {
      collector.internalError(reason, node);
    }
  
    tryRenamePrivateSelector(Send node) {
      collector.tryMakePrivateIdentifier(node.selector.asIdentifier());
    }
  }
  
  
negative.code: 
    SendVisitor(this.collector, TreeElements elements) : super(elements);
  
    visitDynamicSend(Send node) {}
    visitSuperSend(Send node) {}
    visitOperatorSend(Send node) {}
    visitForeignSend(Send node) {}
  