Capture this.

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
   // closures.
   final ClassElement globalizedClosureElement;
   // 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)
+  ClosureData(this.globalizedClosureElement, 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>();
 }
 
 Map<Node, ClosureData> _closureDataCache;
 Map<Node, ClosureData> get closureDataCache() {
   if (_closureDataCache === null) {
     _closureDataCache = new HashMap<Node, ClosureData>();
@@ skipping 120 matching lines @@
       assert(element !== null);
       declareLocal(element);
     }
     // We still need to visit the right-hand sides of the init-assignments.
     // Simply visit all children. We will visit the locals again and make them
     // used, but that should not be a problem.
     node.visitChildren(this);
   }
 
   visitIdentifier(Identifier node) {
-    // TODO(floitsch): handle 'this'.
-    if (node.isThis() && insideClosure) {
-      compiler.unimplemented("ClosureAnalyzer.visitIdentifier this-capture",
-                             node: node);
+    if (node.isThis()) {
+      useLocal(closureData.thisElement);
     }
     node.visitChildren(this);
   }
 
   visitSend(Send node) {
     Element element = elements[node];
     if (Elements.isLocal(element)) {
       useLocal(element);
-    } else if (element === null && node.receiver === null) {
-      if (insideClosure) {
-        compiler.unimplemented("ClosureTranslator.visitSend this-capture");
-      }
+    } else if (node.receiver === null &&
+               Elements.isInstanceSend(node, elements)) {
+      useLocal(closureData.thisElement);
     }
     node.visitChildren(this);
   }
 
   // If variables that are declared in the [node] scope are captured and need
   // to be boxed create a box-element and update the [capturingScopes] in the
   // current [closureData].
   // The boxed variables are updated in the [capturedVariableMapping].
   void attachCapturedScopeVariables(Node node) {
     Element box = null;
@@ skipping 40 matching lines @@
     FunctionElement callElement =
         new FunctionElement.from(Namer.CLOSURE_INVOCATION_NAME,
                                  element,
                                  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);
-    return new ClosureData(globalizedElement, callElement);
+    // 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);
   }
 
   visitFunctionExpression(FunctionExpression node) {
+    FunctionElement element = elements[node];
     bool isClosure = (closureData !== null);
 
     if (isClosure) closures.add(node);
 
     bool oldInsideClosure = insideClosure;
     FunctionElement oldFunctionElement = currentFunctionElement;
     ClosureData oldClosureData = closureData;
     List<Element> oldScopeVariables = scopeVariables;
 
 
     insideClosure = isClosure;
     currentFunctionElement = elements[node];
-    closureData = insideClosure ?
-                  globalizeClosure(node) :
-                  new ClosureData(null, null);
+    if (insideClosure) {
+      closureData = globalizeClosure(node);
+    } else {
+      Element thisElement = null;
+      // TODO(floitsch): we should not need to look for generative constructors.
+      // At the moment we store only one ClosureData for both the factory and
+      // the body.
+      if (element.isInstanceMember() ||
+          element.kind == ElementKind.GENERATIVE_CONSTRUCTOR) {
+        // TODO(floitsch): currently all variables are considered to be
+        // 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);
+    }
     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);
+    }
+
     node.visitChildren(this);
 
     attachCapturedScopeVariables(node);
 
     closureDataCache[node] = closureData;
 
     ClosureData savedClosureData = closureData;
     bool savedInsideClosure = insideClosure;
 
     // Restore old values.
@@ skipping 21 matching lines @@
     }
   }
 
   visitTryStatement(TryStatement node) {
     // TODO(ngeoffray): implement finer grain state.
     inTryCatchOrFinally = true;
     node.visitChildren(this);
     inTryCatchOrFinally = false;
   }
 }