Support is checks on primitive types.

dart/frog/leg/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 HGraphVisitor {
+class SsaInstructionMerger extends HBaseVisitor {
+  List<HInstruction> expectedInputs;
+
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   bool usedOnlyByPhis(instruction) {
     for (HInstruction user in instruction.usedBy) {
       if (user is !HPhi) return false;
     }
     return true;
   }
 
+  void visitInstruction(HInstruction instruction) {
+    for (HInstruction input in instruction.inputs) {
+      if (!input.generateAtUseSite() && input.usedBy.length == 1) {
+        expectedInputs.add(input);
+      }
+    }
+  }
+
+  // The codegen might use the input multiple times, so it must not be
+  // set generate at use site.
+  void visitIs(HIs instruction) {}
+
   void visitBasicBlock(HBasicBlock block) {
     // Visit each instruction of the basic block in last-to-first order.
     // Keep a list of expected inputs of the current "expression" being
     // merged. If instructions occur in the expected order, they are
     // included in the expression.
 
     // The expectedInputs list holds non-trivial instructions that may
     // be generated at their use site, if they occur in the correct order.
-    List<HInstruction> expectedInputs = new List<HInstruction>();
+    expectedInputs = new List<HInstruction>();
     // Add non-trivial inputs of instruction to expectedInputs, in
     // evaluation order.
     void addInputs(HInstruction instruction) {
-      for (HInstruction input in instruction.inputs) {
-        if (!input.generateAtUseSite() && input.usedBy.length == 1) {
-          expectedInputs.add(input);
-        }
-      }
+      instruction.accept(this);
     }
     // Pop instructions from expectedInputs until instruction is found.
     // Return true if it is found, or false if not.
     bool findInInputs(HInstruction instruction) {
       while (!expectedInputs.isEmpty()) {
         HInstruction nextInput = expectedInputs.removeLast();
         assert(!nextInput.generateAtUseSite());
         assert(nextInput.usedBy.length == 1);
         if (nextInput == instruction) {
           return true;
@@ skipping 19 matching lines @@
       }
       if (instruction is HForeign) {
         // Never try to merge inputs to HForeign.
         continue;
       } else if (instruction.generateAtUseSite() ||
                  usedOnlyByPhis(instruction)) {
         // In all other cases, try merging all non-trivial inputs.
         addInputs(instruction);
       }
     }
+    expectedInputs = null;
   }
 }
 
 /**
  * In order to generate efficient code that works with bailouts, we
  * rewrite users of check instruction to use the input of the
  * instruction instead of the check itself.
  */
 class SsaCheckInstructionUnuser extends HBaseVisitor {
   void visitGraph(HGraph graph) {
@@ skipping 153 matching lines @@
     secondBlock.last.tryGenerateAtUseSite();
   }
 
   void visitBasicBlock(HBasicBlock block) {
     if (!block.phis.isEmpty() &&
         block.phis.first == block.phis.last) {
       detectLogicControlFlow(block.phis.first);
     }
   }
 }