Ensure that compile time types for comparisons are recomputed once comparison are specialized.

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 95 matching lines @@
 //
 // 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 {
+class CompileType {

[srdjan, 2013/02/22 21:01:41]

This should be subclass of ValueObject?

[Vyacheslav Egorov (Google), 2013/02/22 22:22:33]

I can make it, but our ValueObject is a strange beast --- e.g. there is a
comment that suggests that we will enable DISALLOW_COPY_AND_ASSIGN for it which
will turn it into NotSoMuchValueObject.

I honestly don't see much of a value in extending ValueObject. All normal
structures *are* values already, by default.

  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.
@@ skipping 16 matching lines @@
   // 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);
+  static CompileType Create(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,
+  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);
+  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);
+  static CompileType None() {
+    return 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 Dynamic();
 
-  static CompileType* Null();
+  static CompileType Null();
 
   // Create non-nullable Bool type.
-  static CompileType* Bool();
+  static CompileType Bool();
 
   // Create non-nullable Int type.
-  static CompileType* Int();
+  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) {

[srdjan, 2013/02/22 21:01:41]

make const CompileType& other, since other may not always be wrapped.

[Vyacheslav Egorov (Google), 2013/02/22 22:22:33]

It'd like to do this, but I can't because ToNullableCid and ToAbstractType are
lazily initializing parts of CompileType (e.g. if type is there and cid is not
there, cid will be computed from type if CHA says that its a leaf type) thus
they are not const members and thus can't be used on a const reference.

     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_;
 };
 
 
+// Zone allocated wrapper for the CompileType value.
+class ZoneCompileType : public ZoneAllocated {
+ public:
+  static CompileType* Wrap(const CompileType& type) {
+    ZoneCompileType* zone_type = new ZoneCompileType(type);
+    return &zone_type->type_;
+  }
+
+ private:
+  explicit ZoneCompileType(const CompileType& type) : type_(type) { }
+
+  CompileType 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() {
@@ skipping 1008 matching lines @@
 
   // Compile time type of the definition, which may be requested before type
   // propagation during graph building.
   CompileType* Type() {
     if (type_ == NULL) {
       type_ = ComputeInitialType();
     }
     return type_;
   }
 
-  // Compute initial compile type for this definition. It is safe to use this
+  virtual CompileType* ComputeInitialType() const {
+    return ZoneCompileType::Wrap(ComputeType());
+  }
+
+  // Compute 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 {
+  virtual CompileType ComputeType() const {
     return CompileType::Dynamic();
   }
 
   // Update CompileType of the definition. Returns true if the type has changed.
   virtual bool RecomputeType() {
     return false;
   }
 
+  bool UpdateType(CompileType new_type) {
+    if (type_ == NULL) {
+      type_ = ZoneCompileType::Wrap(new_type);
+      return true;
+    }
+
+    if (type_->IsNone() || !type_->IsEqualTo(&new_type)) {
+      *type_ = new_type;
+      return true;
+    }
+
+    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 79 matching lines @@
       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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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; }
 
@@ skipping 76 matching lines @@
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual intptr_t Hashcode() const {
     UNREACHABLE();
     return 0;
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
  private:
   const intptr_t index_;
   GraphEntryInstr* block_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class PushArgumentInstr : public Definition {
@@ skipping 10 matching lines @@
     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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   Value* value() const { return value_; }
 
   virtual LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
@@ skipping 423 matching lines @@
     inputs_[0] = value;
     inputs_[1] = NULL;  // Dependency.
   }
 
   DECLARE_INSTRUCTION(Constraint)
 
   virtual intptr_t InputCount() const {
     return (inputs_[1] == NULL) ? 1 : 2;
   }
 
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const {
     UNREACHABLE();
     return false;
   }
 
@@ skipping 26 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(ConstraintInstr);
 };
 
 
 class ConstantInstr : public TemplateDefinition<0> {
  public:
   explicit ConstantInstr(const Object& value)
       : value_(value) { }
 
   DECLARE_INSTRUCTION(Constant)
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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 bool AttributesEqual(Instruction* other) const;
@@ skipping 66 matching lines @@
 
 class AssertBooleanInstr : public TemplateDefinition<1> {
  public:
   AssertBooleanInstr(intptr_t token_pos, Value* value)
       : token_pos_(token_pos) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(AssertBoolean)
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   Value* value() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
@@ skipping 12 matching lines @@
 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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]; }
@@ skipping 11 matching lines @@
 };
 
 
 // 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurrentContextInstr);
 };
 
 
@@ skipping 216 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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; }
 
@@ skipping 22 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
+  virtual bool RecomputeType();
 
   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; }
@@ skipping 48 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
+  virtual bool RecomputeType();
 
   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.
@@ skipping 52 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
@@ skipping 25 matching lines @@
 };
 
 
 class LoadLocalInstr : public TemplateDefinition<0> {
  public:
   LoadLocalInstr(const LocalVariable& local, intptr_t context_level)
       : local_(local),
         context_level_(context_level) { }
 
   DECLARE_INSTRUCTION(LoadLocal)
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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();
@@ skipping 114 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(StoreInstanceFieldInstr);
 };
 
 
 class LoadStaticFieldInstr : public TemplateDefinition<0> {
  public:
   explicit LoadStaticFieldInstr(const Field& field) : field_(field) {}
 
   DECLARE_INSTRUCTION(LoadStaticField);
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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 bool AffectedBySideEffect() const { return !field().is_final(); }
@@ skipping 43 matching lines @@
                    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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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;
   }
 
@@ skipping 20 matching lines @@
   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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   Value* char_code() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual bool AffectedBySideEffect() const { return false; }
@@ skipping 58 matching lines @@
 
 // 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   Value* value() const { return inputs_[0]; }
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BooleanNegateInstr);
 };
@@ skipping 13 matching lines @@
     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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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;
@@ skipping 19 matching lines @@
   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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(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;
@@ skipping 53 matching lines @@
 #if defined(DEBUG)
     ASSERT(element_type != NULL);
     ASSERT(type_.IsZoneHandle());
     ASSERT(!type_.IsNull());
     ASSERT(type_.IsFinalized());
 #endif
     inputs_[0] = element_type;
   }
 
   DECLARE_INSTRUCTION(CreateArray)
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   intptr_t num_elements() const { return num_elements_; }
 
   intptr_t token_pos() const { return token_pos_; }
   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; }
@@ skipping 12 matching lines @@
 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   const Function& function() const { return function_; }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
   virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
@@ skipping 21 matching lines @@
         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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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; }
 
@@ skipping 165 matching lines @@
 
 
 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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; }
 
@@ skipping 32 matching lines @@
   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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(CloneContextInstr);
 };
@@ skipping 79 matching lines @@
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
   DECLARE_INSTRUCTION(BoxDouble)
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
  private:
   const intptr_t token_pos_;
 
   DISALLOW_COPY_AND_ASSIGN(BoxDoubleInstr);
 };
 
 
 class BoxIntegerInstr : public TemplateDefinition<1> {
  public:
@@ skipping 10 matching lines @@
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedMint;
   }
 
   DECLARE_INSTRUCTION(BoxInteger)
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BoxIntegerInstr);
 };
 
 
 class UnboxDoubleInstr : public TemplateDefinition<1> {
  public:
   UnboxDoubleInstr(Value* value, intptr_t deopt_id) {
     ASSERT(value != NULL);
@@ skipping 11 matching lines @@
   virtual bool HasSideEffect() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const { return true; }
 
   DECLARE_INSTRUCTION(UnboxDouble)
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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()->Type()->ToCid() != kSmiCid)
         && (value()->Type()->ToCid() != kMintCid);
   }
 
   virtual bool HasSideEffect() const { return false; }
 
-  virtual CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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 30 matching lines @@
     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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MathSqrtInstr);
 };
 
 
 class BinaryDoubleOpInstr : public TemplateDefinition<2> {
  public:
   BinaryDoubleOpInstr(Token::Kind op_kind,
                       Value* left,
@@ skipping 33 matching lines @@
     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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const;
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual bool AffectedBySideEffect() const { return false; }
   virtual bool AttributesEqual(Instruction* other) const;
 
   void set_overflow(bool overflow) {
     overflow_ = overflow;
@@ skipping 30 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return op_kind() == Token::kNEGATE; }
 
   virtual bool HasSideEffect() const { return false; }
 
  private:
   const Token::Kind op_kind_;
 
   DISALLOW_COPY_AND_ASSIGN(UnarySmiOpInstr);
 };
@@ skipping 22 matching lines @@
 
 
 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
  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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual intptr_t ArgumentCount() const { return 1; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
  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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
     ASSERT(idx == 0);
     return kUnboxedDouble;
   }
 
@@ skipping 13 matching lines @@
     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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
   virtual Representation RequiredInputRepresentation(intptr_t idx) const {
@@ skipping 20 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 CompileType* ComputeInitialType() const;
+  virtual CompileType ComputeType() const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return false; }
 
   virtual Representation representation() const {
     return kUnboxedDouble;
   }
 
@@ skipping 367 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_