Var JavascriptReflect::EntrySetPrototypeOf(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.setPrototypeOf"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.setPrototypeOf"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.setPrototypeOf"));
}
Var target = args[1];
target = JavascriptOperators::ToObject(target, scriptContext);
if (args.Info.Count < 3 || !JavascriptOperators::IsObjectOrNull(args[2]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NotObjectOrNull, _u("Object.setPrototypeOf"));
}
RecyclableObject* newPrototype = RecyclableObject::FromVar(args[2]);
BOOL changeResult = JavascriptObject::ChangePrototype(RecyclableObject::FromVar(target), newPrototype, /*validate*/false, scriptContext);
return scriptContext->GetLibrary()->GetTrueOrFalse(changeResult);
}
Var JavascriptReflect::EntryEnumerate(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.enumerate"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.enumerate"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.enumerate"));
}
Var target = args[1];
Var iterator = nullptr;
Recycler* recycler = scriptContext->GetRecycler();
ForInObjectEnumeratorWrapper* forinEnumerator = RecyclerNew(recycler, Js::ForInObjectEnumeratorWrapper, RecyclableObject::FromVar(target), scriptContext);
iterator = JavascriptEnumeratorIterator::Create(forinEnumerator, nullptr, scriptContext);
return iterator;
}
Var JavascriptReflect::EntryApply(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.apply"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.apply"));
}
Var target = args.Info.Count > 1 ? args[1] : undefinedValue;
if (!JavascriptConversion::IsCallable(target))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedFunction, _u("Reflect.apply"));
}
Var thisArgument = args.Info.Count > 2 ? args[2] : undefinedValue;
Var argArray = args.Info.Count > 3 ? args[3] : undefinedValue;
return JavascriptFunction::ApplyHelper(RecyclableObject::FromVar(target), thisArgument, argArray, scriptContext);
}
Var JavascriptReflect::EntryPreventExtensions(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.preventExtensions"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.preventExtensions"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.preventExtensions"));
}
Var target = args[1];
RecyclableObject* targetObj = RecyclableObject::FromVar(target);
GlobalObject* globalObject = targetObj->GetLibrary()->GetGlobalObject();
if (globalObject != targetObj && globalObject && (globalObject->ToThis() == targetObj))
{
globalObject->PreventExtensions();
}
return scriptContext->GetLibrary()->GetTrueOrFalse(targetObj->PreventExtensions());
}
Var JavascriptReflect::EntrySet(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.set"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.set"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.set"));
}
Var target = args[1];
Var propertyKey = args.Info.Count > 2 ? args[2] : undefinedValue;
Var value = args.Info.Count > 3 ? args[3] : undefinedValue;
Var receiver = args.Info.Count > 4 ? args[4] : target;
target = JavascriptOperators::ToObject(target, scriptContext);
BOOL result = JavascriptOperators::SetElementIHelper(receiver, RecyclableObject::FromVar(target), propertyKey, value, scriptContext, PropertyOperationFlags::PropertyOperation_None);
return scriptContext->GetLibrary()->GetTrueOrFalse(result);
}
Var JavascriptSet::EntryForEach(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Set.prototype.forEach"));
if (!JavascriptSet::Is(args[0]))
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("Set.prototype.forEach"), _u("Set"));
}
JavascriptSet* set = JavascriptSet::FromVar(args[0]);
if (args.Info.Count < 2 || !JavascriptConversion::IsCallable(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedFunction, _u("Set.prototype.forEach"));
}
RecyclableObject* callBackFn = RecyclableObject::FromVar(args[1]);
Var thisArg = (args.Info.Count > 2) ? args[2] : scriptContext->GetLibrary()->GetUndefined();
auto iterator = set->GetIterator();
while (iterator.Next())
{
Var value = iterator.Current();
CALL_FUNCTION(callBackFn, CallInfo(CallFlags_Value, 4), thisArg, value, value, args[0]);
}
return scriptContext->GetLibrary()->GetUndefined();
}
Var JavascriptReflect::EntryHas(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.has"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.has"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.has"));
}
Var target = args[1];
Var propertyKey = args.Info.Count > 2 ? args[2] : undefinedValue;
BOOL result = JavascriptOperators::OP_HasItem(target, propertyKey, scriptContext);
return scriptContext->GetLibrary()->GetTrueOrFalse(result);
}
Var JavascriptReflect::EntryGetOwnPropertyDescriptor(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.getOwnPropertyDescriptor"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.getOwnPropertyDescriptor"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.getOwnPropertyDescriptor"));
}
Var target = args[1];
Var propertyKey = args.Info.Count > 2 ? args[2] : undefinedValue;
if (JavascriptOperators::GetTypeId(target) == TypeIds_HostDispatch)
{
Var result;
if (RecyclableObject::FromVar(target)->InvokeBuiltInOperationRemotely(EntryGetOwnPropertyDescriptor, args, &result))
{
return result;
}
}
return JavascriptObject::GetOwnPropertyDescriptorHelper(RecyclableObject::FromVar(target), propertyKey, scriptContext);
}
Var JavascriptGenerator::EntryNext(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
JavascriptLibrary* library = scriptContext->GetLibrary();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, L"Generator.prototype.next");
if (!JavascriptGenerator::Is(args[0]))
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, L"Generator.prototype.next", L"Generator");
}
JavascriptGenerator* generator = JavascriptGenerator::FromVar(args[0]);
Var input = args.Info.Count > 1 ? args[1] : library->GetUndefined();
if (generator->IsCompleted())
{
return library->CreateIteratorResultObjectUndefinedTrue();
}
ResumeYieldData yieldData(input, nullptr);
return generator->CallGenerator(&yieldData, L"Generator.prototype.next");
}
Var JavascriptGenerator::EntryThrow(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
JavascriptLibrary* library = scriptContext->GetLibrary();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, L"Generator.prototype.throw");
if (!JavascriptGenerator::Is(args[0]))
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, L"Generator.prototype.throw", L"Generator");
}
JavascriptGenerator* generator = JavascriptGenerator::FromVar(args[0]);
Var input = args.Info.Count > 1 ? args[1] : library->GetUndefined();
if (generator->IsSuspendedStart())
{
generator->SetState(GeneratorState::Completed);
}
if (generator->IsCompleted())
{
JavascriptExceptionOperators::OP_Throw(input, scriptContext);
}
ResumeYieldData yieldData(input, RecyclerNew(scriptContext->GetRecycler(), JavascriptExceptionObject, input, scriptContext, nullptr));
return generator->CallGenerator(&yieldData, L"Generator.prototype.throw");
}
Var JavascriptReflect::EntryConstruct(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.construct"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.construct"));
}
Var target = args.Info.Count > 1 ? args[1] : undefinedValue;
if (!JavascriptOperators::IsConstructor(target))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedConstructor, _u("target"));
}
Var newTarget = nullptr;
if (scriptContext->GetConfig()->IsES6ClassAndExtendsEnabled())
{
if (args.Info.Count > 3)
{
newTarget = args[3];
if (!JavascriptOperators::IsConstructor(newTarget))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedConstructor, _u("newTarget"));
}
}
else
{
newTarget = target;
}
}
RecyclableObject* thisArg = RecyclableObject::FromVar(undefinedValue);
if (newTarget != nullptr)
{
thisArg = JavascriptOperators::CreateFromConstructor(RecyclableObject::FromVar(newTarget), scriptContext);
}
Var argArray = args.Info.Count > 2 ? args[2] : undefinedValue;
return JavascriptFunction::ConstructHelper(RecyclableObject::FromVar(target), thisArg, newTarget, argArray, scriptContext);
}
Var JavascriptReflect::EntryDefineProperty(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Var undefinedValue = scriptContext->GetLibrary()->GetUndefined();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.defineProperty"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.defineProperty"));
}
Var propertyKey, attributes;
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.defineProperty"));
}
Var target = args[1];
propertyKey = args.Info.Count > 2 ? args[2] : undefinedValue;
PropertyRecord const * propertyRecord;
JavascriptConversion::ToPropertyKey(propertyKey, scriptContext, &propertyRecord);
attributes = args.Info.Count > 3 ? args[3] : undefinedValue;
PropertyDescriptor propertyDescriptor;
if (!JavascriptOperators::ToPropertyDescriptor(attributes, &propertyDescriptor, scriptContext))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_PropertyDescriptor_Invalid, scriptContext->GetPropertyName(propertyRecord->GetPropertyId())->GetBuffer());
}
// If the object is HostDispatch try to invoke the operation remotely
BOOL defineResult;
if (JavascriptOperators::GetTypeId(target) == TypeIds_HostDispatch)
{
defineResult = RecyclableObject::FromVar(target)->InvokeBuiltInOperationRemotely(EntryDefineProperty, args, nullptr);
}
else
{
defineResult = JavascriptObject::DefineOwnPropertyHelper(RecyclableObject::FromVar(target), propertyRecord->GetPropertyId(), propertyDescriptor, scriptContext, false);
}
return scriptContext->GetLibrary()->GetTrueOrFalse(defineResult);
}
Var JavascriptReflect::EntryGetPrototypeOf(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.getPrototypeOf"));
AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'");
if (args.Info.Flags & CallFlags_New)
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.getPrototypeOf"));
}
if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1]))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.getPrototypeOf"));
}
Var target = args[1];
return JavascriptObject::GetPrototypeOf(RecyclableObject::FromVar(target), scriptContext);
}
Var JavascriptSet::NewInstance(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
JavascriptLibrary* library = scriptContext->GetLibrary();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Set"));
Var newTarget = callInfo.Flags & CallFlags_NewTarget ? args.Values[args.Info.Count] : args[0];
bool isCtorSuperCall = (callInfo.Flags & CallFlags_New) && newTarget != nullptr && !JavascriptOperators::IsUndefined(newTarget);
Assert(isCtorSuperCall || !(callInfo.Flags & CallFlags_New) || args[0] == nullptr);
CHAKRATEL_LANGSTATS_INC_BUILTINCOUNT(SetCount);
JavascriptSet* setObject = nullptr;
if (callInfo.Flags & CallFlags_New)
{
setObject = library->CreateSet();
}
else
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("Set"), _u("Set"));
}
Assert(setObject != nullptr);
Var iterable = (args.Info.Count > 1) ? args[1] : library->GetUndefined();
RecyclableObject* iter = nullptr;
RecyclableObject* adder = nullptr;
if (JavascriptConversion::CheckObjectCoercible(iterable, scriptContext))
{
iter = JavascriptOperators::GetIterator(iterable, scriptContext);
Var adderVar = JavascriptOperators::GetProperty(setObject, PropertyIds::add, scriptContext);
if (!JavascriptConversion::IsCallable(adderVar))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedFunction);
}
adder = RecyclableObject::FromVar(adderVar);
}
if (setObject->set != nullptr)
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_ObjectIsAlreadyInitialized, _u("Set"), _u("Set"));
}
setObject->set = RecyclerNew(scriptContext->GetRecycler(), SetDataSet, scriptContext->GetRecycler());
if (iter != nullptr)
{
JavascriptOperators::DoIteratorStepAndValue(iter, scriptContext, [&](Var nextItem) {
CALL_FUNCTION(adder, CallInfo(CallFlags_Value, 2), setObject, nextItem);
});
}
return isCtorSuperCall ?
JavascriptOperators::OrdinaryCreateFromConstructor(RecyclableObject::FromVar(newTarget), setObject, nullptr, scriptContext) :
setObject;
}
Var JavascriptMap::NewInstance(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
JavascriptLibrary* library = scriptContext->GetLibrary();
AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Map"));
Var newTarget = callInfo.Flags & CallFlags_NewTarget ? args.Values[args.Info.Count] : args[0];
bool isCtorSuperCall = (callInfo.Flags & CallFlags_New) && newTarget != nullptr && !JavascriptOperators::IsUndefined(newTarget);
Assert(isCtorSuperCall || !(callInfo.Flags & CallFlags_New) || args[0] == nullptr);
CHAKRATEL_LANGSTATS_INC_BUILTINCOUNT(MapCount);
JavascriptMap* mapObject = nullptr;
if (callInfo.Flags & CallFlags_New)
{
mapObject = library->CreateMap();
}
else
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("Map"), _u("Map"));
}
Assert(mapObject != nullptr);
Var iterable = (args.Info.Count > 1) ? args[1] : library->GetUndefined();
RecyclableObject* iter = nullptr;
RecyclableObject* adder = nullptr;
if (JavascriptConversion::CheckObjectCoercible(iterable, scriptContext))
{
iter = JavascriptOperators::GetIterator(iterable, scriptContext);
Var adderVar = JavascriptOperators::GetProperty(mapObject, PropertyIds::set, scriptContext);
if (!JavascriptConversion::IsCallable(adderVar))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedFunction);
}
adder = RecyclableObject::FromVar(adderVar);
}
if (mapObject->map != nullptr)
{
JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_ObjectIsAlreadyInitialized, _u("Map"), _u("Map"));
}
mapObject->map = RecyclerNew(scriptContext->GetRecycler(), MapDataMap, scriptContext->GetRecycler());
if (iter != nullptr)
{
Var undefined = library->GetUndefined();
JavascriptOperators::DoIteratorStepAndValue(iter, scriptContext, [&](Var nextItem) {
if (!JavascriptOperators::IsObject(nextItem))
{
JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedObject);
}
RecyclableObject* obj = RecyclableObject::FromVar(nextItem);
Var key, value;
if (!JavascriptOperators::GetItem(obj, 0u, &key, scriptContext))
{
key = undefined;
}
if (!JavascriptOperators::GetItem(obj, 1u, &value, scriptContext))
{
value = undefined;
}
// CONSIDER: if adder is the default built-in, fast path it and skip the JS call?
CALL_FUNCTION(adder, CallInfo(CallFlags_Value, 3), mapObject, key, value);
});
}
return isCtorSuperCall ?
JavascriptOperators::OrdinaryCreateFromConstructor(RecyclableObject::FromVar(newTarget), mapObject, nullptr, scriptContext) :
mapObject;
}
