Fix the case of function field via this initialization.

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 SendVisitor extends ResolvedVisitor {
   final PlaceholderCollector collector;
 
   SendVisitor(this.collector, TreeElements elements) : super(elements);
 
   visitSuperSend(Send node) {}
@@ skipping 74 matching lines @@
         makeTypePlaceholder(nameNode, enclosingClass.type);
       }
       // 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.isThis());
-              tryMakePrivateIdentifier(send.selector.asIdentifier());
+              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 {
+                internalError('Unreachable case');
+              }
             } else {
               assert(definition is Identifier);
             }
           }
         } else {
           assert(parameter is NodeList);
           // We don't have to rename privates in optionals.
         }
       }
     } else if (element.isTopLevel()) {
@@ skipping 13 matching lines @@
 
   void collectFieldDeclarationPlaceholders(Element element, Node 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 {
-          assert(false); // Unreachable.
+          internalError('Unreachable case');
         }
       }
     }
   }
   
   void collect(Element element, TreeElements elements) {
     treeElements = elements;
     Node elementNode;
     if (element is FunctionElement) {
       currentElement = element;
@@ skipping 126 matching lines @@
     }
     // TODO(antonm): is there a better way to detect unresolved types?
     if (type !== compiler.types.dynamicType) {
       makeTypePlaceholder(target, type);
     } else {
       if (!isDynamicType(node)) makeUnresolvedPlaceholder(target);
     }
     node.visitChildren(this);
   }
 }