Unify implementations of Map handles vectors and lists

src/feedback-vector.cc

 // Copyright 2014 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/feedback-vector.h"
 #include "src/code-stubs.h"
 #include "src/feedback-vector-inl.h"
 #include "src/ic/ic-inl.h"
 #include "src/ic/ic-state.h"
 #include "src/objects.h"
@@ skipping 628 matching lines @@
     SetFeedback(*cell);
     SetFeedbackExtra(*handler);
   } else {
     Handle<FixedArray> array = EnsureExtraArrayOfSize(2);
     SetFeedback(*name);
     array->set(0, *cell);
     array->set(1, *handler);
   }
 }
 
-void FeedbackNexus::ConfigurePolymorphic(Handle<Name> name, MapHandleList* maps,
+void FeedbackNexus::ConfigurePolymorphic(Handle<Name> name,
+                                         MapHandles const& maps,
                                          List<Handle<Object>>* handlers) {
-  int receiver_count = maps->length();
+  int receiver_count = static_cast<int>(maps.size());
   DCHECK(receiver_count > 1);
   Handle<FixedArray> array;
   if (name.is_null()) {
     array = EnsureArrayOfSize(receiver_count * 2);
     SetFeedbackExtra(*FeedbackVector::UninitializedSentinel(GetIsolate()),
                      SKIP_WRITE_BARRIER);
   } else {
     array = EnsureExtraArrayOfSize(receiver_count * 2);
     SetFeedback(*name);
   }
 
   for (int current = 0; current < receiver_count; ++current) {
-    Handle<Map> map = maps->at(current);
+    Handle<Map> map = maps[current];
     Handle<WeakCell> cell = Map::WeakCellForMap(map);
     array->set(current * 2, *cell);
     array->set(current * 2 + 1, *handlers->at(current));
   }
 }
 
-int FeedbackNexus::ExtractMaps(MapHandleList* maps) const {
+int FeedbackNexus::ExtractMaps(MapHandles* maps) const {
   Isolate* isolate = GetIsolate();
   Object* feedback = GetFeedback();
   bool is_named_feedback = IsPropertyNameFeedback(feedback);
   if (feedback->IsFixedArray() || is_named_feedback) {
     int found = 0;
     if (is_named_feedback) {
       feedback = GetFeedbackExtra();
     }
     FixedArray* array = FixedArray::cast(feedback);
     const int increment = 2;
     for (int i = 0; i < array->length(); i += increment) {
       DCHECK(array->get(i)->IsWeakCell());
       WeakCell* cell = WeakCell::cast(array->get(i));
       if (!cell->cleared()) {
         Map* map = Map::cast(cell->value());
-        maps->Add(handle(map, isolate));
+        maps->push_back(handle(map, isolate));
         found++;
       }
     }
     return found;
   } else if (feedback->IsWeakCell()) {
     WeakCell* cell = WeakCell::cast(feedback);
     if (!cell->cleared()) {
       Map* map = Map::cast(cell->value());
-      maps->Add(handle(map, isolate));
+      maps->push_back(handle(map, isolate));
       return 1;
     }
   }
 
   return 0;
 }
 
 MaybeHandle<Object> FeedbackNexus::FindHandlerForMap(Handle<Map> map) const {
   Object* feedback = GetFeedback();
   Isolate* isolate = GetIsolate();
@@ skipping 77 matching lines @@
 Name* KeyedStoreICNexus::FindFirstName() const {
   Object* feedback = GetFeedback();
   if (IsPropertyNameFeedback(feedback)) {
     return Name::cast(feedback);
   }
   return NULL;
 }
 
 KeyedAccessStoreMode KeyedStoreICNexus::GetKeyedAccessStoreMode() const {
   KeyedAccessStoreMode mode = STANDARD_STORE;
-  MapHandleList maps;
+  MapHandles maps;
   List<Handle<Object>> handlers;
 
   if (GetKeyType() == PROPERTY) return mode;
 
   ExtractMaps(&maps);
-  FindHandlers(&handlers, maps.length());
+  FindHandlers(&handlers, static_cast<int>(maps.size()));
   for (int i = 0; i < handlers.length(); i++) {
     // The first handler that isn't the slow handler will have the bits we need.
     Handle<Object> maybe_code_handler = handlers.at(i);
     Handle<Code> handler;
     if (maybe_code_handler->IsTuple3()) {
       // Elements transition.
       Handle<Tuple3> data_handler = Handle<Tuple3>::cast(maybe_code_handler);
       handler = handle(Code::cast(data_handler->value2()));
     } else if (maybe_code_handler->IsTuple2()) {
       // Element store with prototype chain check.
@@ skipping 170 matching lines @@
     return *isolate->factory()->NewJSMap();
   }
 
   return *ConvertToJSObject(
       isolate, Handle<UnseededNumberDictionary>(
                    UnseededNumberDictionary::cast(feedback), isolate));
 }
 
 }  // namespace internal
 }  // namespace v8