#pragma once

#include "ArrayConstructor.h"

#include "ArrayPrototype.h"

#include "CommonIdentifiers.h"

#include "Error.h"

#include "ExceptionHelpers.h"

#include "GetVM.h"

#include "JSGlobalObject.h"

#include "JSStringJoiner.h"

#include "JSStringInlines.h"

#include "ObjectPrototype.h"

namespace JSC {

enum class SpeciesConstructResult : uint8_t {

};

ALWAYS_INLINE bool arraySpeciesWatchpointIsValid(VM& vm, JSObject* thisObject)

}

ALWAYS_INLINE bool arrayMissingIsConcatSpreadable(VM& vm, JSObject* thisObject)

}

ALWAYS_INLINE std::pair<SpeciesConstructResult, JSObject*> speciesConstructArray(JSGlobalObject* globalObject, JSObject* thisObject, uint64_t length)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

constexpr std::pair<SpeciesConstructResult, JSObject*> exceptionResult { SpeciesConstructResult::Exception, nullptr };

// ECMA 9.4.2.3: https://tc39.github.io/ecma262/#sec-arrayspeciescreate

JSValue constructor = jsUndefined();

bool thisIsArray = isArray(globalObject, thisObject);

RETURN_IF_EXCEPTION(scope, exceptionResult);

if (thisIsArray) [[likely]] {

// Fast path in the normal case where the user has not set an own constructor and the Array.prototype.constructor is normal.

// We need prototype check for subclasses of Array, which are Array objects but have a different prototype by default.

bool isValid = isJSArray(thisObject) && arraySpeciesWatchpointIsValid(vm, thisObject);

RETURN_IF_EXCEPTION(scope, exceptionResult);

if (isValid) [[likely]]

return std::pair { SpeciesConstructResult::FastPath, nullptr };

constructor = thisObject->get(globalObject, vm.propertyNames->constructor);

RETURN_IF_EXCEPTION(scope, exceptionResult);

if (constructor.isConstructor()) {

JSObject* constructorObject = uncheckedDowncast<JSObject>(constructor);

bool isArrayConstructorFromAnotherRealm = globalObject != constructorObject->realm()

&& constructorObject->inherits<ArrayConstructor>();

if (isArrayConstructorFromAnotherRealm)

return std::pair { SpeciesConstructResult::FastPath, nullptr };

}

if (constructor.isObject()) {

constructor = constructor.get(globalObject, vm.propertyNames->speciesSymbol);

RETURN_IF_EXCEPTION(scope, exceptionResult);

if (constructor.isNull())

return std::pair { SpeciesConstructResult::FastPath, nullptr };

}

} else {

// If isArray is false, return ? ArrayCreate(length).

return std::pair { SpeciesConstructResult::FastPath, nullptr };

}

if (constructor.isUndefined())

return std::pair { SpeciesConstructResult::FastPath, nullptr };

auto args = WTF::toArray<EncodedJSValue>({

JSValue::encode(jsNumber(length)),

});

JSObject* newObject = construct(globalObject, constructor, ArgList { args.data(), args.size() }, "Species construction did not get a valid constructor"_s);

RETURN_IF_EXCEPTION(scope, exceptionResult);

return std::pair { SpeciesConstructResult::CreatedObject, newObject };

}

ALWAYS_INLINE void setLength(JSGlobalObject* globalObject, VM& vm, JSObject* obj, uint64_t value)

}

template<JSArray::ShiftCountMode shiftCountMode>

void shift(JSGlobalObject* globalObject, JSObject* thisObj, uint64_t header, uint64_t currentCount, uint64_t resultCount, uint64_t length)

}

inline void unshift(JSGlobalObject* globalObject, JSObject* thisObj, uint64_t header, uint64_t currentCount, uint64_t resultCount, uint64_t length)

}

inline Structure* ArrayPrototype::createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)

{

return Structure::create(vm, globalObject, prototype, TypeInfo(DerivedArrayType, StructureFlags), info(), ArrayClass);

}

inline bool holesMustForwardToPrototype(JSObject* object)

{

return object->structure()->holesMustForwardToPrototype(object);

}

inline bool canUseFastArrayJoin(const JSObject* thisObject)

}

ALWAYS_INLINE JSString* fastArrayJoin(JSGlobalObject* globalObject, JSObject* thisObject, StringView separator, unsigned length, bool& sawHoles, bool& genericCase)

{

VM& vm = getVM(globalObject);

auto scope = DECLARE_THROW_SCOPE(vm);

JSStringJoiner joiner(separator);

unsigned i = 0;

switch (thisObject->indexingType()) {

case ALL_INT32_INDEXING_TYPES: {

auto& butterfly = *thisObject->butterfly();

if (length > butterfly.publicLength()) [[unlikely]]

break;

auto data = butterfly.contiguous().data();

JSOnlyStringsAndInt32sJoiner onlyInt32sJoiner(separator);

if (auto joined = onlyInt32sJoiner.tryJoin<Int32Shape>(globalObject, data, length))

RELEASE_AND_RETURN(scope, joined);

RETURN_IF_EXCEPTION(scope, { });

joiner.reserveCapacity(globalObject, length);

RETURN_IF_EXCEPTION(scope, { });

bool holesKnownToBeOK = false;

for (; i < length; ++i) {

JSValue value = data[i].get();

if (value) [[likely]]

joiner.appendNumber(vm, value.asInt32());

else {

sawHoles = true;

if (!holesKnownToBeOK) {

if (holesMustForwardToPrototype(thisObject))

goto generalCase;

holesKnownToBeOK = true;

}

joiner.appendEmptyString();

}

}

RELEASE_AND_RETURN(scope, joiner.join(globalObject));

}

case ALL_CONTIGUOUS_INDEXING_TYPES: {

auto& butterfly = *thisObject->butterfly();

unsigned originalLength = butterfly.publicLength();

if (length > originalLength) [[unlikely]]

break;

auto data = butterfly.contiguous().data();

bool holesKnownToBeOK = false;

JSOnlyStringsAndInt32sJoiner onlyStringsJoiner(separator);

if (auto joined = onlyStringsJoiner.tryJoin<ContiguousShape>(globalObject, data, length))

RELEASE_AND_RETURN(scope, joined);

RETURN_IF_EXCEPTION(scope, { });

for (; i < length; ++i) {

if (JSValue value = data[i].get()) {

bool withoutSideEffect = joiner.append(globalObject, value);

RETURN_IF_EXCEPTION(scope, { });

if (!withoutSideEffect) {

genericCase = true;

holesKnownToBeOK = false;

if (thisObject->butterfly() == &butterfly && originalLength == butterfly.publicLength()) [[likely]]

continue;

++i;

goto generalCase;

}

} else {

sawHoles = true;

if (!holesKnownToBeOK) {

if (holesMustForwardToPrototype(thisObject))

goto generalCase;

holesKnownToBeOK = true;

}

joiner.appendEmptyString();

}

}

RELEASE_AND_RETURN(scope, joiner.join(globalObject));

}

case ALL_DOUBLE_INDEXING_TYPES: {

auto& butterfly = *thisObject->butterfly();

if (length > butterfly.publicLength()) [[unlikely]]

break;

joiner.reserveCapacity(globalObject, length);

RETURN_IF_EXCEPTION(scope, { });

auto data = butterfly.contiguousDouble().data();

bool holesKnownToBeOK = false;

for (; i < length; ++i) {

double value = data[i];

if (!isHole(value)) [[likely]]

joiner.appendNumber(vm, value);

else {

sawHoles = true;

if (!holesKnownToBeOK) {

if (holesMustForwardToPrototype(thisObject))

goto generalCase;

holesKnownToBeOK = true;

}

joiner.appendEmptyString();

}

}

RELEASE_AND_RETURN(scope, joiner.join(globalObject));

}

case ALL_UNDECIDED_INDEXING_TYPES: {

if (length && holesMustForwardToPrototype(thisObject))

goto generalCase;

switch (separator.length()) {

case 0:

RELEASE_AND_RETURN(scope, jsEmptyString(vm));

case 1: {

if (length <= 1)

RELEASE_AND_RETURN(scope, jsEmptyString(vm));

if (separator.is8Bit())

RELEASE_AND_RETURN(scope, repeatCharacter(globalObject, separator.span8().front(), length - 1));

RELEASE_AND_RETURN(scope, repeatCharacter(globalObject, separator.span16().front(), length - 1));

default:

JSString* result = jsEmptyString(vm);

if (length <= 1)

return result;

JSString* operand = jsString(vm, separator);

RETURN_IF_EXCEPTION(scope, { });

unsigned count = length - 1;

for (;;) {

if (count & 1) {

result = jsString(globalObject, result, operand);

RETURN_IF_EXCEPTION(scope, { });

}

count >>= 1;

if (!count)

return result;

operand = jsString(globalObject, operand, operand);

RETURN_IF_EXCEPTION(scope, { });

}

}

}

}

}

generalCase:

genericCase = true;

for (; i < length; ++i) {

JSValue element = thisObject->getIndex(globalObject, i);

RETURN_IF_EXCEPTION(scope, { });

joiner.append(globalObject, element);

RETURN_IF_EXCEPTION(scope, { });

}

RELEASE_AND_RETURN(scope, joiner.join(globalObject));

}

} // namespace JSC