return obj;
}
+ // TODO(ishell): Temporary wrapper until handlified.
+ MUST_USE_RESULT static Handle<Object> SetFastElementsCapacityAndLength(
+ Handle<JSObject> obj,
+ int capacity,
+ int length) {
+ CALL_HEAP_FUNCTION(obj->GetIsolate(),
+ SetFastElementsCapacityAndLength(*obj, capacity, length),
+ Object);
+ }
+
MUST_USE_RESULT virtual Handle<Object> Delete(
Handle<JSObject> obj,
uint32_t key,
// Adjusts the length of the fast backing store or returns the new length or
// undefined in case conversion to a slow backing store should be performed.
- static MaybeObject* SetLengthWithoutNormalize(FixedArrayBase* backing_store,
- JSArray* array,
- Object* length_object,
- uint32_t length) {
+ static Handle<Object> SetLengthWithoutNormalize(
+ Handle<FixedArrayBase> backing_store,
+ Handle<JSArray> array,
+ Handle<Object> length_object,
+ uint32_t length) {
+ Isolate* isolate = array->GetIsolate();
uint32_t old_capacity = backing_store->length();
- Object* old_length = array->length();
+ Handle<Object> old_length(array->length(), isolate);
bool same_or_smaller_size = old_length->IsSmi() &&
- static_cast<uint32_t>(Smi::cast(old_length)->value()) >= length;
+ static_cast<uint32_t>(Handle<Smi>::cast(old_length)->value()) >= length;
ElementsKind kind = array->GetElementsKind();
if (!same_or_smaller_size && IsFastElementsKind(kind) &&
!IsFastHoleyElementsKind(kind)) {
kind = GetHoleyElementsKind(kind);
- MaybeObject* maybe_obj = array->TransitionElementsKind(kind);
- if (maybe_obj->IsFailure()) return maybe_obj;
+ JSObject::TransitionElementsKind(array, kind);
}
// Check whether the backing store should be shrunk.
if (length <= old_capacity) {
if (array->HasFastSmiOrObjectElements()) {
- MaybeObject* maybe_obj = array->EnsureWritableFastElements();
- if (!maybe_obj->To(&backing_store)) return maybe_obj;
+ backing_store = JSObject::EnsureWritableFastElements(array);
}
if (2 * length <= old_capacity) {
// If more than half the elements won't be used, trim the array.
// Otherwise, fill the unused tail with holes.
int old_length = FastD2IChecked(array->length()->Number());
for (int i = length; i < old_length; i++) {
- BackingStore::cast(backing_store)->set_the_hole(i);
+ Handle<BackingStore>::cast(backing_store)->set_the_hole(i);
}
}
return length_object;
uint32_t min = JSObject::NewElementsCapacity(old_capacity);
uint32_t new_capacity = length > min ? length : min;
if (!array->ShouldConvertToSlowElements(new_capacity)) {
- MaybeObject* result = FastElementsAccessorSubclass::
+ FastElementsAccessorSubclass::
SetFastElementsCapacityAndLength(array, new_capacity, length);
- if (result->IsFailure()) return result;
array->ValidateElements();
return length_object;
}
// Request conversion to slow elements.
- return array->GetHeap()->undefined_value();
- }
-
- // TODO(ishell): Temporary wrapper until handlified.
- static Handle<Object> SetLengthWithoutNormalize(
- Handle<FixedArrayBase> backing_store,
- Handle<JSArray> array,
- Handle<Object> length_object,
- uint32_t length) {
- CALL_HEAP_FUNCTION(array->GetIsolate(),
- SetLengthWithoutNormalize(
- *backing_store, *array, *length_object, length),
- Object);
+ return isolate->factory()->undefined_value();
}
static Handle<Object> DeleteCommon(Handle<JSObject> obj,
length,
set_capacity_mode);
}
+
+ // TODO(ishell): Temporary wrapper until handlified.
+ static Handle<Object> SetFastElementsCapacityAndLength(
+ Handle<JSObject> obj,
+ int capacity,
+ int length) {
+ CALL_HEAP_FUNCTION(obj->GetIsolate(),
+ SetFastElementsCapacityAndLength(*obj, capacity, length),
+ Object);
+ }
};
length);
}
+ // TODO(ishell): Temporary wrapper until handlified.
+ static Handle<Object> SetFastElementsCapacityAndLength(
+ Handle<JSObject> obj,
+ int capacity,
+ int length) {
+ CALL_HEAP_FUNCTION(obj->GetIsolate(),
+ SetFastElementsCapacityAndLength(*obj, capacity, length),
+ Object);
+ }
+
protected:
static MaybeObject* CopyElementsImpl(FixedArrayBase* from,
uint32_t from_start,