[api] Cleaning up: Replace NeanderArray with FixedArray implementation

src/api-natives.cc

 // Copyright 2015 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/api-natives.h"
 
 #include "src/api.h"
 #include "src/isolate-inl.h"
 #include "src/lookup.h"
 #include "src/messages.h"
@@ skipping 166 matching lines @@
                                         Handle<TemplateInfoT> data,
                                         bool is_hidden_prototype) {
   HandleScope scope(isolate);
   // Disable access checks while instantiating the object.
   AccessCheckDisableScope access_check_scope(isolate, obj);
 
   // Walk the inheritance chain and copy all accessors to current object.
   int max_number_of_properties = 0;
   TemplateInfoT* info = *data;
   while (info != nullptr) {
-    if (!info->property_accessors()->IsUndefined(isolate)) {
-      Object* props = info->property_accessors();
-      if (!props->IsUndefined(isolate)) {
-        Handle<Object> props_handle(props, isolate);
-        NeanderArray props_array(props_handle);
-        max_number_of_properties += props_array.length();
-      }
+    Object* props = info->property_accessors();
+    if (!props->IsUndefined(isolate)) {
+      max_number_of_properties += TemplateList::cast(props)->length();
     }
     info = info->GetParent(isolate);
   }
 
   if (max_number_of_properties > 0) {
     int valid_descriptors = 0;
     // Use a temporary FixedArray to accumulate unique accessors.
     Handle<FixedArray> array =
         isolate->factory()->NewFixedArray(max_number_of_properties);
 
     info = *data;
     while (info != nullptr) {
       // Accumulate accessors.
-      if (!info->property_accessors()->IsUndefined(isolate)) {
-        Handle<Object> props(info->property_accessors(), isolate);
-        valid_descriptors =
-            AccessorInfo::AppendUnique(props, array, valid_descriptors);
+      Object* maybe_properties = info->property_accessors();
+      if (!maybe_properties->IsUndefined(isolate)) {
+        valid_descriptors = AccessorInfo::AppendUnique(
+            handle(maybe_properties, isolate), array, valid_descriptors);
       }
       info = info->GetParent(isolate);
     }
 
     // Install accumulated accessors.
     for (int i = 0; i < valid_descriptors; i++) {
       Handle<AccessorInfo> accessor(AccessorInfo::cast(array->get(i)));
       JSObject::SetAccessor(obj, accessor).Assert();
     }
   }
 
-  auto property_list = handle(data->property_list(), isolate);
-  if (property_list->IsUndefined(isolate)) return obj;
-  // TODO(dcarney): just use a FixedArray here.
-  NeanderArray properties(property_list);
-  if (properties.length() == 0) return obj;
+  Object* maybe_property_list = data->property_list();
+  if (maybe_property_list->IsUndefined(isolate)) return obj;
+  Handle<TemplateList> properties(TemplateList::cast(maybe_property_list),
+                                  isolate);
+  if (properties->length() == 0) return obj;
 
   int i = 0;
   for (int c = 0; c < data->number_of_properties(); c++) {
-    auto name = handle(Name::cast(properties.get(i++)), isolate);
-    Object* bit = properties.get(i++);
+    auto name = handle(Name::cast(properties->get(i++)), isolate);
+    Object* bit = properties->get(i++);
     if (bit->IsSmi()) {
       PropertyDetails details(Smi::cast(bit));
       PropertyAttributes attributes = details.attributes();
       PropertyKind kind = details.kind();
 
       if (kind == kData) {
-        auto prop_data = handle(properties.get(i++), isolate);
+        auto prop_data = handle(properties->get(i++), isolate);
         RETURN_ON_EXCEPTION(isolate, DefineDataProperty(isolate, obj, name,
                                                         prop_data, attributes),
                             JSObject);
       } else {
-        auto getter = handle(properties.get(i++), isolate);
-        auto setter = handle(properties.get(i++), isolate);
+        auto getter = handle(properties->get(i++), isolate);
+        auto setter = handle(properties->get(i++), isolate);
         RETURN_ON_EXCEPTION(
             isolate, DefineAccessorProperty(isolate, obj, name, getter, setter,
                                             attributes, is_hidden_prototype),
             JSObject);
       }
     } else {
       // Intrinsic data property --- Get appropriate value from the current
       // context.
-      PropertyDetails details(Smi::cast(properties.get(i++)));
+      PropertyDetails details(Smi::cast(properties->get(i++)));
       PropertyAttributes attributes = details.attributes();
       DCHECK_EQ(kData, details.kind());
 
       v8::Intrinsic intrinsic =
-          static_cast<v8::Intrinsic>(Smi::cast(properties.get(i++))->value());
+          static_cast<v8::Intrinsic>(Smi::cast(properties->get(i++))->value());
       auto prop_data = handle(GetIntrinsic(isolate, intrinsic), isolate);
 
       RETURN_ON_EXCEPTION(isolate, DefineDataProperty(isolate, obj, name,
                                                       prop_data, attributes),
                           JSObject);
     }
   }
   return obj;
 }
 
@@ skipping 197 matching lines @@
       UncacheTemplateInstantiation(isolate, serial_number);
     }
     return MaybeHandle<JSFunction>();
   }
   return function;
 }
 
 
 void AddPropertyToPropertyList(Isolate* isolate, Handle<TemplateInfo> templ,
                                int length, Handle<Object>* data) {
-  auto list = handle(templ->property_list(), isolate);
-  if (list->IsUndefined(isolate)) {
-    list = NeanderArray(isolate).value();
-    templ->set_property_list(*list);
+  Object* maybe_list = templ->property_list();
+  Handle<TemplateList> list;
+  if (maybe_list->IsUndefined(isolate)) {
+    list = TemplateList::New(isolate, length);
+  } else {
+    list = handle(TemplateList::cast(maybe_list), isolate);
   }
   templ->set_number_of_properties(templ->number_of_properties() + 1);
-  NeanderArray array(list);
   for (int i = 0; i < length; i++) {
     Handle<Object> value =
         data[i].is_null()
             ? Handle<Object>::cast(isolate->factory()->undefined_value())
             : data[i];
-    array.add(isolate, value);
+    list = TemplateList::Add(isolate, list, value);
   }
+  templ->set_property_list(*list);
 }
 
 }  // namespace
 
 
 MaybeHandle<JSFunction> ApiNatives::InstantiateFunction(
     Handle<FunctionTemplateInfo> data) {
   Isolate* isolate = data->GetIsolate();
   InvokeScope invoke_scope(isolate);
   return ::v8::internal::InstantiateFunction(isolate, data);
@@ skipping 70 matching lines @@
   PropertyDetails details(attributes, ACCESSOR, 0, PropertyCellType::kNoCell);
   auto details_handle = handle(details.AsSmi(), isolate);
   Handle<Object> data[kSize] = {name, details_handle, getter, setter};
   AddPropertyToPropertyList(isolate, info, kSize, data);
 }
 
 
 void ApiNatives::AddNativeDataProperty(Isolate* isolate,
                                        Handle<TemplateInfo> info,
                                        Handle<AccessorInfo> property) {
-  auto list = handle(info->property_accessors(), isolate);
-  if (list->IsUndefined(isolate)) {
-    list = NeanderArray(isolate).value();
-    info->set_property_accessors(*list);
+  Object* maybe_list = info->property_accessors();
+  Handle<TemplateList> list;
+  if (maybe_list->IsUndefined(isolate)) {
+    list = TemplateList::New(isolate, 1);
+  } else {
+    list = handle(TemplateList::cast(maybe_list), isolate);
   }
-  NeanderArray array(list);
-  array.add(isolate, property);
+  list = TemplateList::Add(isolate, list, property);
+  info->set_property_accessors(*list);
 }
 
 
 Handle<JSFunction> ApiNatives::CreateApiFunction(
     Isolate* isolate, Handle<FunctionTemplateInfo> obj,
     Handle<Object> prototype, ApiInstanceType instance_type) {
   Handle<SharedFunctionInfo> shared =
       FunctionTemplateInfo::GetOrCreateSharedFunctionInfo(isolate, obj);
   Handle<JSFunction> result =
       isolate->factory()->NewFunctionFromSharedFunctionInfo(
@@ skipping 86 matching lines @@
   if (!obj->instance_call_handler()->IsUndefined(isolate)) {
     map->set_is_callable();
     map->set_is_constructor(true);
   }
 
   return result;
 }
 
 }  // namespace internal
 }  // namespace v8