Fix type feedback for name-keyed stores

src/ast.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_AST_H_
 #define V8_AST_H_
 
 #include "src/v8.h"
 
 #include "src/assembler.h"
@@ skipping 359 matching lines @@
     return false;
   }
   virtual SmallMapList* GetReceiverTypes() {
     UNREACHABLE();
     return NULL;
   }
   virtual KeyedAccessStoreMode GetStoreMode() {
     UNREACHABLE();
     return STANDARD_STORE;
   }
+  virtual IcCheckType GetKeyType() {
+    UNREACHABLE();
+    return ELEMENT;
+  }
 
   // TODO(rossberg): this should move to its own AST node eventually.
   virtual void RecordToBooleanTypeFeedback(TypeFeedbackOracle* oracle);
   byte to_boolean_types() const { return to_boolean_types_; }
 
   BailoutId id() const { return BailoutId(base_id() + 0); }
   TypeFeedbackId test_id() const { return TypeFeedbackId(base_id() + 1); }
 
  protected:
   Expression(Zone* zone, int pos, int num_ids_needed_by_subclass, IdGen* id_gen)
@@ skipping 1704 matching lines @@
   }
 
   Expression* expression() const { return expression_; }
 
   virtual bool IsMonomorphic() OVERRIDE {
     return receiver_types_.length() == 1;
   }
   virtual SmallMapList* GetReceiverTypes() OVERRIDE {
     return &receiver_types_;
   }
+  virtual IcCheckType GetKeyType() OVERRIDE { return key_type_; }
   virtual KeyedAccessStoreMode GetStoreMode() OVERRIDE {
     return store_mode_;
   }
   Type* type() const { return type_; }
+  void set_key_type(IcCheckType type) { key_type_ = type; }
   void set_store_mode(KeyedAccessStoreMode mode) { store_mode_ = mode; }
   void set_type(Type* type) { type_ = type; }
 
   BailoutId AssignmentId() const { return BailoutId(base_id() + 0); }
   TypeFeedbackId CountBinOpFeedbackId() const {
     return TypeFeedbackId(base_id() + 1);
   }
   TypeFeedbackId CountStoreFeedbackId() const {
     return TypeFeedbackId(base_id() + 2);
   }
 
  protected:
   CountOperation(Zone* zone, Token::Value op, bool is_prefix, Expression* expr,
                  int pos, IdGen* id_gen)
       : Expression(zone, pos, num_ids(), id_gen),
         op_(op),
         is_prefix_(is_prefix),
         store_mode_(STANDARD_STORE),
         expression_(expr) {}
 
   static int num_ids() { return 3; }
   int base_id() const { return Expression::base_id() + Expression::num_ids(); }
 
  private:
   Token::Value op_;
   bool is_prefix_ : 1;
+  IcCheckType key_type_ : 1;
   KeyedAccessStoreMode store_mode_ : 5;  // Windows treats as signed,
                                          // must have extra bit.
   Type* type_;
   Expression* expression_;
   SmallMapList receiver_types_;
 };
 
 
 class CompareOperation FINAL : public Expression {
  public:
@@ skipping 92 matching lines @@
   virtual bool IsMonomorphic() OVERRIDE {
     return receiver_types_.length() == 1;
   }
   bool IsUninitialized() { return is_uninitialized_; }
   bool HasNoTypeInformation() {
     return is_uninitialized_;
   }
   virtual SmallMapList* GetReceiverTypes() OVERRIDE {
     return &receiver_types_;
   }
+  virtual IcCheckType GetKeyType() OVERRIDE { return key_type_; }
   virtual KeyedAccessStoreMode GetStoreMode() OVERRIDE {
     return store_mode_;
   }
   void set_is_uninitialized(bool b) { is_uninitialized_ = b; }
+  void set_key_type(IcCheckType key_type) { key_type_ = key_type; }
   void set_store_mode(KeyedAccessStoreMode mode) { store_mode_ = mode; }
 
  protected:
   Assignment(Zone* zone, Token::Value op, Expression* target, Expression* value,
              int pos, IdGen* id_gen);
 
   static int num_ids() { return 2; }
   int base_id() const { return Expression::base_id() + Expression::num_ids(); }
 
   template<class Visitor>
   void Init(Zone* zone, AstNodeFactory<Visitor>* factory) {
     DCHECK(Token::IsAssignmentOp(op_));
     if (is_compound()) {
       binary_operation_ = factory->NewBinaryOperation(
           binary_op(), target_, value_, position() + 1);
     }
   }
 
  private:
   Token::Value op_;
   Expression* target_;
   Expression* value_;
   BinaryOperation* binary_operation_;
   bool is_uninitialized_ : 1;
+  IcCheckType key_type_ : 1;
   KeyedAccessStoreMode store_mode_ : 5;  // Windows treats as signed,
                                          // must have extra bit.
   SmallMapList receiver_types_;
 };
 
 
 class Yield FINAL : public Expression {
  public:
   DECLARE_NODE_TYPE(Yield)
 
@@ skipping 1340 matching lines @@
   Zone* zone_;
   Visitor visitor_;
   AstValueFactory* ast_value_factory_;
   AstNode::IdGen* id_gen_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_