Fix bug in recompilation handling.

lib/compiler/implementation/ssa/bailout.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.
 
 class BailoutInfo {
   int instructionId;
   int bailoutId;
   BailoutInfo(this.instructionId, this.bailoutId);
 }
 
@@ skipping 57 matching lines @@
  * we consider the guard to be of value.
  *
  * Might modify the [:propagatedType:] fields of the instructions in an
  * inconsistent way. No further analysis should rely on them.
  */
 class SsaTypeGuardInserter extends HGraphVisitor implements OptimizationPhase {
   final Compiler compiler;
   final String name = 'SsaTypeGuardInserter';
   final WorkItem work;
   bool calledInLoop = false;
-  bool highTypeLikelyhood = false;
   bool isRecursiveMethod = false;
   int stateId = 1;
 
   SsaTypeGuardInserter(this.compiler, this.work);
 
   void visitGraph(HGraph graph) {
     isRecursiveMethod = graph.isRecursiveMethod;
     calledInLoop = graph.calledInLoop;
-    highTypeLikelyhood = graph.highTypeLikelyhood;
     work.guards = <HTypeGuard>[];
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
     block.forEachPhi(visitInstruction);
 
     HInstruction instruction = block.first;
     while (instruction !== null) {
       // Note that visitInstruction (from the phis and here) might insert an
@@ skipping 58 matching lines @@
     // generation of a bailout method.
     if (instruction is HIndex && instruction.builtin && hasTypeGuards) {
       HBasicBlock loopHeader = instruction.block.enclosingLoopHeader;
       if (loopHeader != null && loopHeader.parentLoopHeader != null) {
         return true;
       }
     }
 
     // Insert type guards if the method is likely to be called in a
     // loop.
-    return calledInLoop || highTypeLikelyhood;
+    return calledInLoop;
   }
 
   bool shouldInsertTypeGuard(HInstruction instruction) {
     HType speculativeType = instruction.propagatedType;
     HType computedType = instruction.computeTypeFromInputTypes();
     // Start by reverting the propagated type. If we add a type guard then the
     // guard will expose the speculative type. If we don't add a type guard
     // then this avoids subsequent instructions to use the the wrong type.
     //
     // Note that just setting the propagatedType of the instruction is not
@@ skipping 359 matching lines @@
         hasComplexTypeGuards = true;
       }
     } else {
       hasComplexTypeGuards = true;
       blocks.forEach((HBasicBlock block) {
         block.guards.add(guard);
       });
     }
   }
 }