Capture this.

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 148 matching lines @@
 
 /**
  * Keeps track of locals (including parameters and phis) when building. The
  * 'this' reference is treated as parameter and hence handled by this class,
  * too.
  */
 class LocalsHandler {
   // The values of locals that can be directly accessed (without redirections
   // to boxes or closure-fields).
   Map<Element, HInstruction> directLocals;
-  HInstruction thisDefinition;
   Map<Element, Element> redirectionMapping;
   SsaBuilder builder;
   ClosureData closureData;
 
   LocalsHandler(this.builder)
       : directLocals = new Map<Element, HInstruction>(),
         redirectionMapping = new Map<Element, Element>();
 
   /**
    * Creates a new [LocalsHandler] based on [other]. We only need to
    * copy the [directLocals], since the other fields can be shared
    * throughout the AST visit.
    */
   LocalsHandler.from(LocalsHandler other)
       : directLocals = new Map<Element, HInstruction>.from(other.directLocals),
         redirectionMapping = other.redirectionMapping,
         builder = other.builder,
-        thisDefinition = other.thisDefinition,
         closureData = other.closureData;
 
   void startFunction(FunctionElement function,
                      FunctionExpression node) {
 
     ClosureTranslator translator =
         new ClosureTranslator(builder.compiler, builder.elements);
     closureData = translator.translate(node);
 
     if (function.isInstanceMember()) {
-      thisDefinition = new HThis();
-      builder.add(thisDefinition);
+      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;
     });
@@ skipping 89 matching lines @@
    */
   HInstruction readLocal(Element element) {
     if (isAccessedDirectly(element)) {
       if (directLocals[element] == null) {
         builder.compiler.internalError(
             "Could not find value", node: element.parseNode(builder.compiler));
       }
       return directLocals[element];
     } else if (isStoredInClosureField(element)) {
       Element redirect = redirectionMapping[element];
-      // We must not use the [LocalsHandler.thisDefinition] since that could
+      // We must not use the [LocalsHandler.readThis()] since that could
       // point to a captured this which would be stored in a closure-field
       // itself.
       HInstruction receiver = new HThis();
       builder.add(receiver);
       HInstruction fieldGet = new HFieldGet(redirect, receiver);
       builder.add(fieldGet);
       return fieldGet;
     } else if (isBoxed(element)) {
       Element redirect = redirectionMapping[element];
       // In the function that declares the captured variable the box is
       // accessed as direct local. Inside the nested closure the box is
       // accessed through a closure-field.
       // Calling [readLocal] makes sure we generate the correct code to get
       // the box.
       assert(redirect.enclosingElement.kind == ElementKind.VARIABLE);
       HInstruction box = readLocal(redirect.enclosingElement);
       HInstruction lookup = new HFieldGet(redirect, box);
       builder.add(lookup);
       return lookup;
     } else {
       assert(isUsedInTry(element));
       HInstruction variable = new HFieldGet.fromActivation(element);
       builder.add(variable);
       return variable;
     }
   }
 
+  HInstruction readThis() {
+    return readLocal(closureData.thisElement);
+  }
+
   /**
    * Sets the [element] to [value]. If the element is boxed or stored in a
    * closure then the method generates code to set the value.
    */
   void updateLocal(Element element, HInstruction value) {
     // TODO(floitsch): replace the following if with an assert.
     if (element is !VariableElement) {
       builder.compiler.internalError("expected a variable",
                                      node: element.parseNode(builder.compiler));
     }
 
     if (isAccessedDirectly(element)) {
       directLocals[element] = value;
     } else if (isStoredInClosureField(element)) {
       Element redirect = redirectionMapping[element];
-      // We must not use the [LocalsHandler.thisDefinition] since that could
+      // We must not use the [LocalsHandler.readThis()] since that could
       // point to a captured this which would be stored in a closure-field
       // itself.
       HInstruction receiver = new HThis();
       builder.add(receiver);
       builder.add(new HFieldSet(redirect, receiver, value));
     } else if (isBoxed(element)) {
       Element redirect = redirectionMapping[element];
       // The box itself could be captured, or be local. A local variable that
       // is captured will be boxed, but the box itself will be a local.
       // Inside the closure the box is stored in a closure-field and cannot
@@ skipping 401 matching lines @@
         assert(capturedLocal != null);
         capturedVariables.add(localsHandler.readLocal(capturedLocal));
       }
     }
 
     push(new HForeignNew(globalizedClosureElement, capturedVariables));
   }
 
   visitIdentifier(Identifier node) {
     if (node.isThis()) {
-      if (localsHandler.thisDefinition === null) {
-        compiler.unimplemented("Ssa.visitIdentifier.", node: node);
-      }
-      stack.add(localsHandler.thisDefinition);
+      stack.add(localsHandler.readThis());
     } else {
       compiler.internalError("SsaBuilder.visitIdentifier on non-this",
                              node: node);
     }
   }
 
   visitIf(If node) {
     // Add the condition to the current block.
     bool hasElse = node.hasElsePart;
     visit(node.condition);
@@ skipping 203 matching lines @@
   void generateGetter(Send send, Element element) {
     Selector selector = elements.getSelector(send);
     if (Elements.isStaticOrTopLevelField(element)) {
       push(new HStatic(element));
       if (element.kind == ElementKind.GETTER) {
         push(new HInvokeStatic(selector, <HInstruction>[pop()]));
       }
     } else if (element === null || Elements.isInstanceField(element)) {
       HInstruction receiver;
       if (send.receiver == null) {
-        receiver = localsHandler.thisDefinition;
-        if (receiver === null) {
-          compiler.unimplemented("SsaBuilder.generateGetter.", node: send);
-        }
+        receiver = localsHandler.readThis();
       } else {
         visit(send.receiver);
         receiver = pop();
       }
       SourceString getterName = send.selector.asIdentifier().source;
       Element staticInterceptor = null;
       if (methodInterceptionEnabled) {
         staticInterceptor = interceptors.getStaticGetInterceptor(getterName);
       }
       if (staticInterceptor != null) {
@@ skipping 19 matching lines @@
         add(target);
         add(new HInvokeStatic(selector, <HInstruction>[target, value]));
       } else {
         add(new HStaticStore(element, value));
       }
       stack.add(value);
     } else if (element === null || Elements.isInstanceField(element)) {
       SourceString dartSetterName = send.selector.asIdentifier().source;
       HInstruction receiver;
       if (send.receiver == null) {
-        receiver = localsHandler.thisDefinition;
-        if (receiver === null) {
-          compiler.unimplemented("Ssa.generateSetter.", node: send);
-        }
+        receiver = localsHandler.readThis();
       } else {
         visit(send.receiver);
         receiver = pop();
       }
       add(new HInvokeDynamicSetter(
           selector, null, dartSetterName, receiver, value));
       stack.add(value);
     } else {
       localsHandler.updateLocal(element, value);
       stack.add(value);
@@ skipping 171 matching lines @@
       add(target);
       inputs.add(target);
       visit(node.receiver);
       inputs.add(pop());
       addGenericSendArgumentsToList(node.arguments, inputs);
       push(new HInvokeInterceptor(selector, dartMethodName, false, inputs));
       return;
     }
 
     if (node.receiver === null) {
-      HThis receiver = localsHandler.thisDefinition;
-      if (receiver === null) {
-        compiler.unimplemented("Ssa.visitDynamicSend.", node: node);
-      }
+      HThis receiver = localsHandler.readThis;
       inputs.add(receiver);
     } else {
       visit(node.receiver);
       inputs.add(pop());
     }
 
     addDynamicSendArgumentsToList(node, inputs);
 
     // The first entry in the inputs list is the receiver.
     push(new HInvokeDynamicMethod(selector, dartMethodName, inputs));
@@ skipping 64 matching lines @@
         break;
       default:
         throw "Unknown foreign: ${node.selector}";
     }
   }
 
   visitSuperSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     HStatic target = new HStatic(element);
-    HThis context = localsHandler.thisDefinition;
-    if (context === null) {
-      compiler.unimplemented("Ssa.visitSuperSend without thisDefinition.",
-                             node: node);
-    }
+    HThis context = localsHandler.readThis;
     add(target);
     var inputs = <HInstruction>[target, context];
     addStaticSendArgumentsToList(node, element, inputs);
     push(new HInvokeSuper(selector, inputs));
   }
 
   visitStaticSend(Send node) {
     Selector selector = elements.getSelector(node);
     Element element = elements[node];
     HStatic target = new HStatic(element);
@@ skipping 431 matching lines @@
     if (exception.type != null) {
       compiler.unimplemented('SsaBuilder catch with type', node: node);
     }
     visit(node.block);
   }
 
   visitTypedef(Typedef node) {
     compiler.unimplemented('SsaBuilder.visitTypedef', node: node);
   }
 }