Use FeedbackVectorSlotKind instead of Code::Kind for type feedback vector.

src/ast.cc

 // 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.
 
 #include "src/ast.h"
 
 #include <cmath>  // For isfinite.
 #include "src/builtins.h"
 #include "src/code-stubs.h"
 #include "src/contexts.h"
@@ skipping 123 matching lines @@
     if ((assign_type == VARIABLE &&
          expr->AsVariableProxy()->var()->IsUnallocated()) ||
         assign_type == NAMED_PROPERTY || assign_type == KEYED_PROPERTY) {
       ic_slots++;
     }
   }
   return ic_slots;
 }
 
 
-static Code::Kind GetStoreICKind(Expression* expr) {
+static FeedbackVectorSlotKind GetStoreICKind(Expression* expr) {
   LhsKind assign_type = Property::GetAssignType(expr->AsProperty());
-  return assign_type == KEYED_PROPERTY ? Code::KEYED_STORE_IC : Code::STORE_IC;
+  return assign_type == KEYED_PROPERTY ? FeedbackVectorSlotKind::KEYED_STORE_IC
+                                       : FeedbackVectorSlotKind::STORE_IC;
 }
 
 
 FeedbackVectorRequirements ForEachStatement::ComputeFeedbackRequirements(
     Isolate* isolate, const ICSlotCache* cache) {
   int ic_slots = GetStoreICSlots(each());
   return FeedbackVectorRequirements(0, ic_slots);
 }
 
 
-Code::Kind ForEachStatement::FeedbackICSlotKind(int index) {
+FeedbackVectorSlotKind ForEachStatement::FeedbackICSlotKind(int index) {
   return GetStoreICKind(each());
 }
 
 
 Assignment::Assignment(Zone* zone, Token::Value op, Expression* target,
                        Expression* value, int pos)
     : Expression(zone, pos),
       bit_field_(
           IsUninitializedField::encode(false) | KeyTypeField::encode(ELEMENT) |
           StoreModeField::encode(STANDARD_STORE) | TokenField::encode(op)),
       target_(target),
       value_(value),
       binary_operation_(NULL),
       slot_(FeedbackVectorICSlot::Invalid()) {}
 
 
 FeedbackVectorRequirements Assignment::ComputeFeedbackRequirements(
     Isolate* isolate, const ICSlotCache* cache) {
   int ic_slots = GetStoreICSlots(target());
   return FeedbackVectorRequirements(0, ic_slots);
 }
 
 
-Code::Kind Assignment::FeedbackICSlotKind(int index) {
+FeedbackVectorSlotKind Assignment::FeedbackICSlotKind(int index) {
   return GetStoreICKind(target());
 }
 
 
 FeedbackVectorRequirements CountOperation::ComputeFeedbackRequirements(
     Isolate* isolate, const ICSlotCache* cache) {
   int ic_slots = GetStoreICSlots(expression());
   return FeedbackVectorRequirements(0, ic_slots);
 }
 
 
-Code::Kind CountOperation::FeedbackICSlotKind(int index) {
+FeedbackVectorSlotKind CountOperation::FeedbackICSlotKind(int index) {
   return GetStoreICKind(expression());
 }
 
 
 Token::Value Assignment::binary_op() const {
   switch (op()) {
     case Token::ASSIGN_BIT_OR: return Token::BIT_OR;
     case Token::ASSIGN_BIT_XOR: return Token::BIT_XOR;
     case Token::ASSIGN_BIT_AND: return Token::BIT_AND;
     case Token::ASSIGN_SHL: return Token::SHL;
@@ skipping 983 matching lines @@
 bool Literal::Match(void* literal1, void* literal2) {
   const AstValue* x = static_cast<Literal*>(literal1)->raw_value();
   const AstValue* y = static_cast<Literal*>(literal2)->raw_value();
   return (x->IsString() && y->IsString() && x->AsString() == y->AsString()) ||
          (x->IsNumber() && y->IsNumber() && x->AsNumber() == y->AsNumber());
 }
 
 
 }  // namespace internal
 }  // namespace v8