anchor.diff:   * inconsistent way. No further analysis should rely on them.
    */
   class SsaTypeGuardInserter extends HGraphVisitor implements OptimizationPhase {
  +  static final int SMALL_METHOD_BLOCK_LIMIT = 5;
  +
     final Compiler compiler;
     final String name = 'SsaTypeGuardInserter';
     final WorkItem work;
  +  bool smallMethodNoLoops = false;
     int stateId = 1;
   
     SsaTypeGuardInserter(this.compiler, this.work);
   
     void visitGraph(HGraph graph) {
  +    var blocks = graph.blocks;
  +    if (blocks.length < SMALL_METHOD_BLOCK_LIMIT) {
  +      smallMethodNoLoops = true;
  +      for (var i = 0; i < blocks.length; i++) {
  +        if (blocks[i].enclosingLoopHeader !== null) {
  +          smallMethodNoLoops = false;
  +        }
  +      }
  +    }
       work.guards = <HTypeGuard>[];
       visitDominatorTree(graph);
     }
  
positive.code: 
    bool typeGuardWouldBeValuable(HInstruction instruction,
                                  HType speculativeType) {
  
      Element source = instruction.sourceElement;
      // Do not insert a type guard if the instruction has a type
      // annotation that disagrees with the speculated type.
      if (source !== null) {
        Type sourceType = source.computeType(compiler);
        Type speculatedType = speculativeType.computeType(compiler);
  
negative.code:       }
      }
  
      // Insert type guards if there are uses in loops.
      bool isNested(HBasicBlock inner, HBasicBlock outer) {
        if (inner === outer) return false;
        if (outer === null) return true;
  