blob: 3cc9fd87acdcf208bcb9a1522fed31f5107d0edc [file] [log] [blame]
/*
* Copyright (C) 2015 Yusuke Suzuki <utatane.tea@gmail.com>.
* Copyright (C) 2016-2017 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "IteratorOperations.h"
#include "JSCInlines.h"
#include "ObjectConstructor.h"
namespace JSC {
JSValue iteratorNext(JSGlobalObject* globalObject, IterationRecord iterationRecord, JSValue argument)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSValue iterator = iterationRecord.iterator;
JSValue nextFunction = iterationRecord.nextMethod;
auto nextFunctionCallData = JSC::getCallData(nextFunction);
if (nextFunctionCallData.type == CallData::Type::None)
return throwTypeError(globalObject, scope);
MarkedArgumentBuffer nextFunctionArguments;
if (!argument.isEmpty())
nextFunctionArguments.append(argument);
ASSERT(!nextFunctionArguments.hasOverflowed());
JSValue result = call(globalObject, nextFunction, nextFunctionCallData, iterator, nextFunctionArguments);
RETURN_IF_EXCEPTION(scope, JSValue());
if (!result.isObject())
return throwTypeError(globalObject, scope, "Iterator result interface is not an object."_s);
return result;
}
JSValue iteratorValue(JSGlobalObject* globalObject, JSValue iterResult)
{
return iterResult.get(globalObject, globalObject->vm().propertyNames->value);
}
bool iteratorComplete(JSGlobalObject* globalObject, JSValue iterResult)
{
JSValue done = iterResult.get(globalObject, globalObject->vm().propertyNames->done);
return done.toBoolean(globalObject);
}
JSValue iteratorStep(JSGlobalObject* globalObject, IterationRecord iterationRecord)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSValue result = iteratorNext(globalObject, iterationRecord);
RETURN_IF_EXCEPTION(scope, JSValue());
bool done = iteratorComplete(globalObject, result);
RETURN_IF_EXCEPTION(scope, JSValue());
if (done)
return jsBoolean(false);
return result;
}
void iteratorClose(JSGlobalObject* globalObject, JSValue iterator)
{
VM& vm = globalObject->vm();
auto throwScope = DECLARE_THROW_SCOPE(vm);
auto catchScope = DECLARE_CATCH_SCOPE(vm);
Exception* exception = nullptr;
if (UNLIKELY(catchScope.exception())) {
exception = catchScope.exception();
catchScope.clearException();
}
JSValue returnFunction = iterator.get(globalObject, vm.propertyNames->returnKeyword);
if (UNLIKELY(throwScope.exception()) || returnFunction.isUndefinedOrNull()) {
if (exception)
throwException(globalObject, throwScope, exception);
return;
}
auto returnFunctionCallData = JSC::getCallData(returnFunction);
if (returnFunctionCallData.type == CallData::Type::None) {
if (exception)
throwException(globalObject, throwScope, exception);
else
throwTypeError(globalObject, throwScope);
return;
}
MarkedArgumentBuffer returnFunctionArguments;
ASSERT(!returnFunctionArguments.hasOverflowed());
JSValue innerResult = call(globalObject, returnFunction, returnFunctionCallData, iterator, returnFunctionArguments);
if (exception) {
throwException(globalObject, throwScope, exception);
return;
}
RETURN_IF_EXCEPTION(throwScope, void());
if (!innerResult.isObject()) {
throwTypeError(globalObject, throwScope, "Iterator result interface is not an object."_s);
return;
}
}
static constexpr PropertyOffset valuePropertyOffset = 0;
static constexpr PropertyOffset donePropertyOffset = 1;
Structure* createIteratorResultObjectStructure(VM& vm, JSGlobalObject& globalObject)
{
Structure* iteratorResultStructure = globalObject.structureCache().emptyObjectStructureForPrototype(&globalObject, globalObject.objectPrototype(), JSFinalObject::defaultInlineCapacity);
PropertyOffset offset;
iteratorResultStructure = Structure::addPropertyTransition(vm, iteratorResultStructure, vm.propertyNames->value, 0, offset);
RELEASE_ASSERT(offset == valuePropertyOffset);
iteratorResultStructure = Structure::addPropertyTransition(vm, iteratorResultStructure, vm.propertyNames->done, 0, offset);
RELEASE_ASSERT(offset == donePropertyOffset);
return iteratorResultStructure;
}
JSObject* createIteratorResultObject(JSGlobalObject* globalObject, JSValue value, bool done)
{
VM& vm = globalObject->vm();
JSObject* resultObject = constructEmptyObject(vm, globalObject->iteratorResultObjectStructure());
resultObject->putDirectOffset(vm, valuePropertyOffset, value);
resultObject->putDirectOffset(vm, donePropertyOffset, jsBoolean(done));
return resultObject;
}
bool hasIteratorMethod(JSGlobalObject* globalObject, JSValue value)
{
auto& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
if (!value.isObject())
return false;
JSObject* object = asObject(value);
CallData callData;
JSValue applyMethod = object->getMethod(globalObject, callData, vm.propertyNames->iteratorSymbol, "Symbol.iterator property should be callable"_s);
RETURN_IF_EXCEPTION(scope, false);
return !applyMethod.isUndefined();
}
JSValue iteratorMethod(JSGlobalObject* globalObject, JSObject* object)
{
auto& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
CallData callData;
JSValue method = object->getMethod(globalObject, callData, vm.propertyNames->iteratorSymbol, "Symbol.iterator property should be callable"_s);
RETURN_IF_EXCEPTION(scope, jsUndefined());
return method;
}
IterationRecord iteratorForIterable(JSGlobalObject* globalObject, JSObject* object, JSValue iteratorMethod)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
auto iteratorMethodCallData = JSC::getCallData(iteratorMethod);
if (iteratorMethodCallData.type == CallData::Type::None) {
throwTypeError(globalObject, scope);
return { };
}
ArgList iteratorMethodArguments;
JSValue iterator = call(globalObject, iteratorMethod, iteratorMethodCallData, object, iteratorMethodArguments);
RETURN_IF_EXCEPTION(scope, { });
if (!iterator.isObject()) {
throwTypeError(globalObject, scope);
return { };
}
JSValue nextMethod = iterator.getObject()->get(globalObject, vm.propertyNames->next);
RETURN_IF_EXCEPTION(scope, { });
return { iterator, nextMethod };
}
IterationRecord iteratorForIterable(JSGlobalObject* globalObject, JSValue iterable)
{
VM& vm = globalObject->vm();
auto scope = DECLARE_THROW_SCOPE(vm);
JSValue iteratorFunction = iterable.get(globalObject, vm.propertyNames->iteratorSymbol);
RETURN_IF_EXCEPTION(scope, { });
auto iteratorFunctionCallData = JSC::getCallData(iteratorFunction);
if (iteratorFunctionCallData.type == CallData::Type::None) {
throwTypeError(globalObject, scope);
return { };
}
ArgList iteratorFunctionArguments;
JSValue iterator = call(globalObject, iteratorFunction, iteratorFunctionCallData, iterable, iteratorFunctionArguments);
RETURN_IF_EXCEPTION(scope, { });
if (!iterator.isObject()) {
throwTypeError(globalObject, scope);
return { };
}
JSValue nextMethod = iterator.getObject()->get(globalObject, vm.propertyNames->next);
RETURN_IF_EXCEPTION(scope, { });
return { iterator, nextMethod };
}
IterationMode getIterationMode(VM&, JSGlobalObject* globalObject, JSValue iterable, JSValue symbolIterator)
{
if (!iterable.inherits<JSArray>())
return IterationMode::Generic;
if (!globalObject->arrayIteratorProtocolWatchpointSet().isStillValid())
return IterationMode::Generic;
// This is correct because we just checked the watchpoint is still valid.
JSFunction* symbolIteratorFunction = jsDynamicCast<JSFunction*>(symbolIterator);
if (!symbolIteratorFunction)
return IterationMode::Generic;
// We don't want to allocate the values function just to check if it's the same as our function so we use the concurrent accessor.
// FIXME: This only works for arrays from the same global object as ourselves but we should be able to support any pairing.
if (globalObject->arrayProtoValuesFunctionConcurrently() != symbolIteratorFunction)
return IterationMode::Generic;
return IterationMode::FastArray;
}
IterationMode getIterationMode(VM&, JSGlobalObject* globalObject, JSValue iterable)
{
if (!iterable.inherits<JSArray>())
return IterationMode::Generic;
JSArray* array = jsCast<JSArray*>(iterable);
Structure* structure = array->structure();
// FIXME: We want to support broader JSArrays as long as array[@@iterator] is not defined.
if (!globalObject->isOriginalArrayStructure(structure))
return IterationMode::Generic;
if (!globalObject->arrayIteratorProtocolWatchpointSet().isStillValid())
return IterationMode::Generic;
// Now, Array has original Array Structures and arrayIteratorProtocolWatchpointSet is not fired.
// This means,
// 1. Array.prototype is [[Prototype]].
// 2. array[@@iterator] is not overridden.
// 3. Array.prototype[@@iterator] is an expected one.
// So, we can say this will create an expected ArrayIterator.
return IterationMode::FastArray;
}
} // namespace JSC