Cleanup how we handle side effects in HInstruction and put the right flags for HIs, modulo, truncat…

sdk/lib/_internal/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.
 
 part of ssa;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 285 matching lines @@
       => visitInvokeDynamic(node);
   visitInvokeDynamicMethod(HInvokeDynamicMethod node)
       => visitInvokeDynamic(node);
   visitInvokeDynamicGetter(HInvokeDynamicGetter node)
       => visitInvokeDynamicField(node);
   visitInvokeDynamicSetter(HInvokeDynamicSetter node)
       => visitInvokeDynamicField(node);
   visitInvokeStatic(HInvokeStatic node) => visitInvoke(node);
   visitInvokeSuper(HInvokeSuper node) => visitInvoke(node);
   visitJump(HJump node) => visitControlFlow(node);
-  visitLazyStatic(HLazyStatic node) => visitStatic(node);
+  visitLazyStatic(HLazyStatic node) => visitInstruction(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);
+  visitLocalGet(HLocalGet node) => visitFieldAccess(node);
+  visitLocalSet(HLocalSet node) => visitFieldAccess(node);
   visitLocalValue(HLocalValue node) => visitInstruction(node);
   visitLoopBranch(HLoopBranch node) => visitConditionalBranch(node);
   visitNegate(HNegate node) => visitInvokeUnary(node);
   visitNot(HNot node) => visitInstruction(node);
   visitPhi(HPhi node) => visitInstruction(node);
   visitMultiply(HMultiply node) => visitBinaryArithmetic(node);
   visitParameterValue(HParameterValue node) => visitLocalValue(node);
   visitRangeConversion(HRangeConversion node) => visitCheck(node);
   visitReturn(HReturn node) => visitControlFlow(node);
   visitShiftLeft(HShiftLeft node) => visitBinaryBitOp(node);
@@ skipping 463 matching lines @@
   static const int LESS_EQUAL_TYPECODE = 24;
   static const int STATIC_TYPECODE = 25;
   static const int STATIC_STORE_TYPECODE = 26;
   static const int FIELD_GET_TYPECODE = 27;
   static const int TYPE_CONVERSION_TYPECODE = 28;
   static const int BAILOUT_TARGET_TYPECODE = 29;
   static const int INVOKE_STATIC_TYPECODE = 30;
   static const int INVOKE_DYNAMIC_GETTER_TYPECODE = 31;
   static const int INDEX_TYPECODE = 32;
 
-  HInstruction(this.inputs)
-      : id = idCounter++,
-        usedBy = <HInstruction>[];
+  HInstruction(this.inputs) : id = idCounter++, usedBy = <HInstruction>[];
 
   int get hashCode => id;
 
   bool getFlag(int position) => (flags & (1 << position)) != 0;
   void setFlag(int position) { flags |= (1 << position); }
   void clearFlag(int position) { flags &= ~(1 << position); }
 
   static int computeDependsOnFlags(int flags) => flags << FLAG_CHANGES_COUNT;
 
   int getChangesFlags() => flags & ((1 << FLAG_CHANGES_COUNT) - 1);
   int getDependsOnFlags() {
     return (flags & ((1 << FLAG_DEPENDS_ON_COUNT) - 1)) >> FLAG_CHANGES_COUNT;
   }
 
   bool hasSideEffects() => getChangesFlags() != 0;
   bool dependsOnSomething() => getDependsOnFlags() != 0;
 
-  void prepareGvn(HTypeMap types) {
-    setAllSideEffects();
-    setDependsOnSomething();
-  }
-
   void setAllSideEffects() { flags |= ((1 << FLAG_CHANGES_COUNT) - 1); }
   void clearAllSideEffects() { flags &= ~((1 << FLAG_CHANGES_COUNT) - 1); }
 
   void setDependsOnSomething() {
     int count = FLAG_DEPENDS_ON_COUNT - FLAG_CHANGES_COUNT;
     flags |= (((1 << count) - 1) << FLAG_CHANGES_COUNT);
   }
+  void clearAllDependencies() {
+    int count = FLAG_DEPENDS_ON_COUNT - FLAG_CHANGES_COUNT;
+    flags &= ~(((1 << count) - 1) << FLAG_CHANGES_COUNT);
+  }
 
   bool dependsOnStaticPropertyStore() {
     return getFlag(FLAG_DEPENDS_ON_STATIC_PROPERTY_STORE);
   }
   void setDependsOnStaticPropertyStore() {
     setFlag(FLAG_DEPENDS_ON_STATIC_PROPERTY_STORE);
   }
   void setChangesStaticProperty() { setFlag(FLAG_CHANGES_STATIC_PROPERTY); }
 
   bool dependsOnIndexStore() => getFlag(FLAG_DEPENDS_ON_INDEX_STORE);
@@ skipping 317 matching lines @@
     // [convertedType] as a bound.
     if (this.guaranteedType == convertedType) {
       return this;
     }
 
     return new HTypeConversion(convertedType, this, kind);
   }
 }
 
 class HBoolify extends HInstruction {
-  HBoolify(HInstruction value) : super(<HInstruction>[value]);
-  void prepareGvn(HTypeMap types) {
+  HBoolify(HInstruction value) : super(<HInstruction>[value]) {
     assert(!hasSideEffects());
     setUseGvn();
   }
 
   HType get guaranteedType => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitBoolify(this);
   int typeCode() => HInstruction.BOOLIFY_TYPECODE;
   bool typeEquals(other) => other is HBoolify;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
  * A [HCheck] instruction is an instruction that might do a dynamic
  * check at runtime on another instruction. To have proper instruction
  * dependencies in the graph, instructions that depend on the check
  * being done reference the [HCheck] instruction instead of the
  * instruction itself.
  */
 abstract class HCheck extends HInstruction {
-  HCheck(inputs) : super(inputs);
-  HInstruction get checkedInput => inputs[0];
-  bool isJsStatement() => true;
-  void prepareGvn(HTypeMap types) {
+  HCheck(inputs) : super(inputs) {
     assert(!hasSideEffects());
     setUseGvn();
   }
+  HInstruction get checkedInput => inputs[0];
+  bool isJsStatement() => true;
   bool canThrow() => true;
 }
 
 class HBailoutTarget extends HInstruction {
   final int state;
   bool isEnabled = true;
-  HBailoutTarget(this.state) : super(<HInstruction>[]);
-  void prepareGvn(HTypeMap types) {
+  HBailoutTarget(this.state) : super(<HInstruction>[]) {
     assert(!hasSideEffects());
     setUseGvn();
   }
 
   bool isControlFlow() => isEnabled;
   bool isJsStatement() => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitBailoutTarget(this);
   int typeCode() => HInstruction.BAILOUT_TARGET_TYPECODE;
   bool typeEquals(other) => other is HBailoutTarget;
@@ skipping 82 matching lines @@
 
 abstract class HConditionalBranch extends HControlFlow {
   HConditionalBranch(inputs) : super(inputs);
   HInstruction get condition => inputs[0];
   HBasicBlock get trueBranch => block.successors[0];
   HBasicBlock get falseBranch => block.successors[1];
 }
 
 abstract class HControlFlow extends HInstruction {
   HControlFlow(inputs) : super(inputs);
-  void prepareGvn(HTypeMap types) {
-    // Control flow does not have side-effects.
-  }
   bool isControlFlow() => true;
   bool isJsStatement() => true;
 }
 
 abstract class HInvoke extends HInstruction {
   /**
     * The first argument must be the target: either an [HStatic] node, or
     * the receiver of a method-call. The remaining inputs are the arguments
     * to the invocation.
     */
-  HInvoke(List<HInstruction> inputs) : super(inputs);
+  HInvoke(List<HInstruction> inputs) : super(inputs) {
+    setAllSideEffects();
+    setDependsOnSomething();
+  }
   static const int ARGUMENTS_OFFSET = 1;
   bool canThrow() => true;
 }
 
 abstract class HInvokeDynamic extends HInvoke {
   final Selector selector;
   Element element;
 
   HInvokeDynamic(this.selector, this.element, List<HInstruction> inputs)
     : super(inputs);
@@ skipping 49 matching lines @@
 abstract class HInvokeDynamicField extends HInvokeDynamic {
   final bool isSideEffectFree;
   HInvokeDynamicField(
       Selector selector, Element element, List<HInstruction> inputs,
       this.isSideEffectFree)
       : super(selector, element, inputs);
   toString() => 'invoke dynamic field: $selector';
 }
 
 class HInvokeDynamicGetter extends HInvokeDynamicField {
-  HInvokeDynamicGetter(
-      selector, element, receiver, isSideEffectFree)
-    : super(selector, element, [receiver], isSideEffectFree);
-  toString() => 'invoke dynamic getter: $selector';
-  accept(HVisitor visitor) => visitor.visitInvokeDynamicGetter(this);
-
-  void prepareGvn(HTypeMap types) {
+  HInvokeDynamicGetter(selector, element, receiver, isSideEffectFree)
+    : super(selector, element, [receiver], isSideEffectFree) {
     clearAllSideEffects();
     if (isSideEffectFree) {
       setUseGvn();
       setDependsOnInstancePropertyStore();
     } else {
       setDependsOnSomething();
       setAllSideEffects();
     }
   }
+  toString() => 'invoke dynamic getter: $selector';
+  accept(HVisitor visitor) => visitor.visitInvokeDynamicGetter(this);
 
   int typeCode() => HInstruction.INVOKE_DYNAMIC_GETTER_TYPECODE;
   bool typeEquals(other) => other is HInvokeDynamicGetter;
   bool dataEquals(HInvokeDynamicGetter other) => selector == other.selector;
 }
 
 class HInvokeDynamicSetter extends HInvokeDynamicField {
   HInvokeDynamicSetter(selector, element, receiver, value, isSideEffectFree)
-    : super(selector, element, [receiver, value], isSideEffectFree);
-  toString() => 'invoke dynamic setter: $selector';
-  accept(HVisitor visitor) => visitor.visitInvokeDynamicSetter(this);
-
-  void prepareGvn(HTypeMap types) {
+    : super(selector, element, [receiver, value], isSideEffectFree) {
     clearAllSideEffects();
     if (isSideEffectFree) {
       setChangesInstanceProperty();
     } else {
       setAllSideEffects();
       setDependsOnSomething();
     }
   }
+  toString() => 'invoke dynamic setter: $selector';
+  accept(HVisitor visitor) => visitor.visitInvokeDynamicSetter(this);
 }
 
 class HInvokeStatic extends HInvoke {
   /** The first input must be the target. */
   HInvokeStatic(inputs, [HType knownType = HType.UNKNOWN]) : super(inputs) {
     guaranteedType = knownType;
   }
 
   toString() => 'invoke static: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
   int typeCode() => HInstruction.INVOKE_STATIC_TYPECODE;
   Element get element => target.element;
   HStatic get target => inputs[0];
-
-  HType computeDesiredTypeForInput(HInstruction input,
-                                   HTypeMap types,
-                                   Compiler compiler) {
-    // TODO(floitsch): we want the target to be a function.
-    if (input == target) return HType.UNKNOWN;
-    return computeDesiredTypeForNonTargetInput(input, types, compiler);
-  }
-
-  HType computeDesiredTypeForNonTargetInput(HInstruction input,
-                                            HTypeMap types,
-                                            Compiler compiler) {
-    return HType.UNKNOWN;
-  }
 }
 
 class HInvokeSuper extends HInvokeStatic {
   final bool isSetter;
   HInvokeSuper(inputs, {this.isSetter: false}) : super(inputs);
   toString() => 'invoke super: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeSuper(this);
 
   HInstruction get value {
     assert(isSetter);
     // Index 0: the element, index 1: 'this'.
     return inputs[2];
   }
 }
 
 abstract class HFieldAccess extends HInstruction {
   final Element element;
 
   HFieldAccess(Element element, List<HInstruction> inputs)
-      : this.element = element,
-        super(inputs);
+      : this.element = element, super(inputs);
 
-  // TODO(ngeoffray): Only if input can be null.
-  bool canThrow() => true;
+  HInstruction get receiver => inputs[0];
 }
 
 class HFieldGet extends HFieldAccess {
   final bool isAssignable;
 
   HFieldGet(Element element, HInstruction receiver, {bool isAssignable})
       : this.isAssignable = (isAssignable != null)
             ? isAssignable
             : element.isAssignable(),
-        super(element, <HInstruction>[receiver]);
-
-  HInstruction get receiver => inputs[0];
-
-  accept(HVisitor visitor) => visitor.visitFieldGet(this);
-
-  void prepareGvn(HTypeMap types) {
+        super(element, <HInstruction>[receiver]) {
     clearAllSideEffects();
     setUseGvn();
-    if (isAssignable) {
+    if (this.isAssignable) {
       setDependsOnInstancePropertyStore();
     }
   }
 
+  // TODO(ngeoffray): Only if input can be null.
+  bool canThrow() => true;
+
+  accept(HVisitor visitor) => visitor.visitFieldGet(this);
+
   int typeCode() => HInstruction.FIELD_GET_TYPECODE;
   bool typeEquals(other) => other is HFieldGet;
   bool dataEquals(HFieldGet other) => element == other.element;
   String toString() => "FieldGet $element";
 }
 
 class HFieldSet extends HFieldAccess {
   HFieldSet(Element element,
             HInstruction receiver,
             HInstruction value)
-      : super(element, <HInstruction>[receiver, value]);
-
-  HInstruction get receiver => inputs[0];
-  HInstruction get value => inputs[1];
-  accept(HVisitor visitor) => visitor.visitFieldSet(this);
-
-  void prepareGvn(HTypeMap types) {
+      : super(element, <HInstruction>[receiver, value]) {
     clearAllSideEffects();
     setChangesInstanceProperty();
   }
 
+  // TODO(ngeoffray): Only if input can be null.
+  bool canThrow() => true;
+
+  HInstruction get value => inputs[1];
+  accept(HVisitor visitor) => visitor.visitFieldSet(this);
+
   bool isJsStatement() => true;
   String toString() => "FieldSet $element";
 }
 
-class HLocalGet extends HFieldGet {
-  HLocalGet(Element element, HLocalValue local) : super(element, local);
+class HLocalGet extends HFieldAccess {
+  // No need to use GVN for a [HLocalGet], it is just a local
+  // access.
+  HLocalGet(Element element, HLocalValue local)
+      : super(element, <HInstruction>[local]);
 
   accept(HVisitor visitor) => visitor.visitLocalGet(this);
 
   HLocalValue get local => inputs[0];
-
-  void prepareGvn(HTypeMap types) {
-    // No need to use GVN for a [HLocalGet], it is just a local
-    // access.
-    clearAllSideEffects();
-  }
 }
 
-class HLocalSet extends HFieldSet {
+class HLocalSet extends HFieldAccess {
   HLocalSet(Element element, HLocalValue local, HInstruction value)
-      : super(element, local, value);
+      : super(element, <HInstruction>[local, value]);
 
   accept(HVisitor visitor) => visitor.visitLocalSet(this);
 
   HLocalValue get local => inputs[0];
+  HInstruction get value => inputs[1];
+  bool isJsStatement() => true;
 }
 
 class HForeign extends HInstruction {
   final DartString code;
   final HType foreignType;
-  final bool _isStatement;
+  final bool isStatement;
 
-  HForeign(this.code, DartString declaredType, List<HInstruction> inputs)
+  HForeign(this.code,
+           DartString declaredType,
+           List<HInstruction> inputs,
+           {this.isStatement: false})
       : foreignType = computeTypeFromDeclaredType(declaredType),
-        _isStatement = false,
-        super(inputs);
-  HForeign.statement(this.code, List<HInstruction> inputs)
-      : foreignType = HType.UNKNOWN,
-        _isStatement = true,
-        super(inputs);
+        super(inputs) {
+    setAllSideEffects();
+    setDependsOnSomething();
+  }
+
+  HForeign.statement(code, List<HInstruction> inputs)
+      : this(code, const LiteralDartString('var'), input, isStatement: true);
+
   accept(HVisitor visitor) => visitor.visitForeign(this);
 
   static HType computeTypeFromDeclaredType(DartString declaredType) {
     if (declaredType.slowToString() == 'bool') return HType.BOOLEAN;
     if (declaredType.slowToString() == 'int') return HType.INTEGER;
     if (declaredType.slowToString() == 'double') return HType.DOUBLE;
     if (declaredType.slowToString() == 'num') return HType.NUMBER;
     if (declaredType.slowToString() == 'String') return HType.STRING;
     if (declaredType.slowToString() == '=List') return HType.READABLE_ARRAY;
     return HType.UNKNOWN;
   }
 
   HType get guaranteedType => foreignType;
 
-  bool isJsStatement() => _isStatement;
+  bool isJsStatement() => isStatement;
   bool canThrow() => true;
 
 }
 
 class HForeignNew extends HForeign {
   ClassElement element;
   HForeignNew(this.element, List<HInstruction> inputs)
       : super(const LiteralDartString("new"),
               const LiteralDartString("Object"), inputs);
   accept(HVisitor visitor) => visitor.visitForeignNew(this);
 }
 
 abstract class HInvokeBinary extends HInstruction {
   HInvokeBinary(HInstruction left, HInstruction right)
-      : super(<HInstruction>[left, right]);
-
-  void prepareGvn(HTypeMap types) {
+      : super(<HInstruction>[left, right]) {
     clearAllSideEffects();
     setUseGvn();
   }
 
   HInstruction get left => inputs[0];
   HInstruction get right => inputs[1];
 
   BinaryOperation operation(ConstantSystem constantSystem);
 }
 
@@ skipping 123 matching lines @@
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
   BinaryOperation operation(ConstantSystem constantSystem)
       => constantSystem.bitXor;
   int typeCode() => HInstruction.BIT_XOR_TYPECODE;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 abstract class HInvokeUnary extends HInstruction {
-  HInvokeUnary(HInstruction input) : super(<HInstruction>[input]);
-
-  HInstruction get operand => inputs[0];
-
-  void prepareGvn(HTypeMap types) {
+  HInvokeUnary(HInstruction input) : super(<HInstruction>[input]) {
     clearAllSideEffects();
     setUseGvn();
   }
 
+  HInstruction get operand => inputs[0];
+
   UnaryOperation operation(ConstantSystem constantSystem);
 }
 
 class HNegate extends HInvokeUnary {
   HNegate(HInstruction input) : super(input);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
   HType computeTypeFromInputTypes(HTypeMap types, Compiler compiler) {
     return types[operand];
   }
@@ skipping 106 matching lines @@
     return identical(kind, DO_WHILE_LOOP);
   }
 }
 
 class HConstant extends HInstruction {
   final Constant constant;
   final HType constantType;
   HConstant.internal(this.constant, HType this.constantType)
       : super(<HInstruction>[]);
 
-  void prepareGvn(HTypeMap types) {
-    assert(!hasSideEffects());
-  }
-
   toString() => 'literal: $constant';
   accept(HVisitor visitor) => visitor.visitConstant(this);
 
   HType get guaranteedType => constantType;
 
   bool isConstant() => true;
   bool isConstantBoolean() => constant.isBool();
   bool isConstantNull() => constant.isNull();
   bool isConstantNumber() => constant.isNum();
   bool isConstantInteger() => constant.isInt();
   bool isConstantString() => constant.isString();
   bool isConstantList() => constant.isList();
   bool isConstantMap() => constant.isMap();
   bool isConstantFalse() => constant.isFalse();
   bool isConstantTrue() => constant.isTrue();
   bool isConstantSentinel() => constant.isSentinel();
 
   // Maybe avoid this if the literal is big?
   bool isCodeMotionInvariant() => true;
 }
 
 class HNot extends HInstruction {
-  HNot(HInstruction value) : super(<HInstruction>[value]);
-  void prepareGvn(HTypeMap types) {
-    assert(!hasSideEffects());
+  HNot(HInstruction value) : super(<HInstruction>[value]) {
     setUseGvn();
   }
 
   HType get guaranteedType => HType.BOOLEAN;
 
   // 'Not' only works on booleans. That's what we want as input.
   HType computeDesiredTypeForInput(HInstruction input,
                                    HTypeMap types,
                                    Compiler compiler) {
     return HType.BOOLEAN;
   }
 
   accept(HVisitor visitor) => visitor.visitNot(this);
   int typeCode() => HInstruction.NOT_TYPECODE;
   bool typeEquals(other) => other is HNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
   * 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 element) : super(<HInstruction>[]) {
     sourceElement = element;
   }
 
-  void prepareGvn(HTypeMap types) {
-    assert(!hasSideEffects());
-  }
   toString() => 'local ${sourceElement.name}';
   accept(HVisitor visitor) => visitor.visitLocalValue(this);
 }
 
 class HParameterValue extends HLocalValue {
   HParameterValue(Element element) : super(element);
 
   toString() => 'parameter ${sourceElement.name.slowToString()}';
   accept(HVisitor visitor) => visitor.visitParameterValue(this);
 }
@@ skipping 169 matching lines @@
   HThrow(value, {this.isRethrow: false}) : super(<HInstruction>[value]);
   toString() => 'throw';
   accept(HVisitor visitor) => visitor.visitThrow(this);
 }
 
 class HStatic extends HInstruction {
   final Element element;
   HStatic(this.element) : super(<HInstruction>[]) {
     assert(element != null);
     assert(invariant(this, element.isDeclaration));
-  }
-
-  void prepareGvn(HTypeMap types) {
     clearAllSideEffects();
     if (element.isAssignable()) {
       setDependsOnStaticPropertyStore();
     }
     setUseGvn();
   }
   toString() => 'static ${element.name}';
   accept(HVisitor visitor) => visitor.visitStatic(this);
 
   int gvnHashCode() => super.gvnHashCode() ^ element.hashCode;
   int typeCode() => HInstruction.STATIC_TYPECODE;
   bool typeEquals(other) => other is HStatic;
   bool dataEquals(HStatic other) => element == other.element;
   bool isCodeMotionInvariant() => !element.isAssignable();
 }
 
 class HInterceptor extends HInstruction {
   Set<ClassElement> interceptedClasses;
   HInterceptor(this.interceptedClasses, HInstruction receiver)
-      : super(<HInstruction>[receiver]);
+      : super(<HInstruction>[receiver]) {
+    clearAllSideEffects();
+    setUseGvn();
+  }
   String toString() => 'interceptor on $interceptedClasses';
   accept(HVisitor visitor) => visitor.visitInterceptor(this);
   HInstruction get receiver => inputs[0];
 
-  void prepareGvn(HTypeMap types) {
-    clearAllSideEffects();
-    setUseGvn();
-  }
-
   HType computeDesiredTypeForInput(HInstruction input,
                                    HTypeMap types,
                                    Compiler compiler) {
     if (interceptedClasses.length != 1) return HType.UNKNOWN;
     // If the only class being intercepted is of type number, we
     // make this interceptor call say it wants that class as input.
     Element interceptor = interceptedClasses.toList()[0];
     JavaScriptBackend backend = compiler.backend;
     if (interceptor == backend.jsNumberClass) {
       return HType.NUMBER;
     } else if (interceptor == backend.jsIntClass) {
       return HType.INTEGER;
     } else if (interceptor == backend.jsDoubleClass) {
       return HType.DOUBLE;
     }
     return HType.UNKNOWN;
   }
 
   int typeCode() => HInstruction.INTERCEPTOR_TYPECODE;
   bool typeEquals(other) => other is HInterceptor;
   bool dataEquals(HInterceptor other) {
     return interceptedClasses == other.interceptedClasses
         || (interceptedClasses.length == other.interceptedClasses.length
             && interceptedClasses.containsAll(other.interceptedClasses));
   }
 }
 
 /** An [HLazyStatic] is a static that is initialized lazily at first read. */
-class HLazyStatic extends HStatic {
-  HLazyStatic(Element element) : super(element);
-
-  void prepareGvn(HTypeMap types) {
+class HLazyStatic extends HInstruction {
+  final Element element;
+  HLazyStatic(this.element) : super(<HInstruction>[]) {
     // TODO(4931): The first access has side-effects, but we afterwards we
     // should be able to GVN.
     setAllSideEffects();
     setDependsOnSomething();
   }
 
   toString() => 'lazy static ${element.name}';
   accept(HVisitor visitor) => visitor.visitLazyStatic(this);
 
   int typeCode() => 30;
   // TODO(4931): can we do better here?
   bool isCodeMotionInvariant() => false;
   bool canThrow() => true;
 }
 
 class HStaticStore extends HInstruction {
   Element element;
-  HStaticStore(this.element, HInstruction value) : super(<HInstruction>[value]);
+  HStaticStore(this.element, HInstruction value)
+      : super(<HInstruction>[value]) {
+    clearAllSideEffects();
+    setChangesStaticProperty();
+  }
   toString() => 'static store ${element.name}';
   accept(HVisitor visitor) => visitor.visitStaticStore(this);
 
   int typeCode() => HInstruction.STATIC_STORE_TYPECODE;
   bool typeEquals(other) => other is HStaticStore;
   bool dataEquals(HStaticStore other) => element == other.element;
   bool isJsStatement() => true;
-
-  void prepareGvn(HTypeMap types) {
-    clearAllSideEffects();
-    setChangesStaticProperty();
-  }
 }
 
 class HLiteralList extends HInstruction {
   HLiteralList(inputs) : super(inputs);
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
 
   HType get guaranteedType => HType.EXTENDABLE_ARRAY;
-
-  void prepareGvn(HTypeMap types) {
-    assert(!hasSideEffects());
-  }
 }
 
 /**
  * The primitive array indexing operation. Note that this instruction
  * does not throw because we generate the checks explicitly.
  */
 class HIndex extends HInstruction {
   HIndex(HInstruction receiver, HInstruction index)
-      : super(<HInstruction>[receiver, index]);
-  String toString() => 'index operator';
-  accept(HVisitor visitor) => visitor.visitIndex(this);
-
-  void prepareGvn(HTypeMap types) {
+      : super(<HInstruction>[receiver, index]) {
     clearAllSideEffects();
     setDependsOnIndexStore();
     setUseGvn();
   }
 
+  String toString() => 'index operator';
+  accept(HVisitor visitor) => visitor.visitIndex(this);
+
   HInstruction get receiver => inputs[0];
   HInstruction get index => inputs[1];
 
   int typeCode() => HInstruction.INDEX_TYPECODE;
   bool typeEquals(HInstruction other) => other is HIndex;
   bool dataEquals(HIndex other) => true;
 }
 
 /**
  * The primitive array assignment operation. Note that this instruction
  * does not throw because we generate the checks explicitly.
  */
 class HIndexAssign extends HInstruction {
   HIndexAssign(HInstruction receiver,
                HInstruction index,
                HInstruction value)
-      : super(<HInstruction>[receiver, index, value]);
+      : super(<HInstruction>[receiver, index, value]) {
+    clearAllSideEffects();
+    setChangesIndex();
+  }
   String toString() => 'index assign operator';
   accept(HVisitor visitor) => visitor.visitIndexAssign(this);
 
   HInstruction get receiver => inputs[0];
   HInstruction get index => inputs[1];
   HInstruction get value => inputs[2];
-
-  void prepareGvn(HTypeMap types) {
-    clearAllSideEffects();
-    setChangesIndex();
-  }
 }
 
 class HIs extends HInstruction {
   final DartType typeExpression;
   final bool nullOk;
 
-  HIs.withArgumentChecks(this.typeExpression,
-                         HInstruction expression,
-                         List<HInstruction> checks,
-                         [this.nullOk = false])
-    : super(<HInstruction>[expression]..addAll(checks));
-
-  HIs(this.typeExpression, HInstruction expression, {this.nullOk: false})
-     : super(<HInstruction>[expression]);
+  HIs(this.typeExpression, List<HInstruction> inputs, {this.nullOk: false})
+     : super(inputs) {
+    setUseGvn();
+  }
 
   HInstruction get expression => inputs[0];
   HInstruction getCheck(int index) => inputs[index + 1];
   int get checkCount => inputs.length - 1;
 
   bool hasArgumentChecks() => inputs.length > 1;
 
   HType get guaranteedType => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitIs(this);
@@ skipping 52 matching lines @@
   }
   accept(HVisitor visitor) => visitor.visitRangeConversion(this);
 
   // We currently only do range analysis for integers.
   HType get guaranteedType => HType.INTEGER;
 }
 
 class HStringConcat extends HInstruction {
   final Node node;
   HStringConcat(HInstruction left, HInstruction right, this.node)
-      : super(<HInstruction>[left, right]);
+      : super(<HInstruction>[left, right]) {
+    setAllSideEffects();
+    setDependsOnSomething();
+  }
   HType get guaranteedType => HType.STRING;
 
   HInstruction get left => inputs[0];
   HInstruction get right => inputs[1];
 
   accept(HVisitor visitor) => visitor.visitStringConcat(this);
   toString() => "string concat";
 }
 
 /** Non-block-based (aka. traditional) loop information. */
@@ skipping 321 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);
 }