Introduce HLocalValue and HLocalGet/Set.

lib/compiler/implementation/ssa/nodes.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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
   R visitBitXor(HBitXor node);
@@ skipping 21 matching lines @@
   R visitInvokeDynamicGetter(HInvokeDynamicGetter node);
   R visitInvokeDynamicMethod(HInvokeDynamicMethod node);
   R visitInvokeDynamicSetter(HInvokeDynamicSetter node);
   R visitInvokeInterceptor(HInvokeInterceptor node);
   R visitInvokeStatic(HInvokeStatic node);
   R visitInvokeSuper(HInvokeSuper node);
   R visitIs(HIs node);
   R visitLess(HLess node);
   R visitLessEqual(HLessEqual node);
   R visitLiteralList(HLiteralList node);
+  R visitLocalGet(HLocalGet node);
+  R visitLocalSet(HLocalSet node);
+  R visitLocalValue(HLocalValue node);
   R visitLoopBranch(HLoopBranch node);
   R visitModulo(HModulo node);
   R visitMultiply(HMultiply node);
   R visitNegate(HNegate node);
   R visitNot(HNot node);
   R visitParameterValue(HParameterValue node);
   R visitPhi(HPhi node);
   R visitReturn(HReturn node);
   R visitShiftLeft(HShiftLeft node);
   R visitShiftRight(HShiftRight node);
@@ skipping 190 matching lines @@
 
   visitBinaryArithmetic(HBinaryArithmetic node) => visitInvokeBinary(node);
   visitBinaryBitOp(HBinaryBitOp node) => visitBinaryArithmetic(node);
   visitInvoke(HInvoke node) => visitInstruction(node);
   visitInvokeBinary(HInvokeBinary node) => visitInvokeStatic(node);
   visitInvokeDynamic(HInvokeDynamic node) => visitInvoke(node);
   visitInvokeDynamicField(HInvokeDynamicField node) => visitInvokeDynamic(node);
   visitInvokeUnary(HInvokeUnary node) => visitInvokeStatic(node);
   visitConditionalBranch(HConditionalBranch node) => visitControlFlow(node);
   visitControlFlow(HControlFlow node) => visitInstruction(node);
+  visitFieldAccess(HFieldAccess node) => visitInstruction(node);
   visitRelational(HRelational node) => visitInvokeBinary(node);
 
   visitAdd(HAdd node) => visitBinaryArithmetic(node);
   visitBitAnd(HBitAnd node) => visitBinaryBitOp(node);
   visitBitNot(HBitNot node) => visitInvokeUnary(node);
   visitBitOr(HBitOr node) => visitBinaryBitOp(node);
   visitBitXor(HBitXor node) => visitBinaryBitOp(node);
   visitBoolify(HBoolify node) => visitInstruction(node);
   visitBoundsCheck(HBoundsCheck node) => visitCheck(node);
   visitBreak(HBreak node) => visitJump(node);
   visitContinue(HContinue node) => visitJump(node);
   visitCheck(HCheck node) => visitInstruction(node);
   visitConstant(HConstant node) => visitInstruction(node);
   visitDivide(HDivide node) => visitBinaryArithmetic(node);
   visitEquals(HEquals node) => visitRelational(node);
   visitExit(HExit node) => visitControlFlow(node);
-  visitFieldGet(HFieldGet node) => visitInstruction(node);
-  visitFieldSet(HFieldSet node) => visitInstruction(node);
+  visitFieldGet(HFieldGet node) => visitFieldAccess(node);
+  visitFieldSet(HFieldSet node) => visitFieldAccess(node);
   visitForeign(HForeign node) => visitInstruction(node);
   visitForeignNew(HForeignNew node) => visitForeign(node);
   visitGoto(HGoto node) => visitControlFlow(node);
   visitGreater(HGreater node) => visitRelational(node);
   visitGreaterEqual(HGreaterEqual node) => visitRelational(node);
   visitIdentity(HIdentity node) => visitRelational(node);
   visitIf(HIf node) => visitConditionalBranch(node);
   visitIndex(HIndex node) => visitInvokeStatic(node);
   visitIndexAssign(HIndexAssign node) => visitInvokeStatic(node);
   visitIntegerCheck(HIntegerCheck node) => visitCheck(node);
   visitInvokeClosure(HInvokeClosure node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicMethod(HInvokeDynamicMethod node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicGetter(HInvokeDynamicGetter node)
       => visitInvokeDynamicField(node);
   visitInvokeDynamicSetter(HInvokeDynamicSetter node)
       => visitInvokeDynamicField(node);
   visitInvokeInterceptor(HInvokeInterceptor node)
       => visitInvokeStatic(node);
   visitInvokeStatic(HInvokeStatic node) => visitInvoke(node);
   visitInvokeSuper(HInvokeSuper node) => visitInvoke(node);
   visitJump(HJump node) => visitControlFlow(node);
   visitLess(HLess node) => visitRelational(node);
   visitLessEqual(HLessEqual node) => visitRelational(node);
   visitLiteralList(HLiteralList node) => visitInstruction(node);
+  visitLocalGet(HLocalGet node) => visitFieldGet(node);
+  visitLocalSet(HLocalSet node) => visitFieldSet(node);
+  visitLocalValue(HLocalValue node) => visitInstruction(node);
   visitLoopBranch(HLoopBranch node) => visitConditionalBranch(node);
   visitModulo(HModulo node) => visitBinaryArithmetic(node);
   visitNegate(HNegate node) => visitInvokeUnary(node);
   visitNot(HNot node) => visitInstruction(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
-  visitParameterValue(HParameterValue node) => visitInstruction(node);
+  visitParameterValue(HParameterValue node) => visitLocalValue(node);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftRight(HShiftRight node) => visitBinaryBitOp(node);
   visitShiftLeft(HShiftLeft node) => visitBinaryBitOp(node);
   visitSubtract(HSubtract node) => visitBinaryArithmetic(node);
   visitSwitch(HSwitch node) => visitControlFlow(node);
   visitStatic(HStatic node) => visitInstruction(node);
   visitStaticStore(HStaticStore node) => visitInstruction(node);
   visitStringConcat(HStringConcat node) => visitInstruction(node);
   visitThis(HThis node) => visitParameterValue(node);
   visitThrow(HThrow node) => visitControlFlow(node);
@@ skipping 967 matching lines @@
   HFieldSet(Element element, HInstruction receiver, HInstruction value)
       : super(element, <HInstruction>[receiver, value]);
   HFieldSet.fromActivation(receiver, value)
       : this(null, receiver, value);
 
   HInstruction get receiver() => inputs.length == 2 ? inputs[0] : null;
   HInstruction get value() => inputs.length == 2 ? inputs[1] : inputs[0];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   void prepareGvn() {
-    // TODO(ngeoffray): implement more fine grain side effects.
+    // TODO(ngeoffray): implement more fine grained side effects.
     setAllSideEffects();
   }
 
   bool isStatement() => true;
 }
 
+class HLocalGet extends HFieldGet {
+  HLocalGet(Element element, HLocalValue local) : super(element, local);
+
+  accept(HVisitor visitor) => visitor.visitLocalGet(this);
+
+  HLocalValue get local() => inputs[0];
+
+  void prepareGvn() {
+    setUseGvn();
+    // TODO(floitsch): if the variable is not captured then it only depends
+    // on assignments to the same variable. Otherwise we need to see if the
+    // variable is mutated inside closures.
+    setDependsOnSomething();
+  }
+}
+
+class HLocalSet extends HFieldSet {
+  HLocalSet(Element element, HLocalValue local, HInstruction value)
+      : super(element, local, value);
+
+  accept(HVisitor visitor) => visitor.visitLocalSet(this);
+
+  HLocalValue get local() => inputs[0];
+
+  void prepareGvn() {
+    // TODO(floitsch): implement more fine grained side effects.
+    setAllSideEffects();
+  }
+}
+
 class HForeign extends HInstruction {
   final DartString code;
   final HType foreignType;
   HForeign(this.code, DartString declaredType, List<HInstruction> inputs)
       : foreignType = computeTypeFromDeclaredType(declaredType),
         super(inputs);
   accept(HVisitor visitor) => visitor.visitForeign(this);
 
   static HType computeTypeFromDeclaredType(DartString declaredType) {
     if (declaredType.slowToString() == 'bool') return HType.BOOLEAN;
@@ skipping 507 matching lines @@
 
   // 'Not' only works on booleans. That's what we want as input.
   HType computeDesiredTypeForInput(HInstruction input) => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitNot(this);
   int typeCode() => 18;
   bool typeEquals(other) => other is HNot;
   bool dataEquals(HInstruction other) => true;
 }
 
-class HParameterValue extends HInstruction {
-  HParameterValue(element) : super(<HInstruction>[]) {
+/**
+  * An [HLocalValue] represents a local. Unlike [HParameterValue]s its
+  * first use must be in an HLocalSet. That is, [HParameterValue]s have a
+  * value from the start, whereas [HLocalValue]s need to be initialized first.
+  */
+class HLocalValue extends HInstruction {
+  HLocalValue(element) : super(<HInstruction>[]) {
     sourceElement = element;
   }
 
   void prepareGvn() {
     assert(!hasSideEffects());
   }
-  toString() => 'parameter ${sourceElement.name}';
-  accept(HVisitor visitor) => visitor.visitParameterValue(this);
+  toString() => 'local ${sourceElement.name}';
+  accept(HVisitor visitor) => visitor.visitLocalValue(this);
   bool isCodeMotionInvariant() => true;
 }
 
+class HParameterValue extends HLocalValue {
+  HParameterValue(element) : super(element);
+
+  toString() => 'parameter ${sourceElement.name}';
+  accept(HVisitor visitor) => visitor.visitParameterValue(this);
+}
+
 class HThis extends HParameterValue {
   HThis([HType type = HType.UNKNOWN]) : super(null) {
     guaranteedType = type;
   }
   toString() => 'this';
   accept(HVisitor visitor) => visitor.visitThis(this);
 }
 
 class HPhi extends HInstruction {
   static final IS_NOT_LOGICAL_OPERATOR = 0;
@@ skipping 735 matching lines @@
   HBasicBlock get start() => expression.start;
   HBasicBlock get end() {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty());
     return statements.last().end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }