Allow self-referencing closures.

frog/leg/ssa/closure.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 ClosureFieldElement extends Element {
   ClosureFieldElement(SourceString name, ClassElement enclosing)
       : super(name, ElementKind.FIELD, enclosing);
 
   bool isInstanceMember() => true;
   bool isAssignable() => false;
 
   String toString() => "ClosureFieldElement($name)";
 }
 
 // The box-element for a scope, and the captured variables that need to be
 // stored in the box.
 class ClosureScope {
   Element boxElement;
   Map<Element, Element> capturedVariableMapping;
 
   ClosureScope(this.boxElement, this.capturedVariableMapping);
 }
 
 class ClosureData {
-  // The globalizedClosureElement will be null for methods that are not local
+  // The closure's element before any translation. Will be null for methods.
+  final FunctionElement closureElement;
+  // The closureClassElement will be null for methods that are not local
   // closures.
-  final ClassElement globalizedClosureElement;
+  final ClassElement closureClassElement;
   // The callElement will be null for methods that are not local closures.
   final FunctionElement callElement;
   // The [thisElement] makes handling 'this' easier by treating it like any
   // other argument. It is only set for instance-members.
   final Element thisElement;
 
   // Maps free locals, arguments and function elements to their captured
   // copies.
   final Map<Element, Element> freeVariableMapping;
   // Maps closure-fields to their captured elements. This is somehow the inverse
   // mapping of [freeVariableMapping], but whereas [freeVariableMapping] does
   // not deal with boxes, here we map instance-fields (which might represent
   // boxes) to their boxElement.
   final Map<Element, Element> capturedFieldMapping;
 
   // Maps scopes ([Loop] and [FunctionExpression] nodes) to their
   // [ClosureScope] which contains their box and the
   // captured variables that are stored in the box.
   // This map will be empty if the method/closure of this [ClosureData] does not
   // contain any nested closure.
   final Map<Node, ClosureScope> capturingScopes;
 
   final Set<Element> usedVariablesInTry;
 
-  ClosureData(this.globalizedClosureElement, this.callElement, this.thisElement)
+  ClosureData(this.closureElement,
+              this.closureClassElement,
+              this.callElement,
+              this.thisElement)
       : this.freeVariableMapping = new Map<Element, Element>(),
         this.capturedFieldMapping = new Map<Element, Element>(),
         this.capturingScopes = new Map<Node, ClosureScope>(),
         this.usedVariablesInTry = new Set<Element>();
+
+  bool isClosure() => closureElement !== null;
 }
 
 Map<Node, ClosureData> _closureDataCache;
 Map<Node, ClosureData> get closureDataCache() {
   if (_closureDataCache === null) {
     _closureDataCache = new HashMap<Node, ClosureData>();
   }
   return _closureDataCache;
 }
 
@@ skipping 62 matching lines @@
           // The variable has not been boxed.
           fieldCaptures.add(updatedElement);
         } else {
           // A boxed element.
           freeVariableMapping[fromElement] = updatedElement;
           Element boxElement = updatedElement.enclosingElement;
           assert(boxElement.kind == ElementKind.VARIABLE);
           fieldCaptures.add(boxElement);
         }
       });
-      ClassElement closureElement = data.globalizedClosureElement;
+      ClassElement closureElement = data.closureClassElement;
       assert(closureElement != null || fieldCaptures.isEmpty());
       for (Element boxElement in fieldCaptures) {
         Element fieldElement =
             new ClosureFieldElement(boxElement.name, closureElement);
         closureElement.backendMembers =
             closureElement.backendMembers.prepend(fieldElement);
         data.capturedFieldMapping[fieldElement] = boxElement;
         freeVariableMapping[boxElement] = fieldElement;
       }
     }
@@ skipping 109 matching lines @@
                                  globalizedElement);
     globalizedElement.backendMembers =
         const EmptyLink<Element>().prepend(callElement);
     globalizedElement.isResolved = true;
     ClassElement objectClass =
         compiler.coreLibrary.find(const SourceString('Object'));
     globalizedElement.supertype = new SimpleType(Types.OBJECT, objectClass);
     // The nested function's 'this' is the same as the one for the outer
     // function. It could be [null] if we are inside a static method.
     Element thisElement = closureData.thisElement;
-    return new ClosureData(globalizedElement, callElement, thisElement);
+    return new ClosureData(element, globalizedElement,
+                           callElement, thisElement);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     FunctionElement element = elements[node];
     bool isClosure = (closureData !== null);
 
     if (isClosure) closures.add(node);
 
     bool oldInsideClosure = insideClosure;
     FunctionElement oldFunctionElement = currentFunctionElement;
@@ skipping 16 matching lines @@
         // declared in the GENERATIVE_CONSTRUCTOR. Including the 'this'.
         Element thisEnclosingElement = element;
         if (element.kind === ElementKind.GENERATIVE_CONSTRUCTOR_BODY) {
           ConstructorBodyElement body = element;
           thisEnclosingElement = body.constructor;
         }
         thisElement = new Element(const SourceString("this"),
                                   ElementKind.PARAMETER,
                                   thisEnclosingElement);
       }
-      closureData = new ClosureData(null, null, thisElement);
+      closureData = new ClosureData(null, null, null, thisElement);
     }
     scopeVariables = new List<Element>();
 
     // TODO(floitsch): a named function is visible from inside itself. Add
     // the element to the block.
 
     // We have to declare the implicit 'this' parameter.
     if (!insideClosure && closureData.thisElement !== null) {
       declareLocal(closureData.thisElement);
     }
@@ skipping 10 matching lines @@
     // Restore old values.
     scopeVariables = oldScopeVariables;
     insideClosure = oldInsideClosure;
     closureData = oldClosureData;
     currentFunctionElement = oldFunctionElement;
 
     // Mark all free variables as captured and use them in the outer function.
     List<Element> freeVariables =
         savedClosureData.freeVariableMapping.getKeys();
     assert(freeVariables.isEmpty() || savedInsideClosure);
-    for (Element element in freeVariables) {
-      assert(capturedVariableMapping[element] == null ||
-             capturedVariableMapping[element] == element);
-      capturedVariableMapping[element] = element;
-      useLocal(element);
+    for (Element freeElement in freeVariables) {
+      assert(capturedVariableMapping[freeElement] == null ||
+             capturedVariableMapping[freeElement] == freeElement);
+      capturedVariableMapping[freeElement] = freeElement;
+      useLocal(freeElement);
     }
 
     // If we just visited a closure we declare it. This is not always correct
     // since some closures are used as expressions and don't introduce any
     // name. But in this case the added local is simply not used.
     if (savedInsideClosure) {
-      declareLocal(elements[node]);
+      declareLocal(element);
     }
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     inTryCatchOrFinally = true;
     node.visitChildren(this);
     inTryCatchOrFinally = false;
   }
 }