Address comments from CL 10660026.

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 visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 1049 matching lines @@
     return validator.isValid;
   }
 
   /**
    * The code for computing a bailout environment, and the code
    * generation must agree on what does not need to be captured,
    * so should always be generated at use site.
    */
   bool isCodeMotionInvariant() => false;
 
-  bool isStatement(HTypeMap types) => false;
+  bool isJsStatement(HTypeMap types) => false;
 
   bool dominates(HInstruction other) {
     if (block != other.block) return block.dominates(other.block);
 
     HInstruction current = this;
     while (current !== null) {
       if (current === other) return true;
       current = current.next;
     }
     return false;
@@ skipping 18 matching lines @@
 /**
  * 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 isStatement(HTypeMap types) => true;
+  bool isJsStatement(HTypeMap types) => true;
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
     setUseGvn();
   }
 }
 
 class HBailoutTarget extends HInstruction {
   final int state;
   bool isEnabled = false;
   HBailoutTarget(this.state) : super(<HInstruction>[]);
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
     setUseGvn();
   }
 
   bool isControlFlow() => true;
-  bool isStatement(HTypeMap types) => isEnabled;
+  bool isJsStatement(HTypeMap types) => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitBailoutTarget(this);
   int typeCode() => HInstruction.BAILOUT_TARGET_TYPECODE;
   bool typeEquals(other) => other is HBailoutTarget;
   bool dataEquals(HBailoutTarget other) => other.state == state;
 }
 
 class HTypeGuard extends HCheck {
   final HType guardedType;
   bool isEnabled = false;
 
   HTypeGuard(this.guardedType, HInstruction guarded, HInstruction bailoutTarget)
       : super(<HInstruction>[guarded, bailoutTarget]);
 
   HInstruction get guarded => inputs[0];
   HInstruction get checkedInput => guarded;
   HBailoutTarget get bailoutTarget => inputs[1];
   int get state => bailoutTarget.state;
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     return isEnabled ? guardedType : types[guarded];
   }
 
   HType get guaranteedType => isEnabled ? guardedType : HType.UNKNOWN;
 
   bool isControlFlow() => true;
 
-  bool isStatement(HTypeMap types) => isEnabled;
+  bool isJsStatement(HTypeMap types) => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitTypeGuard(this);
   int typeCode() => HInstruction.TYPE_GUARD_TYPECODE;
   bool typeEquals(other) => other is HTypeGuard;
   bool dataEquals(HTypeGuard other) => guardedType == other.guardedType;
 }
 
 class HBoundsCheck extends HCheck {
   static const int ALWAYS_FALSE = 0;
   static const int FULL_CHECK = 1;
@@ skipping 51 matching lines @@
   abstract toString();
 }
 
 class HControlFlow extends HInstruction {
   HControlFlow(inputs) : super(inputs);
   abstract toString();
   void prepareGvn(HTypeMap types) {
     // Control flow does not have side-effects.
   }
   bool isControlFlow() => true;
-  bool isStatement(HTypeMap types) => true;
+  bool isJsStatement(HTypeMap types) => true;
 }
 
 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);
   static const int ARGUMENTS_OFFSET = 1;
@@ skipping 193 matching lines @@
 
   HInstruction get receiver => inputs[0];
   HInstruction get value => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   void prepareGvn(HTypeMap types) {
     // TODO(ngeoffray): implement more fine grained side effects.
     setAllSideEffects();
   }
 
-  bool isStatement(HTypeMap types) => true;
+  bool isJsStatement(HTypeMap types) => true;
   String toString() => "FieldSet $element";
 }
 
 class HLocalGet extends HFieldGet {
   HLocalGet(Element element, HLocalValue local) : super(element, local);
 
   accept(HVisitor visitor) => visitor.visitLocalGet(this);
 
   HLocalValue get local => inputs[0];
 
@@ skipping 39 matching lines @@
     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;
     return HType.UNKNOWN;
   }
 
   HType get guaranteedType => foreignType;
 
-  bool isStatement(HTypeMap types) => _isStatement;
+  bool isJsStatement(HTypeMap types) => _isStatement;
 }
 
 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);
 }
 
@@ skipping 800 matching lines @@
 
 class HStaticStore extends HInstruction {
   Element element;
   HStaticStore(this.element, HInstruction value) : super(<HInstruction>[value]);
   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 isStatement(HTypeMap types) => true;
+  bool isJsStatement(HTypeMap types) => true;
 }
 
 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) {
@@ skipping 59 matching lines @@
     }
     // The index should be an int when the receiver is a string or array.
     // However it turns out that inserting an integer check in the optimized
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
 
   bool isBuiltin(HTypeMap types)
       => receiver.isMutableArray(types) && index.isInteger(types);
-  bool isStatement(HTypeMap types) => !isBuiltin(types);
+  bool isJsStatement(HTypeMap types) => !isBuiltin(types);
 }
 
 class HIs extends HInstruction {
   final Type typeExpression;
   final bool nullOk;
 
   HIs.withTypeInfoCall(this.typeExpression, HInstruction expression,
                        HInstruction typeInfo, [this.nullOk = false])
     : super(<HInstruction>[expression, typeInfo]);
 
@@ skipping 36 matching lines @@
 
   bool get isChecked => kind != NO_CHECK;
   bool get isCheckedModeCheck => kind == CHECKED_MODE_CHECK;
   bool get isArgumentTypeCheck => kind == ARGUMENT_TYPE_CHECK;
   bool get isCastTypeCheck => kind == CAST_TYPE_CHECK;
 
   HType get guaranteedType => type;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
-  bool isStatement(HTypeMap types) => kind == ARGUMENT_TYPE_CHECK;
+  bool isJsStatement(HTypeMap types) => kind == ARGUMENT_TYPE_CHECK;
   bool isControlFlow() => kind == ARGUMENT_TYPE_CHECK;
 
   int typeCode() => HInstruction.TYPE_CONVERSION_TYPECODE;
   bool typeEquals(HInstruction other) => other is HTypeConversion;
   bool dataEquals(HTypeConversion other) {
     return type == other.type && kind == other.kind;
   }
 }
 
 class HStringConcat extends HInstruction {
@@ skipping 332 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);
 }