Allow self-referencing closures.

frog/leg/ssa/builder.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 Interceptors {
   Compiler compiler;
   Interceptors(Compiler this.compiler);
 
   SourceString mapOperatorToMethodName(Operator op) {
     String name = op.source.stringValue;
@@ skipping 198 matching lines @@
     }    
   }
 
   void startFunction(FunctionElement function,
                      FunctionExpression node) {
 
     ClosureTranslator translator =
         new ClosureTranslator(builder.compiler, builder.elements);
     closureData = translator.translate(node);
 
-    if (closureData.thisElement !== null &&
-        isAccessedDirectly(closureData.thisElement)) {
-      HInstruction thisInstruction = new HThis();
-      updateLocal(closureData.thisElement, thisInstruction);
-      builder.add(thisInstruction);
-    }
-
     FunctionParameters params = function.computeParameters(builder.compiler);
     params.forEachParameter((Element element) {
       HParameterValue parameter = new HParameterValue(element);
       builder.add(parameter);
       // Note that for constructors [element] could be a field-element which we
       // treat as if it was a local.
       directLocals[element] = parameter;
     });
 
     enterScope(node);
 
     // If the freeVariableMapping is not empty, then this function was a
     // nested closure that captures variables. Redirect the captured
     // variables to fields in the closure.
     closureData.freeVariableMapping.forEach((Element from, Element to) {
       redirectElement(from, to);
     });
+    if (closureData.isClosure()) {
+      // Inside closure redirect references to itself to [:this:].
+      HInstruction thisInstruction = new HThis();
+      builder.add(thisInstruction);
+      updateLocal(closureData.closureElement, thisInstruction);
+    } else if (function.isInstanceMember() ||
+               function.isGenerativeConstructor()) {
+      HInstruction thisInstruction = new HThis();
+      builder.add(thisInstruction);
+      updateLocal(closureData.thisElement, thisInstruction);
+    }
   }
 
   /**
    * Returns true if the [For] loop declares a variable that is boxed.
    */
   bool isForLoopDeclaringBoxedLoopVariable(Loop node) {
     For forNode = node.asFor();
     if (forNode === null) return false;
     if (forNode.initializer === null) return false;
     VariableDefinitions definitions =
@@ skipping 628 matching lines @@
 
     conditionBlock.addSuccessor(loopEntryBlock);  // The back-edge.
     loopEntryBlock.postProcessLoopHeader();
 
     endLoop(loopEntryBlock, conditionBlock);
   }
 
   visitFunctionExpression(FunctionExpression node) {
     ClosureData nestedClosureData = closureDataCache[node];
     assert(nestedClosureData !== null);
-    assert(nestedClosureData.globalizedClosureElement !== null);
-    ClassElement globalizedClosureElement =
-        nestedClosureData.globalizedClosureElement;
+    assert(nestedClosureData.closureClassElement !== null);
+    ClassElement closureClassElement =
+        nestedClosureData.closureClassElement;
     FunctionElement callElement = nestedClosureData.callElement;
     compiler.enqueue(new WorkItem.toCodegen(callElement, elements));
-    compiler.registerInstantiatedClass(globalizedClosureElement);
-    assert(globalizedClosureElement.members.isEmpty());
+    compiler.registerInstantiatedClass(closureClassElement);
+    assert(closureClassElement.members.isEmpty());
 
     List<HInstruction> capturedVariables = <HInstruction>[];
-    for (Element member in globalizedClosureElement.backendMembers) {
+    for (Element member in closureClassElement.backendMembers) {
       // The backendMembers also contains the call method(s). We are only
       // interested in the fields.
       if (member.kind == ElementKind.FIELD) {
         Element capturedLocal = nestedClosureData.capturedFieldMapping[member];
         assert(capturedLocal != null);
         capturedVariables.add(localsHandler.readLocal(capturedLocal));
       }
     }
 
-    push(new HForeignNew(globalizedClosureElement, capturedVariables));
+    push(new HForeignNew(closureClassElement, capturedVariables));
   }
 
   visitIdentifier(Identifier node) {
     if (node.isThis()) {
       stack.add(localsHandler.readThis());
     } else {
       compiler.internalError("SsaBuilder.visitIdentifier on non-this",
                              node: node);
     }
   }
@@ skipping 475 matching lines @@
 
   visitClosureSend(Send node) {
     Selector selector = elements.getSelector(node);
     assert(node.receiver === null);
     Element element = elements[node];
     HInstruction closureTarget;
     if (element === null) {
       visit(node.selector);
       closureTarget = pop();
     } else {
-      assert(element.kind === ElementKind.VARIABLE ||
-             element.kind === ElementKind.PARAMETER);
+      assert(Elements.isLocal(element));
       closureTarget = localsHandler.readLocal(element);
     }
     var inputs = <HInstruction>[];
     inputs.add(closureTarget);
     addDynamicSendArgumentsToList(node, inputs);
     push(new HInvokeClosure(selector, inputs));
   }
 
   visitForeignSend(Send node) {
     Identifier selector = node.selector;
@@ skipping 525 matching lines @@
   }
 
   visitCatchBlock(CatchBlock node) {
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 }