Track fields which are known to be always set to integer constants

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 11 matching lines @@
       loopMarkers = new Set<HBasicBlock>.from(other.loopMarkers);
 
   void remove(HInstruction instruction) {
     lives.remove(instruction);
   }
 
   void add(HInstruction instruction) {
     // If the instruction is a type guard, we add its checked input
     // instead. This allows sharing the same environment between
     // different type guards.
-    // 
+    //
     // Also, we don't need to add code motion invariant instructions
     // in the live set (because we generate them at use-site), except
     // for parameters that are not 'this', which is always passed as
     // the receiver.
     if (instruction is HTypeGuard) {
       add(instruction.checkedInput);
     } else if (!instruction.isCodeMotionInvariant()
                || (instruction is HParameterValue && instruction is !HThis)) {
       lives.add(instruction);
     } else {
@@ skipping 25 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 42 matching lines @@
 
     // If the instruction is not in a loop then the header will be null.
     HBasicBlock currentLoopHeader = instruction.block.enclosingLoopHeader;
     for (HInstruction user in instruction.usedBy) {
       HBasicBlock userLoopHeader = user.block.enclosingLoopHeader;
       if (isNested(userLoopHeader, currentLoopHeader)) return true;
     }
 
     // Insert type guards if the method is likely to be called in a
     // loop.
-    return calledInLoop;
+    return calledInLoop || highTypeLikelyhood;
   }
 
   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 361 matching lines @@
         hasComplexTypeGuards = true;
       }
     } else {
       hasComplexTypeGuards = true;
       blocks.forEach((HBasicBlock block) {
         block.guards.add(guard);
       });
     }
   }
 }