Don't allow statement-nodes in expression contexts.

lib/compiler/implementation/ssa/codegen_helpers.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.
 
 /**
  * Instead of emitting each SSA instruction with a temporary variable
  * mark instructions that can be emitted at their use-site.
  * For example, in:
  *   t0 = 4;
  *   t1 = 3;
  *   t2 = add(t0, t1);
  * t0 and t1 would be marked and the resulting code would then be:
  *   t2 = add(4, 3);
  */
 class SsaInstructionMerger extends HBaseVisitor {
   List<HInstruction> expectedInputs;
   Set<HInstruction> generateAtUseSite;
 
+  void markAsGenerateAtUseSite(HInstruction instruction) {
+    assert(!instruction.isStatement);
+    generateAtUseSite.add(instruction);
+  }
+
   SsaInstructionMerger(this.generateAtUseSite);
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitInstruction(HInstruction instruction) {
     // A code motion invariant instruction is dealt before visiting it.
     assert(!instruction.isCodeMotionInvariant());
     for (HInstruction input in instruction.inputs) {
@@ skipping 24 matching lines @@
     if (!instruction.builtin) super.visitEquals(instruction);
     // Otherwise do nothing.
   }
 
   // Identity operations must not have its input generated at use site, because
   // it's using it multiple times (because of null/undefined).
   void visitIdentity(HIdentity instruction) {}
 
   void visitTypeConversion(HTypeConversion instruction) {
     if (!instruction.isChecked) {
-      generateAtUseSite.add(instruction);
+      markAsGenerateAtUseSite(instruction);
     } else if (instruction.isCheckedModeCheck) {
       // Checked mode checks compile to code that only use their input
       // once, so we can safely visit them and try to merge the input.
       visitInstruction(instruction);
     }
   }
 
   void tryGenerateAtUseSite(HInstruction instruction) {
     if (instruction.isControlFlow()) return;
-    generateAtUseSite.add(instruction);
+    markAsGenerateAtUseSite(instruction);
   }
 
   bool isBlockSinglePredecessor(HBasicBlock block) {
     return block.successors.length === 1
         && block.successors[0].predecessors.length === 1;
   }
 
   void visitBasicBlock(HBasicBlock block) {
     // Compensate from not merging blocks: if the block is the
     // single predecessor of its single successor, let the successor
@@ skipping 28 matching lines @@
     }
 
     block.last.accept(this);
     for (HInstruction instruction = block.last.previous;
          instruction !== null;
          instruction = instruction.previous) {
       if (generateAtUseSite.contains(instruction)) {
         continue;
       }
       if (instruction.isCodeMotionInvariant()) {
-        generateAtUseSite.add(instruction);
+        markAsGenerateAtUseSite(instruction);
         continue;
       }
+      if (instruction.isStatement) {

[ngeoffray, 2012/08/17 13:08:58]

Please explain which inputs can be statements. Maybe we should change it to
isJSStatement?

[floitsch, 2012/08/29 11:03:12]

Changed to isJsStatement.

+        expectedInputs.clear();
+      }
       // See if the current instruction is the next non-trivial
       // expected input.
       if (findInInputsAndPopNonMatching(instruction)) {
         tryGenerateAtUseSite(instruction);
       } else {
         assert(expectedInputs.isEmpty());
       }
       instruction.accept(this);
     }
 
     if (block.predecessors.length === 1
         && isBlockSinglePredecessor(block.predecessors[0])) {
       assert(block.phis.isEmpty());
       tryMergingExpressions(block.predecessors[0]);
     } else {
       expectedInputs = null;
     }
   }
 }
 
 /**
  *  Detect control flow arising from short-circuit logical and
  *  conditional operators, and prepare the program to be generated
  *  using these operators instead of nested ifs and boolean variables.
  */
 class SsaConditionMerger extends HGraphVisitor {
   Set<HInstruction> generateAtUseSite;
   Set<HInstruction> controlFlowOperators;
 
+  void markAsGenerateAtUseSite(HInstruction instruction) {
+    assert(!instruction.isStatement);
+    generateAtUseSite.add(instruction);
+  }
+
   SsaConditionMerger(this.generateAtUseSite, this.controlFlowOperators);
 
   void visitGraph(HGraph graph) {
     visitPostDominatorTree(graph);
   }
 
   /**
    * Check if a block has at least one statement other than
    * [instruction].
    */
@@ skipping 51 matching lines @@
     // phi(expr, true|false)
     if (end == null) return;
     if (end.phis.isEmpty()) return;
     if (end.phis.first !== end.phis.last) return;
     HBasicBlock elseBlock = startIf.elseBlock;
 
     if (end.predecessors[1] !== elseBlock) return;
     HPhi phi = end.phis.first;
     HInstruction thenInput = phi.inputs[0];
     HInstruction elseInput = phi.inputs[1];
+    if (thenInput.isStatement || elseInput.isStatement) return;
 
     if (hasAnyStatement(elseBlock, elseInput)) return;
     assert(elseBlock.successors.length == 1);
     assert(end.predecessors.length == 2);
 
     HBasicBlock thenBlock = startIf.thenBlock;
     // Skip trivial goto blocks.
     while (thenBlock.successors[0] != end && thenBlock.first is HGoto) {
       thenBlock = thenBlock.successors[0];
     }
 
     // If the [thenBlock] is already a control flow operation, and does not
     // have any statement and its join block is [end], we can emit a
     // sequence of control flow operation.
     if (controlFlowOperators.contains(thenBlock.last)) {
       HIf otherIf = thenBlock.last;
       if (otherIf.joinBlock !== end) return;
       if (hasAnyStatement(thenBlock, otherIf)) return;
     } else {
       if (end.predecessors[0] !== thenBlock) return;
       if (hasAnyStatement(thenBlock, thenInput)) return;
       assert(thenBlock.successors.length == 1);
     }
 
     // From now on, we have recognized a control flow operation built from
     // the builder. Mark the if instruction as such.
     controlFlowOperators.add(startIf);
 
     // If the operation is only used by the first instruction
-    // of its block and is safe to be generated at use sute, mark it
+    // of its block and is safe to be generated at use site, mark it
     // so.
     if (phi.usedBy.length == 1
         && phi.usedBy[0] === phi.block.first
         && isSafeToGenerateAtUseSite(phi.usedBy[0], phi)) {
-      generateAtUseSite.add(phi);
+      markAsGenerateAtUseSite(phi);
     }
 
     if (elseInput.block === elseBlock) {
       assert(elseInput.usedBy.length == 1);
-      generateAtUseSite.add(elseInput);
+      markAsGenerateAtUseSite(elseInput);
     }
 
     // If [thenInput] is defined in the first predecessor, then it is only used
     // by [phi] and can be generated at use site.
     if (thenInput.block === end.predecessors[0]) {
       assert(thenInput.usedBy.length == 1);
-      generateAtUseSite.add(thenInput);
+      markAsGenerateAtUseSite(thenInput);
     }
   }
 }
 
 // Precedence information for JavaScript operators.
 class JSPrecedence {
    // Used as precedence for something that's not even an expression.
   static final int STATEMENT_PRECEDENCE      = 0;
   // Precedences of JS operators.
   static final int EXPRESSION_PRECEDENCE     = 1;
@@ skipping 64 matching lines @@
   };
 }
 
 class JSBinaryOperatorPrecedence {
   final int left;
   final int right;
   const JSBinaryOperatorPrecedence(this.left, this.right);
   // All binary operators (excluding assignment) are left associative.
   int get precedence() => left;
 }