Distinguish statement and expression foreign code.

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 946 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() => false;
+  bool get isStatement() => false;
 }
 
 class HBoolify extends HInstruction {
   HBoolify(HInstruction value) : super(<HInstruction>[value]);
   void prepareGvn() {
     assert(!hasSideEffects());
     setUseGvn();
   }
 
   HType get guaranteedType() => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitBoolify(this);
   int typeCode() => 0;
   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 isStatement() => true;
+  final bool isStatement = true;
   void prepareGvn() {
     assert(!hasSideEffects());
     setUseGvn();
   }
 }
 
 class HTypeGuard extends HCheck {
   final int state;
   final HType guardedType;
   bool isOn = false;
@@ skipping 69 matching lines @@
   abstract toString();
 }
 
 class HControlFlow extends HInstruction {
   HControlFlow(inputs) : super(inputs);
   abstract toString();
   void prepareGvn() {
     // Control flow does not have side-effects.
   }
   bool isControlFlow() => true;
-  bool isStatement() => true;
+  final bool isStatement = 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.
     */
   final Selector selector;
   HInvoke(Selector this.selector, List<HInstruction> inputs) : super(inputs);
@@ skipping 184 matching lines @@
 
   HInstruction get receiver() => inputs[0];
   HInstruction get value() => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
   void prepareGvn() {
     // TODO(ngeoffray): implement more fine grained side effects.
     setAllSideEffects();
   }
 
-  bool isStatement() => true;
+  final 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() {
@@ skipping 17 matching lines @@
     // 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),
+        isStatement = false,
+        super(inputs);
+  HForeign.statement(this.code, List<HInstruction> inputs)
+      : foreignType = HType.UNKNOWN,
+        isStatement = true,
         super(inputs);
   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;
     return HType.UNKNOWN;
   }
 
   HType get guaranteedType() => foreignType;
 
-  // Be conservative and treat all [HForeign] as statements, even
-  // though some are just expressions.
-  bool isStatement() => true;
+  final bool 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 788 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() => 26;
   bool typeEquals(other) => other is HStaticStore;
   bool dataEquals(HStaticStore other) => element == other.element;
-  bool isStatement() => true;
+  final bool isStatement = true;
 }
 
 class HLiteralList extends HInstruction {
   HLiteralList(inputs) : super(inputs);
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
 
   HType get guaranteedType() => HType.MUTABLE_ARRAY;
 
   void prepareGvn() {
@@ skipping 54 matching lines @@
       return HType.MUTABLE_ARRAY;
     }
     // 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 get builtin() => receiver.isMutableArray() && index.isInteger();
-  bool isStatement() => !builtin;
+  bool get isStatement() => !builtin;
 }
 
 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 34 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() => kind == ARGUMENT_TYPE_CHECK;
+  bool get isStatement() => kind == ARGUMENT_TYPE_CHECK;
   bool isControlFlow() => kind == ARGUMENT_TYPE_CHECK;
 
   int typeCode() => 28;
   bool typeEquals(HInstruction other) => other is HTypeConversion;
   bool dataEquals(HTypeConversion other) {
     return type == other.type && kind == other.kind;
   }
 }
 
 class HStringConcat extends HInstruction {
@@ skipping 330 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);
 }