Fix bug when a variable is used in try/catch and accessed trough HFieldGet and HFieldSet: reference…

lib/compiler/implementation/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 394 matching lines @@
       // 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.name, box);
       builder.add(lookup);
       return lookup;
     } else {
       assert(isUsedInTry(element));
-      HInstruction variable = new HFieldGet.fromActivation(element.name);
+      HParameterValue parameter = builder.activationVariables.putIfAbsent(

[kasperl, 2012/05/25 10:05:15]

This code should be refactored. There's a lot of duplication.

[ngeoffray, 2012/05/25 10:45:10]

Done.

+          element, () {
+            HParameterValue parameter = new HParameterValue(element);
+            builder.add(parameter);
+            return parameter;
+          }
+      );
+      HInstruction variable = new HFieldGet.fromActivation(parameter);
       builder.add(variable);
       return variable;
     }
   }
 
   HType cachedTypeOfThis;
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisElement);
     if (res.guaranteedType === null) {
@@ skipping 28 matching lines @@
       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
       // be accessed directly.
       assert(redirect.enclosingElement.kind == ElementKind.VARIABLE);
       HInstruction box = readLocal(redirect.enclosingElement);
       builder.add(new HFieldSet(redirect.name, box, value));
     } else {
       assert(isUsedInTry(element));
-      builder.add(new HFieldSet.fromActivation(element.name, value));
+      HParameterValue parameter = builder.activationVariables.putIfAbsent(
+          element, () {
+            HParameterValue parameter = new HParameterValue(element);
+            builder.add(parameter);
+            return parameter;
+          }
+      );
+      builder.add(new HFieldSet.fromActivation(parameter, value));
     }
   }
 
   /**
    * This function must be called before visiting any children of the loop. In
    * particular it needs to be called before executing the initializers.
    *
    * The [LocalsHandler] will make the boxes and updates at the right moment.
    * The builder just needs to call [enterLoopBody] and [enterLoopUpdates] (for
    * [For] loops) at the correct places. For phi-handling [beginLoopHeader] and
@@ skipping 297 matching lines @@
   TreeElements elements;
   final Interceptors interceptors;
   final WorkItem work;
   bool methodInterceptionEnabled;
   HGraph graph;
   LocalsHandler localsHandler;
   HInstruction rethrowableException;
 
   Map<TargetElement, JumpHandler> jumpTargets;
 
+  /**
+   * Variables stored in the current activation. These variables are
+   * being updated in try/catch blocks, and should be
+   * accessed indirectly through HFieldGet and HFieldSet.
+   */
+  Map<Element, HParameterValue> activationVariables;
+
   // We build the Ssa graph by simulating a stack machine.
   List<HInstruction> stack;
 
   // The current block to add instructions to. Might be null, if we are
   // visiting dead code.
   HBasicBlock current;
   // The most recently opened block. Has the same value as [current] while
   // the block is open, but unlike [current], it isn't cleared when the current
   // block is closed.
   HBasicBlock lastOpenedBlock;
 
   LibraryElement get currentLibrary() => work.element.getLibrary();
   Compiler get compiler() => builder.compiler;
   CodeEmitterTask get emitter() => builder.emitter;
 
   SsaBuilder(SsaBuilderTask builder, WorkItem work)
     : this.builder = builder,
       this.work = work,
       interceptors = builder.interceptors,
       methodInterceptionEnabled = true,
       elements = work.resolutionTree,
       graph = new HGraph(),
       stack = new List<HInstruction>(),
+      activationVariables = new Map<Element, HParameterValue>(),
       jumpTargets = new Map<TargetElement, JumpHandler>() {
     localsHandler = new LocalsHandler(this);
   }
 
   void disableMethodInterception() {
     assert(methodInterceptionEnabled);
     methodInterceptionEnabled = false;
   }
 
   void enableMethodInterception() {
@@ skipping 2551 matching lines @@
                                    <HInstruction>[target, input],
                                    HType.STRING));
     return builder.pop();
   }
 
   HInstruction result(Node node) {
     flushLiterals(node);
     return prefix;
   }
 }