Reapply r18377 it was reverted due to the unrelated bug it surfaced.

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, 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.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 59 matching lines @@
 #define DEFINE_ENUM_LIST(class_name, function_name, enum_name, fp) k##enum_name,
 RECOGNIZED_LIST(DEFINE_ENUM_LIST)
 #undef DEFINE_ENUM_LIST
   };
 
   static Kind RecognizeKind(const Function& function);
   static const char* KindToCString(Kind kind);
 };
 
 
+// CompileType describes type of the value produced by the definition.
+//
+// It captures the following properties:
+//    - whether value can potentially be null or it is definitely not null;
+//    - concrete class id of the value or kDynamicCid if unknown statically;
+//    - abstract super type of the value, concrete type of the value in runtime
+//      is guaranteed to be sub type of this type.
+//
+// Values of CompileType form a lattice with a None type as a bottom and a
+// nullable Dynamic type as a top element. Method Union provides a join
+// operation for the lattice.
+class CompileType : public ZoneAllocated {
+ public:
+  static const bool kNullable = true;
+  static const bool kNonNullable = false;
+
+  // Return type such that concrete value's type in runtime is guaranteed to
+  // be subtype of it.
+  const AbstractType* ToAbstractType();
+
+  // Return class id such that it is either kDynamicCid or in runtime
+  // value is guaranteed to have an equal class id.
+  intptr_t ToCid();
+
+  // Return class id such that it is either kDynamicCid or in runtime
+  // value is guaranteed to be either null or have an equal class id.
+  intptr_t ToNullableCid();
+
+  // Returns true if the value is guaranteed to be not-null or is known to be
+  // always null.
+  bool HasDecidableNullability();
+
+  // Returns true if the value is known to be always null.
+  bool IsNull();
+
+  // Returns true if this type is more specific than given type.
+  bool IsMoreSpecificThan(const AbstractType& other);
+
+  // Returns true if value of this type is assignable to a location of the
+  // given type.
+  bool IsAssignableTo(const AbstractType& type) {
+    bool is_instance;
+    return CanComputeIsInstanceOf(type, kNullable, &is_instance) &&
+           is_instance;
+  }
+
+  // Create a new CompileType representing given combination of class id and
+  // abstract type. The pair is assumed to be coherent.
+  static CompileType* New(intptr_t cid, const AbstractType& type);
+
+  // Create a new CompileType representing given abstract type. By default
+  // values as assumed to be nullable.
+  static CompileType* FromAbstractType(const AbstractType& type,
+                                       bool is_nullable = kNullable);
+
+  // Create a new CompileType representing an value with the given class id.
+  // Resulting CompileType is nullable only if cid is kDynamicCid or kNullCid.
+  static CompileType* FromCid(intptr_t cid);
+
+  // Create None CompileType. It is the bottom of the lattice and is used to
+  // represent type of the phi that was not yet inferred.
+  static CompileType* None() {
+    return new CompileType(true, kIllegalCid, NULL);
+  }
+
+  // Create Dynamic CompileType. It is the top of the lattice and is used to
+  // represent unknown type.
+  static CompileType* Dynamic();
+
+  static CompileType* Null();
+
+  // Create non-nullable Bool type.
+  static CompileType* Bool();
+
+  // Create non-nullable Int type.
+  static CompileType* Int();
+
+  // Perform a join operation over the type lattice.
+  void Union(CompileType* other);
+
+  // Returns true if this and other types are the same.
+  bool IsEqualTo(CompileType* other) {
+    return (is_nullable_ == other->is_nullable_) &&
+        (ToNullableCid() == other->ToNullableCid()) &&
+        (ToAbstractType()->Equals(*other->ToAbstractType()));
+  }
+
+  // Replaces this type with other.
+  void ReplaceWith(CompileType* other) {
+    is_nullable_ = other->is_nullable_;
+    cid_ = other->cid_;
+    type_ = other->type_;
+  }
+
+  bool IsNone() const {
+    return (cid_ == kIllegalCid) && (type_ == NULL);
+  }
+
+  void PrintTo(BufferFormatter* f) const;
+  const char* ToCString() const;
+
+ private:
+  CompileType(bool is_nullable, intptr_t cid, const AbstractType* type)
+      : is_nullable_(is_nullable), cid_(cid), type_(type) { }
+
+  bool CanComputeIsInstanceOf(const AbstractType& type,
+                              bool is_nullable,
+                              bool* is_instance);
+
+  bool is_nullable_;
+  intptr_t cid_;
+  const AbstractType* type_;
+};
+
+
 class Value : public ZoneAllocated {
  public:
   // A forward iterator that allows removing the current value from the
   // underlying use list during iteration.
   class Iterator {
    public:
     explicit Iterator(Value* head) : next_(head) { Advance(); }
     Value* Current() const { return current_; }
     bool Done() const { return current_ == NULL; }
     void Advance() {
       // Pre-fetch next on advance and cache it.
       current_ = next_;
       if (next_ != NULL) next_ = next_->next_use();
     }
    private:
     Value* current_;
     Value* next_;
   };
 
   explicit Value(Definition* definition)
       : definition_(definition),
         previous_use_(NULL),
         next_use_(NULL),
         instruction_(NULL),
         use_index_(-1),
-        reaching_cid_(kIllegalCid) { }
+        reaching_type_(NULL) { }
 
   Definition* definition() const { return definition_; }
   void set_definition(Definition* definition) { definition_ = definition; }
 
   Value* previous_use() const { return previous_use_; }
   void set_previous_use(Value* previous) { previous_use_ = previous; }
 
   Value* next_use() const { return next_use_; }
   void set_next_use(Value* next) { next_use_ = next; }
 
   Instruction* instruction() const { return instruction_; }
   void set_instruction(Instruction* instruction) { instruction_ = instruction; }
 
   intptr_t use_index() const { return use_index_; }
   void set_use_index(intptr_t index) { use_index_ = index; }
 
   static void AddToList(Value* value, Value** list);
   void RemoveFromUseList();
 
   Value* Copy() { return new Value(definition_); }
 
-  RawAbstractType* CompileType() const;
-  intptr_t ResultCid() const;
+  CompileType* Type();
+
+  void SetReachingType(CompileType* type) {
+    reaching_type_ = type;
+  }
 
   void PrintTo(BufferFormatter* f) const;
 
   const char* DebugName() const { return "Value"; }
 
   // Return true if the value represents a constant.
   bool BindsToConstant() const;
 
   // Return true if the value represents the constant null.
   bool BindsToConstantNull() const;
 
   // Assert if BindsToConstant() is false, otherwise returns the constant value.
   const Object& BoundConstant() const;
 
-  // Compute a run-time null test at compile-time and set result in is_null.
-  // Return false if the computation is not possible at compile time.
-  bool CanComputeIsNull(bool* is_null) const;
-
-  // Compute a run-time type test at compile-time and set result in is_instance.
-  // Return false if the computation is not possible at compile time.
-  bool CanComputeIsInstanceOf(const AbstractType& type,
-                              bool* is_instance) const;
-
   // Compile time constants, Bool, Smi and Nulls do not need to update
   // the store buffer.
-  bool NeedsStoreBuffer() const;
+  bool NeedsStoreBuffer();
 
   bool Equals(Value* other) const;
 
-  void set_reaching_cid(intptr_t cid) { reaching_cid_ = cid; }
-  intptr_t reaching_cid() const { return reaching_cid_; }
-
  private:
   Definition* definition_;
   Value* previous_use_;
   Value* next_use_;
   Instruction* instruction_;
   intptr_t use_index_;
 
-  intptr_t reaching_cid_;
+  CompileType* reaching_type_;
 
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 
 enum Representation {
   kTagged,
   kUnboxedDouble,
   kUnboxedMint
 };
@@ skipping 908 matching lines @@
     ssa_temp_index_ = index;
   }
   bool HasSSATemp() const { return ssa_temp_index_ >= 0; }
   void ClearSSATempIndex() { ssa_temp_index_ = -1; }
 
   bool is_used() const { return (use_kind_ != kEffect); }
   void set_use_kind(UseKind kind) { use_kind_ = kind; }
 
   // Compile time type of the definition, which may be requested before type
   // propagation during graph building.
-  virtual RawAbstractType* CompileType() const = 0;
-
-  virtual intptr_t ResultCid() const = 0;
-
-  bool HasPropagatedType() const {
-    return !propagated_type_.IsNull();
-  }
-  RawAbstractType* PropagatedType() const {
-    ASSERT(HasPropagatedType());
-    return propagated_type_.raw();
-  }
-  // Returns true if the propagated type has changed.
-  bool SetPropagatedType(const AbstractType& propagated_type) {
-    if (propagated_type.IsNull()) {
-      // Not a typed definition, e.g. access to a VM field.
-      return false;
+  CompileType* Type() {
+    if (type_ == NULL) {
+      type_ = ComputeInitialType();
     }
-    const bool changed =
-        propagated_type_.IsNull() || !propagated_type.Equals(propagated_type_);
-    propagated_type_ = propagated_type.raw();
-    return changed;
+    return type_;
   }
 
-  bool has_propagated_cid() const { return propagated_cid_ != kIllegalCid; }
-  intptr_t propagated_cid() const { return propagated_cid_; }
+  // Compute initial compile type for this definition. It is safe to use this
+  // approximation even before type propagator was run (e.g. during graph
+  // building).
+  virtual CompileType* ComputeInitialType() const {
+    return CompileType::Dynamic();
+  }
 
-  // May compute and set propagated cid.
-  virtual intptr_t GetPropagatedCid();
-
-  // Returns true if the propagated cid has changed.
-  bool SetPropagatedCid(intptr_t cid);
+  // Update CompileType of the definition. Returns true if the type has changed.
+  virtual bool RecomputeType() {
+    return false;
+  }
 
   bool HasUses() const {
     return (input_use_list_ != NULL) || (env_use_list_ != NULL);
   }
 
   Value* input_use_list() const { return input_use_list_; }
   void set_input_use_list(Value* head) { input_use_list_ = head; }
 
   Value* env_use_list() const { return env_use_list_; }
   void set_env_use_list(Value* head) { env_use_list_ = head; }
@@ skipping 48 matching lines @@
     ASSERT(ssa_temp_index_ >= 0);
     ASSERT(WasEliminated());
     ssa_temp_index_ = kReplacementMarker;
     temp_index_ = reinterpret_cast<intptr_t>(other);
   }
 
  protected:
   friend class RangeAnalysis;
 
   Range* range_;
+  CompileType* type_;
 
  private:
   intptr_t temp_index_;
   intptr_t ssa_temp_index_;
-  // TODO(regis): GrowableArray<const AbstractType*> propagated_types_;
-  // For now:
-  AbstractType& propagated_type_;
-  intptr_t propagated_cid_;
   Value* input_use_list_;
   Value* env_use_list_;
   UseKind use_kind_;
 
   Object& constant_value_;
 
   DISALLOW_COPY_AND_ASSIGN(Definition);
 };
 
 
 class PhiInstr : public Definition {
  public:
   explicit PhiInstr(JoinEntryInstr* block, intptr_t num_inputs)
     : block_(block),
       inputs_(num_inputs),
       is_alive_(false),
       representation_(kTagged),
       reaching_defs_(NULL) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
     }
   }
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() const { return block(); }
   JoinEntryInstr* block() const { return block_; }
 
-  virtual RawAbstractType* CompileType() const;
-  virtual intptr_t GetPropagatedCid();
+  virtual CompileType* ComputeInitialType() const;
+  virtual bool RecomputeType();
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   void SetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  // TODO(regis): This helper will be removed once we support type sets.
-  RawAbstractType* LeastSpecificInputType() const;
-
   // Phi is alive if it reaches a non-environment use.
   bool is_alive() const { return is_alive_; }
   void mark_alive() { is_alive_ = true; }
   void mark_dead() { is_alive_ = false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t i) const {
     return representation_;
   }
 
   virtual Representation representation() const {
     return representation_;
   }
 
   virtual void set_representation(Representation r) {
     representation_ = r;
   }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
-  virtual intptr_t ResultCid() const {
-    UNREACHABLE();
-    return kIllegalCid;
-  }
-
   DECLARE_INSTRUCTION(Phi)
 
   virtual void PrintTo(BufferFormatter* f) const;
 
   virtual void InferRange();
 
   BitVector* reaching_defs() const {
     return reaching_defs_;
   }
 
@@ skipping 20 matching lines @@
   explicit ParameterInstr(intptr_t index, GraphEntryInstr* block)
       : index_(index), block_(block) { }
 
   DECLARE_INSTRUCTION(Parameter)
 
   intptr_t index() const { return index_; }
 
   // Get the block entry for that instruction.
   virtual BlockEntryInstr* GetBlock() const { return block_; }
 
-  // Compile type of the passed-in parameter.
-  virtual RawAbstractType* CompileType() const;
-
-  // No known propagated cid for parameters.
-  virtual intptr_t GetPropagatedCid();
-
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return 0; }
   Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
   void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
-  virtual intptr_t ResultCid() const {
-    UNREACHABLE();
-    return kIllegalCid;
-  }
-
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
+  virtual CompileType* ComputeInitialType() const;
+
  private:
   const intptr_t index_;
   GraphEntryInstr* block_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class PushArgumentInstr : public Definition {
  public:
   explicit PushArgumentInstr(Value* value) : value_(value), locs_(NULL) {
     ASSERT(value != NULL);
     set_use_kind(kEffect);  // Override the default.
   }
 
   DECLARE_INSTRUCTION(PushArgument)
 
   intptr_t InputCount() const { return 1; }
   Value* InputAt(intptr_t i) const {
     ASSERT(i == 0);
     return value_;
   }
   void SetInputAt(intptr_t i, Value* value) {
     ASSERT(i == 0);
     value_ = value;
   }
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
-  virtual RawAbstractType* CompileType() const;
-  virtual intptr_t GetPropagatedCid() { return propagated_cid(); }
-  virtual intptr_t ResultCid() const {
-    UNREACHABLE();
-    return kIllegalCid;
-  }
+  virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return value_; }
 
   virtual LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
@@ skipping 200 matching lines @@
 
 
 class StoreContextInstr : public TemplateInstruction<1> {
  public:
   explicit StoreContextInstr(Value* value) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(StoreContext);
-  virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
@@ skipping 198 matching lines @@
     inputs_[0] = value;
     inputs_[1] = NULL;  // Dependency.
   }
 
   DECLARE_INSTRUCTION(Constraint)
 
   virtual intptr_t InputCount() const {
     return (inputs_[1] == NULL) ? 1 : 2;
   }
 
-  virtual RawAbstractType* CompileType() const {
-    return Type::SmiType();
-  }
+  virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kSmiCid; }
-
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   Value* value() const { return inputs_[0]; }
   Range* constraint() const { return constraint_; }
 
@@ skipping 21 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ConstraintInstr);
 };
 
 
 class ConstantInstr : public TemplateDefinition<0> {
  public:
   explicit ConstantInstr(const Object& value)
       : value_(value) { }
 
   DECLARE_INSTRUCTION(Constant)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   const Object& value() const { return value_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const;
-
   virtual bool AttributesEqual(Instruction* other) const;
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual void InferRange();
 
  private:
   const Object& value_;
 
   DISALLOW_COPY_AND_ASSIGN(ConstantInstr);
 };
 
 
 class AssertAssignableInstr : public TemplateDefinition<3> {
  public:
   AssertAssignableInstr(intptr_t token_pos,
                         Value* value,
                         Value* instantiator,
                         Value* instantiator_type_arguments,
                         const AbstractType& dst_type,
                         const String& dst_name)
       : token_pos_(token_pos),
         dst_type_(AbstractType::ZoneHandle(dst_type.raw())),
-        dst_name_(dst_name),
-        is_eliminated_(false) {
+        dst_name_(dst_name) {
     ASSERT(value != NULL);
     ASSERT(instantiator != NULL);
     ASSERT(instantiator_type_arguments != NULL);
     ASSERT(!dst_type.IsNull());
     ASSERT(!dst_name.IsNull());
     inputs_[0] = value;
     inputs_[1] = instantiator;
     inputs_[2] = instantiator_type_arguments;
   }
 
   DECLARE_INSTRUCTION(AssertAssignable)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
+  virtual bool RecomputeType();
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
   intptr_t token_pos() const { return token_pos_; }
   const AbstractType& dst_type() const { return dst_type_; }
   void set_dst_type(const AbstractType& dst_type) {
     dst_type_ = dst_type.raw();
   }
   const String& dst_name() const { return dst_name_; }
 
-  bool is_eliminated() const {
-    return is_eliminated_;
-  }
-  void eliminate() {
-    ASSERT(!is_eliminated_);
-    is_eliminated_ = true;
-  }
-
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const;
 
-  virtual intptr_t ResultCid() const { return value()->ResultCid(); }
-  virtual intptr_t GetPropagatedCid();
-
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
  private:
   const intptr_t token_pos_;
   AbstractType& dst_type_;
   const String& dst_name_;
-  bool is_eliminated_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertAssignableInstr);
 };
 
 
 class AssertBooleanInstr : public TemplateDefinition<1> {
  public:
   AssertBooleanInstr(intptr_t token_pos, Value* value)
-      : token_pos_(token_pos),
-        is_eliminated_(false) {
+      : token_pos_(token_pos) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(AssertBoolean)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
-  bool is_eliminated() const {
-    return is_eliminated_;
-  }
-  void eliminate() {
-    ASSERT(!is_eliminated_);
-    is_eliminated_ = true;
-  }
-
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
-  virtual intptr_t ResultCid() const { return kBoolCid; }
-
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
  private:
   const intptr_t token_pos_;
-  bool is_eliminated_;
 
   DISALLOW_COPY_AND_ASSIGN(AssertBooleanInstr);
 };
 
 
 class ArgumentDefinitionTestInstr : public TemplateDefinition<1> {
  public:
   ArgumentDefinitionTestInstr(ArgumentDefinitionTestNode* node,
                               Value* saved_arguments_descriptor)
       : ast_node_(*node) {
     ASSERT(saved_arguments_descriptor != NULL);
     inputs_[0] = saved_arguments_descriptor;
   }
 
   DECLARE_INSTRUCTION(ArgumentDefinitionTest)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t formal_parameter_index() const {
     return ast_node_.formal_parameter_index();
   }
   const String& formal_parameter_name() const {
     return ast_node_.formal_parameter_name();
   }
+
   Value* saved_arguments_descriptor() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kBoolCid; }
-
  private:
   const ArgumentDefinitionTestNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(ArgumentDefinitionTestInstr);
 };
 
 
 // Denotes the current context, normally held in a register.  This is
 // a computation, not a value, because it's mutable.
 class CurrentContextInstr : public TemplateDefinition<0> {
  public:
   CurrentContextInstr() { }
 
   DECLARE_INSTRUCTION(CurrentContext)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
 class ClosureCallInstr : public TemplateDefinition<0> {
  public:
   ClosureCallInstr(ClosureCallNode* node,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         arguments_(arguments) { }
 
   DECLARE_INSTRUCTION(ClosureCall)
-  virtual RawAbstractType* CompileType() const;
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const ClosureCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallInstr);
 };
 
 
 class InstanceCallInstr : public TemplateDefinition<0> {
  public:
@@ skipping 16 matching lines @@
     ASSERT(Token::IsBinaryOperator(token_kind) ||
            Token::IsPrefixOperator(token_kind) ||
            Token::IsIndexOperator(token_kind) ||
            Token::IsTypeTestOperator(token_kind) ||
            token_kind == Token::kGET ||
            token_kind == Token::kSET ||
            token_kind == Token::kILLEGAL);
   }
 
   DECLARE_INSTRUCTION(InstanceCall)
-  virtual RawAbstractType* CompileType() const;
 
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
 
   // ICData can be replaced by optimizer.
   void set_ic_data(const ICData* value) { ic_data_ = value; }
 
   intptr_t token_pos() const { return token_pos_; }
   const String& function_name() const { return function_name_; }
   Token::Kind token_kind() const { return token_kind_; }
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  protected:
   friend class FlowGraphOptimizer;
   void set_ic_data(ICData* value) { ic_data_ = value; }
 
  private:
   const ICData* ic_data_;
   const intptr_t token_pos_;
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
@@ skipping 19 matching lines @@
   bool with_checks() const { return with_checks_; }
 
   virtual intptr_t ArgumentCount() const {
     return instance_call()->ArgumentCount();
   }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return instance_call()->ArgumentAt(index);
   }
 
   DECLARE_INSTRUCTION(PolymorphicInstanceCall)
-  virtual RawAbstractType* CompileType() const;
 
   const ICData& ic_data() const { return ic_data_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   InstanceCallInstr* instance_call_;
   const ICData& ic_data_;
   const bool with_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
 };
 
@@ skipping 76 matching lines @@
     intptr_t i) const {
   return comparison()->RequiredInputRepresentation(i);
 }
 
 
 class StrictCompareInstr : public ComparisonInstr {
  public:
   StrictCompareInstr(Token::Kind kind, Value* left, Value* right);
 
   DECLARE_INSTRUCTION(StrictCompare)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const;
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
-  virtual intptr_t ResultCid() const { return kBoolCid; }
-
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   bool needs_number_check() const { return needs_number_check_; }
   void set_needs_number_check(bool value) { needs_number_check_ = value; }
 
  private:
   // True if the comparison must check for double, Mint or Bigint and
   // use value comparison instead.
   bool needs_number_check_;
@@ skipping 10 matching lines @@
                        Value* right)
       : ComparisonInstr(kind, left, right),
         token_pos_(token_pos),
         receiver_class_id_(kIllegalCid) {
     // deopt_id() checks receiver_class_id_ value.
     ic_data_ = Isolate::Current()->GetICDataForDeoptId(deopt_id());
     ASSERT((kind == Token::kEQ) || (kind == Token::kNE));
   }
 
   DECLARE_INSTRUCTION(EqualityCompare)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
 
   intptr_t token_pos() const { return token_pos_; }
 
   // Receiver class id is computed from collected ICData.
   void set_receiver_class_id(intptr_t value) { receiver_class_id_ = value; }
   intptr_t receiver_class_id() const { return receiver_class_id_; }
 
+  bool IsInlinedNumericComparison() const {
+    return (receiver_class_id() == kDoubleCid)
+        || (receiver_class_id() == kMintCid)
+        || (receiver_class_id() == kSmiCid);
+  }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const {
-    return (receiver_class_id() != kDoubleCid)
-        && (receiver_class_id() != kMintCid)
-        && (receiver_class_id() != kSmiCid);
-  }
-  virtual bool HasSideEffect() const {
-    return (receiver_class_id() != kDoubleCid)
-        && (receiver_class_id() != kMintCid)
-        && (receiver_class_id() != kSmiCid);
+    return !IsInlinedNumericComparison();
   }
 
-  virtual intptr_t ResultCid() const;
+  virtual bool HasSideEffect() const {
+    return !IsInlinedNumericComparison();
+  }
 
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
   virtual intptr_t DeoptimizationTarget() const {
     return GetDeoptId();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
@@ skipping 21 matching lines @@
                     Value* right)
       : ComparisonInstr(kind, left, right),
         token_pos_(token_pos),
         operands_class_id_(kIllegalCid) {
     // deopt_id() checks operands_class_id_ value.
     ic_data_ = Isolate::Current()->GetICDataForDeoptId(deopt_id());
     ASSERT(Token::IsRelationalOperator(kind));
   }
 
   DECLARE_INSTRUCTION(RelationalOp)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   const ICData* ic_data() const { return ic_data_; }
   bool HasICData() const {
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
 
   intptr_t token_pos() const { return token_pos_; }
 
   // TODO(srdjan): instead of class-id pass an enum that can differentiate
   // between boxed and unboxed doubles and integers.
   void set_operands_class_id(intptr_t value) {
     operands_class_id_ = value;
   }
 
   intptr_t operands_class_id() const { return operands_class_id_; }
 
+  bool IsInlinedNumericComparison() const {
+    return (operands_class_id() == kDoubleCid)
+        || (operands_class_id() == kMintCid)
+        || (operands_class_id() == kSmiCid);
+  }
+
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const {
-    return (operands_class_id() != kDoubleCid)
-        && (operands_class_id() != kMintCid)
-        && (operands_class_id() != kSmiCid);
+    return !IsInlinedNumericComparison();
   }
   virtual bool HasSideEffect() const {
-    return (operands_class_id() != kDoubleCid)
-        && (operands_class_id() != kMintCid)
-        && (operands_class_id() != kSmiCid);
+    return !IsInlinedNumericComparison();
   }
 
-  virtual intptr_t ResultCid() const;
-
   virtual void EmitBranchCode(FlowGraphCompiler* compiler,
                               BranchInstr* branch);
 
 
   virtual intptr_t DeoptimizationTarget() const {
     return GetDeoptId();
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
@@ skipping 21 matching lines @@
         function_(function),
         argument_names_(argument_names),
         arguments_(arguments),
         result_cid_(kDynamicCid),
         is_known_constructor_(false) {
     ASSERT(function.IsZoneHandle());
     ASSERT(argument_names.IsZoneHandle());
   }
 
   DECLARE_INSTRUCTION(StaticCall)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   // Accessors forwarded to the AST node.
   const Function& function() const { return function_; }
   const Array& argument_names() const { return argument_names_; }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return result_cid_; }
   void set_result_cid(intptr_t value) { result_cid_ = value; }
 
   bool is_known_constructor() const { return is_known_constructor_; }
   void set_is_known_constructor(bool is_known_constructor) {
     is_known_constructor_ = is_known_constructor;
   }
 
  private:
   const intptr_t token_pos_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t result_cid_;  // For some library functions we know the result.
 
   // Some library constructors have known semantics.
   bool is_known_constructor_;
 
-
   DISALLOW_COPY_AND_ASSIGN(StaticCallInstr);
 };
 
 
 class LoadLocalInstr : public TemplateDefinition<0> {
  public:
   LoadLocalInstr(const LocalVariable& local, intptr_t context_level)
       : local_(local),
         context_level_(context_level) { }
 
   DECLARE_INSTRUCTION(LoadLocal)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   const LocalVariable& local() const { return local_; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const {
     UNREACHABLE();
     return false;
   }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
 };
 
 
 class StoreLocalInstr : public TemplateDefinition<1> {
  public:
   StoreLocalInstr(const LocalVariable& local,
                   Value* value,
                   intptr_t context_level)
       : local_(local),
         context_level_(context_level) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(StoreLocal)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
   intptr_t context_level() const { return context_level_; }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const {
     UNREACHABLE();
     return false;
   }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
 };
 
 
 class NativeCallInstr : public TemplateDefinition<0> {
  public:
   explicit NativeCallInstr(NativeBodyNode* node)
       : ast_node_(*node) {}
 
   DECLARE_INSTRUCTION(NativeCall)
-  virtual RawAbstractType* CompileType() const;
 
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   const Function& function() const { return ast_node_.function(); }
 
   const String& native_name() const {
     return ast_node_.native_c_function_name();
   }
 
   NativeFunction native_c_function() const {
     return ast_node_.native_c_function();
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const NativeBodyNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeCallInstr);
 };
 
 
 class StoreInstanceFieldInstr : public TemplateDefinition<2> {
  public:
   StoreInstanceFieldInstr(const Field& field,
                           Value* instance,
                           Value* value,
                           bool emit_store_barrier)
       : field_(field), emit_store_barrier_(emit_store_barrier) {
     ASSERT(instance != NULL);
     ASSERT(value != NULL);
     inputs_[0] = instance;
     inputs_[1] = value;
   }
 
   DECLARE_INSTRUCTION(StoreInstanceField)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
 
   Value* instance() const { return inputs_[0]; }
   Value* value() const { return inputs_[1]; }
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer() && emit_store_barrier_;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const Field& field_;
   const bool emit_store_barrier_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
 
 class LoadStaticFieldInstr : public TemplateDefinition<0> {
  public:
   explicit LoadStaticFieldInstr(const Field& field) : field_(field) {}
 
   DECLARE_INSTRUCTION(LoadStaticField);
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
   virtual bool AffectedBySideEffect() const { return !field().is_final(); }
   virtual bool AttributesEqual(Instruction* other) const;
 
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadStaticFieldInstr);
 };
 
 
 class StoreStaticFieldInstr : public TemplateDefinition<1> {
  public:
   StoreStaticFieldInstr(const Field& field, Value* value)
       : field_(field) {
     ASSERT(field.IsZoneHandle());
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(StoreStaticField);
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   const Field& field() const { return field_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const Field& field_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreStaticFieldInstr);
 };
 
 
 class LoadIndexedInstr : public TemplateDefinition<2> {
  public:
   LoadIndexedInstr(Value* array,
                    Value* index,
                    intptr_t index_scale,
                    intptr_t class_id,
                    intptr_t deopt_id)
       : index_scale_(index_scale), class_id_(class_id) {
     ASSERT(array != NULL);
     ASSERT(index != NULL);
     inputs_[0] = array;
     inputs_[1] = index;
     deopt_id_ = deopt_id;
   }
 
   DECLARE_INSTRUCTION(LoadIndexed)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   intptr_t index_scale() const { return index_scale_; }
   intptr_t class_id() const { return class_id_; }
 
   virtual bool CanDeoptimize() const {
     return deopt_id_ != Isolate::kNoDeoptId;
   }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const;
-
   virtual Representation representation() const;
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual bool AffectedBySideEffect() const { return true; }
 
   virtual void InferRange();
 
  private:
   const intptr_t index_scale_;
   const intptr_t class_id_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadIndexedInstr);
 };
 
 
 class StringFromCharCodeInstr : public TemplateDefinition<1> {
  public:
   explicit StringFromCharCodeInstr(Value* char_code,
                                    intptr_t cid) : cid_(cid) {
     ASSERT(char_code != NULL);
     ASSERT(char_code->definition()->IsLoadIndexed() &&
            (char_code->definition()->AsLoadIndexed()->class_id() ==
             kOneByteStringCid));
     inputs_[0] = char_code;
   }
 
   DECLARE_INSTRUCTION(StringFromCharCode)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   Value* char_code() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const {  return cid_; }
-
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
  private:
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(StringFromCharCodeInstr);
 };
 
@@ skipping 11 matching lines @@
         deopt_id_(deopt_id) {
     ASSERT(array != NULL);
     ASSERT(index != NULL);
     ASSERT(value != NULL);
     inputs_[0] = array;
     inputs_[1] = index;
     inputs_[2] = value;
   }
 
   DECLARE_INSTRUCTION(StoreIndexed)
-  virtual RawAbstractType* CompileType() const;
 
   Value* array() const { return inputs_[0]; }
   Value* index() const { return inputs_[1]; }
   Value* value() const { return inputs_[2]; }
   intptr_t class_id() const { return class_id_; }
 
   bool ShouldEmitStoreBarrier() const {
     return value()->NeedsStoreBuffer() && emit_store_barrier_;
   }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
   virtual Representation RequiredInputRepresentation(intptr_t idx) const;
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
  private:
   const bool emit_store_barrier_;
   const intptr_t class_id_;
   const intptr_t deopt_id_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreIndexedInstr);
 };
 
 
 // Note overrideable, built-in: value? false : true.
 class BooleanNegateInstr : public TemplateDefinition<1> {
  public:
   explicit BooleanNegateInstr(Value* value) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(BooleanNegate)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kBoolCid; }
-
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
 
 
 class InstanceOfInstr : public TemplateDefinition<3> {
  public:
   InstanceOfInstr(intptr_t token_pos,
                   Value* value,
                   Value* instantiator,
                   Value* instantiator_type_arguments,
                   const AbstractType& type,
                   bool negate_result)
       : token_pos_(token_pos),
         type_(type),
         negate_result_(negate_result) {
     ASSERT(value != NULL);
     ASSERT(instantiator != NULL);
     ASSERT(instantiator_type_arguments != NULL);
     ASSERT(!type.IsNull());
     inputs_[0] = value;
     inputs_[1] = instantiator;
     inputs_[2] = instantiator_type_arguments;
   }
 
   DECLARE_INSTRUCTION(InstanceOf)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return inputs_[0]; }
   Value* instantiator() const { return inputs_[1]; }
   Value* instantiator_type_arguments() const { return inputs_[2]; }
 
   bool negate_result() const { return negate_result_; }
   const AbstractType& type() const { return type_; }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kBoolCid; }
-
  private:
   const intptr_t token_pos_;
   Value* value_;
   Value* instantiator_;
   Value* type_arguments_;
   const AbstractType& type_;
   const bool negate_result_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceOfInstr);
 };
 
 
 class AllocateObjectInstr : public TemplateDefinition<0> {
  public:
   AllocateObjectInstr(ConstructorCallNode* node,
                       ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         arguments_(arguments),
         cid_(Class::Handle(node->constructor().Owner()).id()) {
     // Either no arguments or one type-argument and one instantiator.
     ASSERT(arguments->is_empty() || (arguments->length() == 2));
   }
 
   DECLARE_INSTRUCTION(AllocateObject)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return cid_; }
-
  private:
   const ConstructorCallNode& ast_node_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const intptr_t cid_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectInstr);
 };
 
 
 class AllocateObjectWithBoundsCheckInstr : public TemplateDefinition<2> {
  public:
   AllocateObjectWithBoundsCheckInstr(ConstructorCallNode* node,
                                      Value* type_arguments,
                                      Value* instantiator)
       : ast_node_(*node) {
     ASSERT(type_arguments != NULL);
     ASSERT(instantiator != NULL);
     inputs_[0] = type_arguments;
     inputs_[1] = instantiator;
   }
 
   DECLARE_INSTRUCTION(AllocateObjectWithBoundsCheck)
-  virtual RawAbstractType* CompileType() const;
 
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const ConstructorCallNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateObjectWithBoundsCheckInstr);
 };
 
 
 class CreateArrayInstr : public TemplateDefinition<1> {
  public:
   CreateArrayInstr(intptr_t token_pos,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments,
                    const AbstractType& type,
                    Value* element_type)
       : token_pos_(token_pos),
         arguments_(arguments),
         type_(type) {
 #if defined(DEBUG)
     for (int i = 0; i < ArgumentCount(); ++i) {
       ASSERT(ArgumentAt(i) != NULL);
     }
     ASSERT(element_type != NULL);
     ASSERT(type_.IsZoneHandle());
     ASSERT(!type_.IsNull());
     ASSERT(type_.IsFinalized());
 #endif
     inputs_[0] = element_type;
   }
 
   DECLARE_INSTRUCTION(CreateArray)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
 
   intptr_t token_pos() const { return token_pos_; }
   PushArgumentInstr* ArgumentAt(intptr_t i) const { return (*arguments_)[i]; }
   const AbstractType& type() const { return type_; }
   Value* element_type() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kArrayCid; }
-
  private:
   const intptr_t token_pos_;
   ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayInstr);
 };
 
 
 class CreateClosureInstr : public TemplateDefinition<0> {
  public:
   CreateClosureInstr(const Function& function,
                      ZoneGrowableArray<PushArgumentInstr*>* arguments,
                      intptr_t token_pos)
       : function_(function),
         arguments_(arguments),
         token_pos_(token_pos) { }
 
   DECLARE_INSTRUCTION(CreateClosure)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   const Function& function() const { return function_; }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const Function& function_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateClosureInstr);
 };
 
 
 class LoadFieldInstr : public TemplateDefinition<1> {
  public:
   LoadFieldInstr(Value* value,
                  intptr_t offset_in_bytes,
                  const AbstractType& type,
                  bool immutable = false)
       : offset_in_bytes_(offset_in_bytes),
         type_(type),
         result_cid_(kDynamicCid),
         immutable_(immutable),
         recognized_kind_(MethodRecognizer::kUnknown) {
     ASSERT(value != NULL);
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(LoadField)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return inputs_[0]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
   void set_result_cid(intptr_t value) { result_cid_ = value; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return result_cid_; }
-
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual bool AffectedBySideEffect() const { return !immutable_; }
 
   virtual void InferRange();
 
   void set_recognized_kind(MethodRecognizer::Kind kind) {
     recognized_kind_ = kind;
   }
 
@@ skipping 27 matching lines @@
                     const AbstractType& type)
       : offset_in_bytes_(offset_in_bytes), type_(type) {
     ASSERT(value != NULL);
     ASSERT(dest != NULL);
     ASSERT(type.IsZoneHandle());  // May be null if field is not an instance.
     inputs_[0] = value;
     inputs_[1] = dest;
   }
 
   DECLARE_INSTRUCTION(StoreVMField)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   Value* value() const { return inputs_[0]; }
   Value* dest() const { return inputs_[1]; }
   intptr_t offset_in_bytes() const { return offset_in_bytes_; }
   const AbstractType& type() const { return type_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const intptr_t offset_in_bytes_;
   const AbstractType& type_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreVMFieldInstr);
 };
 
 
 class InstantiateTypeArgumentsInstr : public TemplateDefinition<1> {
  public:
   InstantiateTypeArgumentsInstr(intptr_t token_pos,
                                 const AbstractTypeArguments& type_arguments,
                                 Value* instantiator)
       : token_pos_(token_pos),
         type_arguments_(type_arguments) {
     ASSERT(type_arguments.IsZoneHandle());
     ASSERT(instantiator != NULL);
     inputs_[0] = instantiator;
   }
 
   DECLARE_INSTRUCTION(InstantiateTypeArguments)
-  virtual RawAbstractType* CompileType() const;
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const intptr_t token_pos_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(InstantiateTypeArgumentsInstr);
 };
 
 
 class ExtractConstructorTypeArgumentsInstr : public TemplateDefinition<1> {
  public:
   ExtractConstructorTypeArgumentsInstr(
       intptr_t token_pos,
       const AbstractTypeArguments& type_arguments,
       Value* instantiator)
       : token_pos_(token_pos),
         type_arguments_(type_arguments) {
     ASSERT(instantiator != NULL);
     inputs_[0] = instantiator;
   }
 
   DECLARE_INSTRUCTION(ExtractConstructorTypeArguments)
-  virtual RawAbstractType* CompileType() const;
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return type_arguments_;
   }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const intptr_t token_pos_;
   const AbstractTypeArguments& type_arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorTypeArgumentsInstr);
 };
 
 
 class ExtractConstructorInstantiatorInstr : public TemplateDefinition<1> {
  public:
   ExtractConstructorInstantiatorInstr(ConstructorCallNode* ast_node,
                                       Value* instantiator)
       : ast_node_(*ast_node) {
     ASSERT(instantiator != NULL);
     inputs_[0] = instantiator;
   }
 
   DECLARE_INSTRUCTION(ExtractConstructorInstantiator)
-  virtual RawAbstractType* CompileType() const;
 
   Value* instantiator() const { return inputs_[0]; }
   const AbstractTypeArguments& type_arguments() const {
     return ast_node_.type_arguments();
   }
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const ConstructorCallNode& ast_node_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtractConstructorInstantiatorInstr);
 };
 
 
 class AllocateContextInstr : public TemplateDefinition<0> {
  public:
   AllocateContextInstr(intptr_t token_pos,
                        intptr_t num_context_variables)
       : token_pos_(token_pos),
         num_context_variables_(num_context_variables) {}
 
   DECLARE_INSTRUCTION(AllocateContext);
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t num_context_variables() const { return num_context_variables_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   const intptr_t token_pos_;
   const intptr_t num_context_variables_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocateContextInstr);
 };
 
 
 class ChainContextInstr : public TemplateInstruction<1> {
  public:
   explicit ChainContextInstr(Value* context_value) {
     ASSERT(context_value != NULL);
     inputs_[0] = context_value;
   }
 
   DECLARE_INSTRUCTION(ChainContext)
-  virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   Value* context_value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChainContextInstr);
 };
 
 
 class CloneContextInstr : public TemplateDefinition<1> {
  public:
   CloneContextInstr(intptr_t token_pos, Value* context_value)
       : token_pos_(token_pos) {
     ASSERT(context_value != NULL);
     inputs_[0] = context_value;
   }
 
   intptr_t token_pos() const { return token_pos_; }
   Value* context_value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(CloneContext)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kContextCid; }
-
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
 };
 
 
 class CatchEntryInstr : public TemplateInstruction<0> {
  public:
   CatchEntryInstr(const LocalVariable& exception_var,
                   const LocalVariable& stacktrace_var)
       : exception_var_(exception_var), stacktrace_var_(stacktrace_var) {}
 
   const LocalVariable& exception_var() const { return exception_var_; }
   const LocalVariable& stacktrace_var() const { return stacktrace_var_; }
 
   DECLARE_INSTRUCTION(CatchEntry)
-  virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
  private:
@@ skipping 10 matching lines @@
                          Value* right,
                          InstanceCallInstr* instance_call) {
     ASSERT(left != NULL);
     ASSERT(right != NULL);
     inputs_[0] = left;
     inputs_[1] = right;
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckEitherNonSmi)
-  virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
@@ skipping 21 matching lines @@
 
   intptr_t token_pos() const { return token_pos_; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
-  virtual intptr_t ResultCid() const;
-
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   DECLARE_INSTRUCTION(BoxDouble)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
 };
 
 
 class BoxIntegerInstr : public TemplateDefinition<1> {
  public:
   explicit BoxIntegerInstr(Value* value) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
-  virtual intptr_t ResultCid() const;
-
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedMint;
   }
 
   DECLARE_INSTRUCTION(BoxInteger)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxIntegerInstr);
 };
 
 
 class UnboxDoubleInstr : public TemplateDefinition<1> {
  public:
   UnboxDoubleInstr(Value* value, intptr_t deopt_id) {
     ASSERT(value != NULL);
     inputs_[0] = value;
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
-    return (value()->ResultCid() != kDoubleCid)
-        && (value()->ResultCid() != kSmiCid);
+    return (value()->Type()->ToCid() != kDoubleCid)
+        && (value()->Type()->ToCid() != kSmiCid);
   }
 
   virtual bool HasSideEffect() const { return false; }
 
-  // The output is not an instance but when it is boxed it becomes double.
-  virtual intptr_t ResultCid() const { return kDoubleCid; }
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   DECLARE_INSTRUCTION(UnboxDouble)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(UnboxDoubleInstr);
 };
 
 
 class UnboxIntegerInstr : public TemplateDefinition<1> {
  public:
   UnboxIntegerInstr(Value* value, intptr_t deopt_id) {
     ASSERT(value != NULL);
     inputs_[0] = value;
     deopt_id_ = deopt_id;
   }
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const {
-    return (value()->ResultCid() != kMintCid)
-        && (value()->ResultCid() != kSmiCid);
+    return (value()->Type()->ToCid() != kSmiCid)
+        && (value()->Type()->ToCid() != kMintCid);
   }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const;
-
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   DECLARE_INSTRUCTION(UnboxInteger)
@@ skipping 14 matching lines @@
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return true;
   }
 
-  // The output is not an instance but when it is boxed it becomes double.
-  virtual intptr_t ResultCid() const { return kDoubleCid; }
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(MathSqrt)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MathSqrtInstr);
 };
 
 
 class BinaryDoubleOpInstr : public TemplateDefinition<2> {
  public:
   BinaryDoubleOpInstr(Token::Kind op_kind,
                       Value* left,
@@ skipping 17 matching lines @@
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryDoubleOp()->op_kind();
   }
 
-  virtual intptr_t ResultCid() const;
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const {
     // Direct access since this instruction cannot deoptimize, and the deopt-id
     // was inherited from another instruction that could deoptimize.
     return deopt_id_;
   }
 
   DECLARE_INSTRUCTION(BinaryDoubleOp)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(BinaryDoubleOpInstr);
 };
 
 
@@ skipping 23 matching lines @@
   }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsBinaryMintOp()->op_kind();
   }
 
-  virtual intptr_t ResultCid() const;
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return kUnboxedMint;
   }
 
@@ skipping 39 matching lines @@
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsShiftMintOp()->op_kind();
   }
 
-  virtual intptr_t ResultCid() const;
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((idx == 0) || (idx == 1));
     return (idx == 0) ? kUnboxedMint : kTagged;
   }
 
@@ skipping 33 matching lines @@
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     return op_kind() == other->AsUnaryMintOp()->op_kind();
   }
 
-  virtual intptr_t ResultCid() const;
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual Representation representation() const {
     return kUnboxedMint;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedMint;
   }
 
@@ skipping 34 matching lines @@
   Token::Kind op_kind() const { return op_kind_; }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   const ICData* ic_data() const { return instance_call()->ic_data(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(BinarySmiOp)
 
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const;
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const;
 
-  virtual intptr_t ResultCid() const;
-
   void set_overflow(bool overflow) {
     overflow_ = overflow;
   }
 
   void PrintTo(BufferFormatter* f) const;
 
   virtual void InferRange();
 
   virtual Definition* Canonicalize(FlowGraphOptimizer* optimizer);
 
@@ skipping 22 matching lines @@
     inputs_[0] = value;
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
   Token::Kind op_kind() const { return op_kind_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   DECLARE_INSTRUCTION(UnarySmiOp)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return op_kind() == Token::kNEGATE; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kSmiCid; }
-
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
 };
 
 
 class CheckStackOverflowInstr : public TemplateInstruction<0> {
  public:
   explicit CheckStackOverflowInstr(intptr_t token_pos)
       : token_pos_(token_pos) {}
 
   intptr_t token_pos() const { return token_pos_; }
 
   DECLARE_INSTRUCTION(CheckStackOverflow)
-  virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CheckStackOverflowInstr);
 };
 
 
 class SmiToDoubleInstr : public TemplateDefinition<0> {
  public:
   explicit SmiToDoubleInstr(InstanceCallInstr* instance_call)
       : instance_call_(instance_call) { }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   DECLARE_INSTRUCTION(SmiToDouble)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kDoubleCid; }
-
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(SmiToDoubleInstr);
 };
 
 
 class DoubleToIntegerInstr : public TemplateDefinition<1> {
  public:
   DoubleToIntegerInstr(Value* value, InstanceCallInstr* instance_call)
       : instance_call_(instance_call) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   Value* value() const { return inputs_[0]; }
   InstanceCallInstr* instance_call() const { return instance_call_; }
 
   DECLARE_INSTRUCTION(DoubleToInteger)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  // Result could be any of the int types.
-  virtual intptr_t ResultCid() const { return kDynamicCid; }
-
  private:
   InstanceCallInstr* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(DoubleToIntegerInstr);
 };
 
 
 // Similar to 'DoubleToIntegerInstr' but expects unboxed double as input
 // and creates a Smi.
 class DoubleToSmiInstr : public TemplateDefinition<1> {
  public:
   DoubleToSmiInstr(Value* value, InstanceCallInstr* instance_call) {
     ASSERT(value != NULL);
     inputs_[0] = value;
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   DECLARE_INSTRUCTION(DoubleToSmi)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kSmiCid; }
-
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DoubleToSmiInstr);
 };
 
 
 class DoubleToDoubleInstr : public TemplateDefinition<1> {
  public:
   DoubleToDoubleInstr(Value* value,
                       InstanceCallInstr* instance_call,
                       MethodRecognizer::Kind recognized_kind)
     : recognized_kind_(recognized_kind) {
     ASSERT(value != NULL);
     inputs_[0] = value;
     deopt_id_ = instance_call->deopt_id();
   }
 
   Value* value() const { return inputs_[0]; }
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(DoubleToDouble)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kDoubleCid; }
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
@@ skipping 15 matching lines @@
     deopt_id_ = instance_call->deopt_id();
   }
 
   static intptr_t ArgumentCountFor(MethodRecognizer::Kind recognized_kind_);
 
   const RuntimeEntry& TargetFunction() const;
 
   MethodRecognizer::Kind recognized_kind() const { return recognized_kind_; }
 
   DECLARE_INSTRUCTION(InvokeMathCFunction)
-  virtual RawAbstractType* CompileType() const;
+  virtual CompileType* ComputeInitialType() const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual intptr_t ResultCid() const { return kDoubleCid; }
-
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT((0 <= idx) && (idx < InputCount()));
     return kUnboxedDouble;
   }
 
   virtual intptr_t DeoptimizationTarget() const { return deopt_id_; }
@@ skipping 31 matching lines @@
 };
 
 
 class CheckClassInstr : public TemplateInstruction<1> {
  public:
   CheckClassInstr(Value* value,
                   intptr_t deopt_id,
                   const ICData& unary_checks);
 
   DECLARE_INSTRUCTION(CheckClass)
-  virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual bool AffectedBySideEffect() const;
@@ skipping 16 matching lines @@
 class CheckSmiInstr : public TemplateInstruction<1> {
  public:
   CheckSmiInstr(Value* value, intptr_t original_deopt_id) {
     ASSERT(value != NULL);
     ASSERT(original_deopt_id != Isolate::kNoDeoptId);
     inputs_[0] = value;
     deopt_id_ = original_deopt_id;
   }
 
   DECLARE_INSTRUCTION(CheckSmi)
-  virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
@@ skipping 15 matching lines @@
                        InstanceCallInstr* instance_call)
       : array_type_(array_type) {
     ASSERT(length != NULL);
     ASSERT(index != NULL);
     inputs_[0] = length;
     inputs_[1] = index;
     deopt_id_ = instance_call->deopt_id();
   }
 
   DECLARE_INSTRUCTION(CheckArrayBound)
-  virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const;
 
   virtual bool AffectedBySideEffect() const { return false; }
@@ skipping 239 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_