Introduce HLocalValue and HLocalGet/Set.

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 399 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, box);
       builder.add(lookup);
       return lookup;
     } else {
       assert(isUsedInTry(element));
-      HParameterValue parameter = getActivationParameter(element);
-      HInstruction variable = new HFieldGet.fromActivation(parameter);
+      HLocalValue local = getLocal(element);
+      HInstruction variable = new HLocalGet(element, local);
       builder.add(variable);
       return variable;
     }
   }
 
   HType cachedTypeOfThis;
 
   HInstruction readThis() {
     HInstruction res = readLocal(closureData.thisElement);
     if (res.guaranteedType === null) {
       if (cachedTypeOfThis === null) {
         assert(closureData.isClosure());
         Element element = closureData.thisElement;
         ClassElement cls = element.enclosingElement.enclosingElement;
         Type type = cls.computeType(builder.compiler);
         cachedTypeOfThis = new HBoundedType.nonNull(type);
       }
       res.guaranteedType = cachedTypeOfThis;
     }
     return res;
   }
 
-  HParameterValue getActivationParameter(Element element) {
+  HLocalValue getLocal(Element element) {
     // If the element is a parameter, we already have a
     // HParameterValue for it. We cannot create another one because
     // it could then have another name than the real parameter. And
     // the other one would not know it is just a copy of the real
     // parameter.
     if (element.isParameter()) return builder.parameters[element];
 
     return builder.activationVariables.putIfAbsent(element, () {
-      HParameterValue parameter = new HParameterValue(element);
-      builder.graph.entry.addAtExit(parameter);
-      return parameter;
+      HLocalValue local = new HLocalValue(element);
+      builder.graph.entry.addAtExit(local);
+      return local;
     });
   }
 
   /**
    * 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) {
     assert(!isStoredInClosureField(element));
     if (isAccessedDirectly(element)) {
       directLocals[element] = 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
       // be accessed directly.
       assert(redirect.enclosingElement.kind == ElementKind.VARIABLE);
       HInstruction box = readLocal(redirect.enclosingElement);
       builder.add(new HFieldSet(redirect, box, value));
     } else {
       assert(isUsedInTry(element));
-      HParameterValue parameter = getActivationParameter(element);
-      builder.add(new HFieldSet.fromActivation(parameter, value));
+      HLocalValue local = getLocal(element);
+      builder.add(new HLocalSet(element, local, 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 2972 matching lines @@
   void visitNodeList(NodeList node) {
      node.visitChildren(this);
   }
 
   HInstruction concat(HInstruction left, HInstruction right) {
     HInstruction instruction = new HStringConcat(left, right, diagnosticNode);
     builder.add(instruction);
     return instruction;
   }
 }