Properly collect placeholders for function expressions.

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 132 matching lines @@
   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<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>>(),
       functionScopes = new Map<FunctionElement, FunctionScope>(),
       privateNodes = new Map<LibraryElement, Set<Identifier>>(),
       declarationTypePlaceholders = new List<DeclarationTypePlaceholder>(),
       memberPlaceholders = new Map<String, Set<Identifier>>();
 
   void tryMakeConstructorNamePlaceholder(
@@ skipping 62 matching lines @@
     Identifier name = node is Identifier ? node : node.asSend().selector;
     if (Elements.isStaticOrTopLevel(element)) {
       makeElementPlaceholder(name, element);
     } else if (Elements.isInstanceField(element)) {
       tryMakeMemberPlaceholder(name);
     }
   }
 
   void collect(Element element) {
     this.currentElement = element;
+    this.topmostEnclosingFunction = null;
     final ElementAst elementAst = elementAsts[element];
     this.treeElements = elementAst.treeElements;
     Node elementNode = elementAst.ast;
     if (element is FunctionElement) {
       collectFunctionDeclarationPlaceholders(element, elementNode);
     } else if (element is VariableListElement) {
       VariableDefinitions definitions = elementNode;
       for (Node definition in definitions.definitions) {
         final definitionElement = treeElements[definition];
         // definitionElement === null if variable is actually unused.
@@ skipping 16 matching lines @@
       for (Element parameter in function.functionSignature.optionalParameters) {
         if (parameter === element) return true;
       }
       return false;
     }
 
     // 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.isParameter() && isOptionalParameter()) {
-      functionScopes.putIfAbsent(currentElement, () => new FunctionScope())
-          .registerParameter(node);
+      currentFunctionScope.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();
@@ skipping 52 matching lines @@
 
   void makeUnresolvedPlaceholder(Node node) {
     unresolvedNodes.add(node);
   }
 
   void makeLocalPlaceholder(Identifier identifier) {
     LocalPlaceholder getLocalPlaceholder() {
       String name = identifier.source.slowToString();
       return currentLocalPlaceholders.putIfAbsent(name, () {
         LocalPlaceholder localPlaceholder = new LocalPlaceholder(name);
-        functionScopes.putIfAbsent(currentElement, () => new FunctionScope())
-            .localPlaceholders.add(localPlaceholder);
+        currentFunctionScope.localPlaceholders.add(localPlaceholder);
         return localPlaceholder;
       });
     }
 
-    assert(currentElement is FunctionElement);
     getLocalPlaceholder().nodes.add(identifier);
   }
 
   void internalError(String reason, [Node node]) {
     compiler.cancel(reason: reason, node: node);
   }
 
   void unreachable() { internalError('Unreachable case'); }
 
   visit(Node node) => (node === null) ? null : node.accept(this);
@@ skipping 83 matching lines @@
         makeTypePlaceholder(target, type);
       } else {
         if (!isDynamicType(node)) makeUnresolvedPlaceholder(target);
       }
     }
     node.visitChildren(this);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     // Collect only local placeholders.
-    if (currentElement is FunctionElement) {
-      for (Node definition in node.definitions.nodes) {
-        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) {
-            if (definitionElement.kind === ElementKind.FIELD_PARAMETER) {
-              tryMakeMemberPlaceholder(definition.selector);
-            } else {
-              tryMakeLocalPlaceholder(definitionElement, definition.selector);
-            }
+    for (Node definition in node.definitions.nodes) {
+      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) {
+          if (definitionElement.kind === ElementKind.FIELD_PARAMETER) {
+            tryMakeMemberPlaceholder(definition.selector);
           } else {
-            assert(definition.selector is FunctionExpression);
-            if (definitionElement.kind === ElementKind.FIELD_PARAMETER) {
-              tryMakeMemberPlaceholder(
-                  definition.selector.asFunctionExpression().name);
-            }
+            tryMakeLocalPlaceholder(definitionElement, definition.selector);
           }
-        } 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');
+          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');
       }
     }
     node.visitChildren(this);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     Element element = treeElements[node];
     // May get null here in case of A(int this.f());
     if (element !== null) {
       // Rename only local functions.
+      if (topmostEnclosingFunction === null) {
+        topmostEnclosingFunction = element;
+      }
       if (element !== currentElement) {
         if (node.name !== null) {
           assert(node.name is Identifier);
           tryMakeLocalPlaceholder(element, node.name);
         }
       }
     }
     node.visitChildren(this);
     makeOmitDeclarationTypePlaceholder(node.returnType);
     collectFunctionParameters(node.parameters);
@@ skipping 65 matching lines @@
 
   visitBlock(Block node) {
     for (Node statement in node.statements.nodes) {
       if (statement is VariableDefinitions) {
         makeVarDeclarationTypePlaceholder(statement);
       }
     }
     node.visitChildren(this);
   }
 }