Return void from array setters since the return value needs to be ignored

src/objects.cc

 // Copyright 2013 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 <iomanip>
 #include <sstream>
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 14674 matching lines @@
     TYPED_ARRAYS(INSTANCE_TYPE_TO_ELEMENT_SIZE)
 #undef INSTANCE_TYPE_TO_ELEMENT_SIZE
 
     default:
       UNREACHABLE();
       return 0;
   }
 }
 
 
-Handle<Object> FixedArray::SetValue(Handle<JSObject> holder,
-                                    Handle<FixedArray> array, uint32_t index,
-                                    Handle<Object> value) {
+void FixedArray::SetValue(Handle<JSObject> holder, Handle<FixedArray> array,
+                          uint32_t index, Handle<Object> value) {
   array->set(index, *value);
-  return value;
 }
 
 
-Handle<Object> FixedDoubleArray::SetValue(Handle<JSObject> holder,
-                                          Handle<FixedDoubleArray> array,
-                                          uint32_t index,
-                                          Handle<Object> value) {
+void FixedDoubleArray::SetValue(Handle<JSObject> holder,
+                                Handle<FixedDoubleArray> array, uint32_t index,
+                                Handle<Object> value) {
   array->set(index, value->Number());
-  return value;
 }
 
 
-Handle<Object> ExternalUint8ClampedArray::SetValue(
+void ExternalUint8ClampedArray::SetValue(
     Handle<JSObject> holder, Handle<ExternalUint8ClampedArray> array,
     uint32_t index, Handle<Object> value) {
   uint8_t clamped_value = 0;
   Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
   if (!view->WasNeutered()) {
     if (index < static_cast<uint32_t>(array->length())) {
       if (value->IsSmi()) {
         int int_value = Handle<Smi>::cast(value)->value();
         if (int_value < 0) {
           clamped_value = 0;
@@ skipping 15 matching lines @@
           clamped_value = static_cast<uint8_t>(lrint(double_value));
         }
       } else {
         // Clamp undefined to zero (default). All other types have been
         // converted to a number type further up in the call chain.
         DCHECK(value->IsUndefined());
       }
       array->set(index, clamped_value);
     }
   }
-  return handle(Smi::FromInt(clamped_value), array->GetIsolate());
 }
 
 
 template <typename ExternalArrayClass, typename ValueType>
-static Handle<Object> ExternalArrayIntSetter(
-    Isolate* isolate, Handle<JSObject> holder,
-    Handle<ExternalArrayClass> receiver, uint32_t index, Handle<Object> value) {
+static void ExternalArrayIntSetter(Isolate* isolate, Handle<JSObject> holder,
+                                   Handle<ExternalArrayClass> receiver,
+                                   uint32_t index, Handle<Object> value) {
   ValueType cast_value = 0;
   Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
   if (!view->WasNeutered()) {
     if (index < static_cast<uint32_t>(receiver->length())) {
       if (value->IsSmi()) {
         int int_value = Handle<Smi>::cast(value)->value();
         cast_value = static_cast<ValueType>(int_value);
       } else if (value->IsHeapNumber()) {
         double double_value = Handle<HeapNumber>::cast(value)->value();
         cast_value = static_cast<ValueType>(DoubleToInt32(double_value));
       } else {
         // Clamp undefined to zero (default). All other types have been
         // converted to a number type further up in the call chain.
         DCHECK(value->IsUndefined());
       }
       receiver->set(index, cast_value);
     }
   }
-  return isolate->factory()->NewNumberFromInt(cast_value);
 }
 
 
-Handle<Object> ExternalInt8Array::SetValue(Handle<JSObject> holder,
-                                           Handle<ExternalInt8Array> array,
-                                           uint32_t index,
-                                           Handle<Object> value) {
-  return ExternalArrayIntSetter<ExternalInt8Array, int8_t>(
+void ExternalInt8Array::SetValue(Handle<JSObject> holder,
+                                 Handle<ExternalInt8Array> array,
+                                 uint32_t index, Handle<Object> value) {
+  ExternalArrayIntSetter<ExternalInt8Array, int8_t>(array->GetIsolate(), holder,
+                                                    array, index, value);
+}
+
+
+void ExternalUint8Array::SetValue(Handle<JSObject> holder,
+                                  Handle<ExternalUint8Array> array,
+                                  uint32_t index, Handle<Object> value) {
+  ExternalArrayIntSetter<ExternalUint8Array, uint8_t>(
       array->GetIsolate(), holder, array, index, value);
 }
 
 
-Handle<Object> ExternalUint8Array::SetValue(Handle<JSObject> holder,
-                                            Handle<ExternalUint8Array> array,
-                                            uint32_t index,
-                                            Handle<Object> value) {
-  return ExternalArrayIntSetter<ExternalUint8Array, uint8_t>(
+void ExternalInt16Array::SetValue(Handle<JSObject> holder,
+                                  Handle<ExternalInt16Array> array,
+                                  uint32_t index, Handle<Object> value) {
+  ExternalArrayIntSetter<ExternalInt16Array, int16_t>(
       array->GetIsolate(), holder, array, index, value);
 }
 
 
-Handle<Object> ExternalInt16Array::SetValue(Handle<JSObject> holder,
-                                            Handle<ExternalInt16Array> array,
-                                            uint32_t index,
-                                            Handle<Object> value) {
-  return ExternalArrayIntSetter<ExternalInt16Array, int16_t>(
+void ExternalUint16Array::SetValue(Handle<JSObject> holder,
+                                   Handle<ExternalUint16Array> array,
+                                   uint32_t index, Handle<Object> value) {
+  ExternalArrayIntSetter<ExternalUint16Array, uint16_t>(
       array->GetIsolate(), holder, array, index, value);
 }
 
 
-Handle<Object> ExternalUint16Array::SetValue(Handle<JSObject> holder,
-                                             Handle<ExternalUint16Array> array,
-                                             uint32_t index,
-                                             Handle<Object> value) {
-  return ExternalArrayIntSetter<ExternalUint16Array, uint16_t>(
+void ExternalInt32Array::SetValue(Handle<JSObject> holder,
+                                  Handle<ExternalInt32Array> array,
+                                  uint32_t index, Handle<Object> value) {
+  ExternalArrayIntSetter<ExternalInt32Array, int32_t>(
       array->GetIsolate(), holder, array, index, value);
 }
 
 
-Handle<Object> ExternalInt32Array::SetValue(Handle<JSObject> holder,
-                                            Handle<ExternalInt32Array> array,
-                                            uint32_t index,
-                                            Handle<Object> value) {
-  return ExternalArrayIntSetter<ExternalInt32Array, int32_t>(
-      array->GetIsolate(), holder, array, index, value);
-}
-
-
-Handle<Object> ExternalUint32Array::SetValue(Handle<JSObject> holder,
-                                             Handle<ExternalUint32Array> array,
-                                             uint32_t index,
-                                             Handle<Object> value) {
+void ExternalUint32Array::SetValue(Handle<JSObject> holder,
+                                   Handle<ExternalUint32Array> array,
+                                   uint32_t index, Handle<Object> value) {
   uint32_t cast_value = 0;
   Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
   if (!view->WasNeutered()) {
     if (index < static_cast<uint32_t>(array->length())) {
       if (value->IsSmi()) {
         int int_value = Handle<Smi>::cast(value)->value();
         cast_value = static_cast<uint32_t>(int_value);
       } else if (value->IsHeapNumber()) {
         double double_value = Handle<HeapNumber>::cast(value)->value();
         cast_value = static_cast<uint32_t>(DoubleToUint32(double_value));
       } else {
         // Clamp undefined to zero (default). All other types have been
         // converted to a number type further up in the call chain.
         DCHECK(value->IsUndefined());
       }
       array->set(index, cast_value);
     }
   }
-  return array->GetIsolate()->factory()->NewNumberFromUint(cast_value);
 }
 
 
-Handle<Object> ExternalFloat32Array::SetValue(
-    Handle<JSObject> holder, Handle<ExternalFloat32Array> array, uint32_t index,
-    Handle<Object> value) {
+void ExternalFloat32Array::SetValue(Handle<JSObject> holder,
+                                    Handle<ExternalFloat32Array> array,
+                                    uint32_t index, Handle<Object> value) {
   float cast_value = std::numeric_limits<float>::quiet_NaN();
   Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
   if (!view->WasNeutered()) {
     if (index < static_cast<uint32_t>(array->length())) {
       if (value->IsSmi()) {
         int int_value = Handle<Smi>::cast(value)->value();
         cast_value = static_cast<float>(int_value);
       } else if (value->IsHeapNumber()) {
         double double_value = Handle<HeapNumber>::cast(value)->value();
         cast_value = static_cast<float>(double_value);
       } else {
         // Clamp undefined to NaN (default). All other types have been
         // converted to a number type further up in the call chain.
         DCHECK(value->IsUndefined());
       }
       array->set(index, cast_value);
     }
   }
-  return array->GetIsolate()->factory()->NewNumber(cast_value);
 }
 
 
-Handle<Object> ExternalFloat64Array::SetValue(
-    Handle<JSObject> holder, Handle<ExternalFloat64Array> array, uint32_t index,
-    Handle<Object> value) {
+void ExternalFloat64Array::SetValue(Handle<JSObject> holder,
+                                    Handle<ExternalFloat64Array> array,
+                                    uint32_t index, Handle<Object> value) {
   double double_value = std::numeric_limits<double>::quiet_NaN();
   Handle<JSArrayBufferView> view = Handle<JSArrayBufferView>::cast(holder);
   if (!view->WasNeutered()) {
     if (index < static_cast<uint32_t>(array->length())) {
       if (value->IsNumber()) {
         double_value = value->Number();
       } else {
         // Clamp undefined to NaN (default). All other types have been
         // converted to a number type further up in the call chain.
         DCHECK(value->IsUndefined());
       }
       array->set(index, double_value);
     }
   }
-  return array->GetIsolate()->factory()->NewNumber(double_value);
 }
 
 
 void GlobalObject::InvalidatePropertyCell(Handle<GlobalObject> global,
                                           Handle<Name> name) {
   DCHECK(!global->HasFastProperties());
   auto dictionary = handle(global->global_dictionary());
   int entry = dictionary->FindEntry(name);
   if (entry == GlobalDictionary::kNotFound) return;
   PropertyCell::InvalidateEntry(dictionary, entry);
@@ skipping 1804 matching lines @@
                                             Handle<Object> new_value) {
   if (cell->value() != *new_value) {
     cell->set_value(*new_value);
     Isolate* isolate = cell->GetIsolate();
     cell->dependent_code()->DeoptimizeDependentCodeGroup(
         isolate, DependentCode::kPropertyCellChangedGroup);
   }
 }
 }  // namespace internal
 }  // namespace v8