OpenHarmony-v4.0.1-Release/s

/*
 * Copyright (c) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "ecmascript/js_async_generator_object.h"
#include "ecmascript/async_generator_helper.h"
#include "ecmascript/accessor_data.h"
#include "ecmascript/base/builtins_base.h"
#include "ecmascript/builtins/builtins_promise.h"
#include "ecmascript/ecma_string.h"
#include "ecmascript/global_env.h"
#include "ecmascript/interpreter/interpreter.h"
#include "ecmascript/js_promise.h"
#include "ecmascript/object_factory.h"
#include "ecmascript/tagged_queue.h"
#include "ecmascript/generator_helper.h"
#include "ecmascript/js_iterator.h"
#include "ecmascript/js_tagged_value-inl.h"
#include "ecmascript/js_function.h"


namespace panda::ecmascript {
using BuiltinsPromise = builtins::BuiltinsPromise;

// AsyncGeneratorValidate ( generator, generatorBrand )
void JSAsyncGeneratorObject::AsyncGeneratorValidate(JSThread *thread, const JSHandle<JSTaggedValue> &gen,
                                                    const JSTaggedValue &val)
{
    // 1. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorContext]]).
    // 2. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorState]]).
    // 3. Perform ? RequireInternalSlot(generator, [[AsyncGeneratorQueue]]).
    if (!gen->IsAsyncGeneratorObject()) {
        THROW_TYPE_ERROR(thread, "Not a asyncgenerator object");
    }
    // 4. If generator.[[GeneratorBrand]] is not the same value as generatorBrand, throw a TypeError exception.
    JSHandle<JSObject> obj = JSTaggedValue::ToObject(thread, gen);
    RETURN_IF_ABRUPT_COMPLETION(thread);
    JSHandle<JSAsyncGeneratorObject> generator = JSHandle<JSAsyncGeneratorObject>::Cast(obj);
    if (!JSTaggedValue::SameValue(generator->GetGeneratorBrand(), val)) {
        THROW_TYPE_ERROR(thread, "Results are not equal");
    }
}

JSTaggedValue JSAsyncGeneratorObject::AsyncGeneratorResolve(JSThread *thread,
                                                            const JSHandle<JSAsyncGeneratorObject> &generator,
                                                            const JSHandle<JSTaggedValue> value, bool done)
{
    // 1. Assert: generator is an AsyncGenerator instance.
    ASSERT(generator->IsAsyncGeneratorObject());
    // 2. Let queue be generator.[[AsyncGeneratorQueue]].
    JSHandle<TaggedQueue> queue(thread, generator->GetAsyncGeneratorQueue());
    // 3. Assert: queue is not an empty List.
    ASSERT(!(queue->Empty()));
    // 4. Let next be the first element of queue.
    JSHandle<AsyncGeneratorRequest> next(thread, queue->Front());
    // 5. Remove the first element from queue.
    queue->Pop(thread);
    // 6. Let promiseCapability be next.[[Capability]].
    JSHandle<PromiseCapability> capability(thread, next->GetCapability());
    // 7. Let iteratorResult be ! CreateIterResultObject(value, done).
    JSHandle<JSObject> iteratorResult = JSIterator::CreateIterResultObject(thread, value, done);
    // 8. Perform ! Call(promiseCapability.[[Resolve]], undefined, « iteratorResult »).
    JSHandle<JSTaggedValue> its = JSHandle<JSTaggedValue>::Cast(iteratorResult);
    JSHandle<JSTaggedValue> resolve(thread, capability->GetResolve());
    JSHandle<JSTaggedValue> undefined = thread->GlobalConstants()->GetHandledUndefined();
    EcmaRuntimeCallInfo* info =
        EcmaInterpreter::NewRuntimeCallInfo(thread, resolve, undefined, undefined, 1);
    RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
    info->SetCallArg(its.GetTaggedValue());
    [[maybe_unused]] JSTaggedValue res = JSFunction::Call(info);
    RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);

    // 9. Perform ! AsyncGeneratorResumeNext(generator).
    AsyncGeneratorResumeNext(thread, generator);
    // 10. Return undefined.
    return JSTaggedValue::Undefined();
}

JSTaggedValue JSAsyncGeneratorObject::AsyncGeneratorReject(JSThread *thread,
                                                           const JSHandle<JSAsyncGeneratorObject> &generator,
                                                           const JSHandle<JSTaggedValue> value)
{
   // 1. Assert: generator is an AsyncGenerator instance.
    ASSERT(generator->IsAsyncGeneratorObject());
    // 2. Let queue be generator.[[AsyncGeneratorQueue]].
    JSHandle<TaggedQueue> queue(thread, generator->GetAsyncGeneratorQueue());
    // 3. Assert: queue is not an empty List.
    ASSERT(!(queue->Empty()));
    // 4. Let next be the first element of queue.
    JSHandle<JSTaggedValue> val(thread, queue->Front());
    JSHandle<AsyncGeneratorRequest> next = JSHandle<AsyncGeneratorRequest>::Cast(val);
    // 5. Remove the first element from queue.
    queue->Pop(thread);
    // 6. Let promiseCapability be next.[[Capability]].
    JSHandle<PromiseCapability> capability(thread, next->GetCapability());
    // 7. Perform ! Call(promiseCapability.[[Reject]], undefined, ? exception ?).
    JSHandle<JSTaggedValue> reject(thread, capability->GetReject());
    const GlobalEnvConstants *constants = thread->GlobalConstants();
    const JSHandle<JSTaggedValue> thisArg = constants->GetHandledUndefined();
    const JSHandle<JSTaggedValue> undefined = constants->GetHandledUndefined();
    EcmaRuntimeCallInfo* info =
        EcmaInterpreter::NewRuntimeCallInfo(thread, reject, thisArg, undefined, 1);
    RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
    info->SetCallArg(value.GetTaggedValue());
    [[maybe_unused]] JSTaggedValue res = JSFunction::Call(info);
    RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
    // 8. Perform ! AsyncGeneratorResumeNext(generator).
    AsyncGeneratorResumeNext(thread, generator);
    // 9. Return undefined.
    return JSTaggedValue::Undefined();
}

JSTaggedValue JSAsyncGeneratorObject::AsyncGeneratorResumeNext(JSThread *thread,
                                                               const JSHandle<JSAsyncGeneratorObject> &generator)
{
    // 1. Assert: generator is an AsyncGenerator instance.
    ASSERT(generator->IsAsyncGeneratorObject());
    // 2. Let state be generator.[[AsyncGeneratorState]].
    JSAsyncGeneratorState state = generator->GetAsyncGeneratorState();
    // 3. Assert: state is not executing.
    ASSERT(state != JSAsyncGeneratorState::EXECUTING);
    // 4. If state is awaiting-return, return undefined.
    if (state == JSAsyncGeneratorState::AWAITING_RETURN) {
        return JSTaggedValue::Undefined();
    }
    // 5. Let queue be generator.[[AsyncGeneratorQueue]].
    JSHandle<TaggedQueue> queue(thread, generator->GetAsyncGeneratorQueue());
    // 6. If queue is an empty List, return undefined.
    if (queue->Empty()) {
        return JSTaggedValue::Undefined();
    }
    // 7. Let next be the value of the first element of queue.
    JSHandle<AsyncGeneratorRequest> next(thread, queue->Front());
    // 8. Assert: next is an AsyncGeneratorRequest record.
    ASSERT(next->GetClass()->IsAsyncGeneratorRequest());
    // 9. Let completion be next.[[Completion]].
    JSTaggedValue rcd = next->GetCompletion();
    JSHandle<CompletionRecord> completion(thread, rcd);
    CompletionRecordType type = completion->GetType();
    // 10. If completion is an abrupt completion, then
    if (thread->HasPendingException() || type != CompletionRecordType::NORMAL) {
        // a. If state is suspendedStart, then
        if (state == JSAsyncGeneratorState::SUSPENDED_START) {
            // i. Set generator.[[AsyncGeneratorState]] to completed.
            // ii. Set state to completed.
            state = JSAsyncGeneratorState::COMPLETED;
            generator->SetAsyncGeneratorState(state);
        }
        // b. If state is completed, then
        if (state == JSAsyncGeneratorState::COMPLETED) {
            // i. If completion.[[Type]] is return, then
            if (completion->GetType() == CompletionRecordType::RETURN) {
                // 1. Set generator.[[AsyncGeneratorState]] to awaiting-return.
                generator->SetAsyncGeneratorState(JSAsyncGeneratorState::AWAITING_RETURN);
                // 2. Let promise be ? PromiseResolve(%Promise%, completion.[[Value]]).
                JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
                JSHandle<JSTaggedValue> val(thread, completion->GetValue());
                JSTaggedValue promise = PromiseResolve(thread,
                                                       JSHandle<JSTaggedValue>::Cast(env->GetPromiseFunction()), val);
                JSHandle<JSPromise> handPromise(thread, promise);
                // 3. Let stepsFulfilled be the algorithm steps defined in
                //    AsyncGeneratorResumeNext Return Processor Fulfilled Functions.
                // 4. Let lengthFulfilled be the number of non-optional parameters of the
                //    function definition in AsyncGeneratorResumeNext Return Processor Fulfilled Functions.
                // 5. Let onFulfilled be ! CreateBuiltinFunction(stepsFulfilled,
                //    lengthFulfilled, "", « [[Generator]] »).
                // 7. Let stepsRejected be the algorithm steps defined in AsyncGeneratorResumeNext
                //    Return Processor Rejected Functions.
                // 8. Let lengthRejected be the number of non-optional parameters of the function definition in
                //    AsyncGeneratorResumeNext Return Processor Rejected Functions.
                // 9. Let onRejected be ! CreateBuiltinFunction(stepsRejected, lengthRejected, "", « [[Generator]] »).
                ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
                JSHandle<JSAsyncGeneratorResNextRetProRstFtn> onFulfilled =
                    factory->NewJSAsyGenResNextRetProRstFulfilledFtn();
                onFulfilled->SetAsyncGeneratorObject(thread, generator);

                JSHandle<JSAsyncGeneratorResNextRetProRstFtn> onFulRejected =
                    factory->NewJSAsyGenResNextRetProRstRejectedFtn();
                onFulRejected->SetAsyncGeneratorObject(thread, generator);

                // 11. Perform ! PerformPromiseThen(promise, onFulfilled, onRejected).
                JSHandle<PromiseCapability> tcap =
                    JSPromise::NewPromiseCapability(thread, JSHandle<JSTaggedValue>::Cast(env->GetPromiseFunction()));
                RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
                [[maybe_unused]] JSTaggedValue pres = BuiltinsPromise::PerformPromiseThen(
                    thread, handPromise, JSHandle<JSTaggedValue>::Cast(onFulfilled),
                    JSHandle<JSTaggedValue>::Cast(onFulRejected), tcap);
                // 12. Return undefined.
                return JSTaggedValue::Undefined();
            } else {
                // 1. Assert: completion.[[Type]] is throw.
                ASSERT(completion->GetType() == CompletionRecordType::THROW);
                // 2. Perform ! AsyncGeneratorReject(generator, completion.[[Value]]).
                JSHandle<JSTaggedValue> comVal(thread, completion->GetValue());
                AsyncGeneratorReject(thread, generator, comVal);
                // 3. Return undefined.
                return JSTaggedValue::Undefined();
            }
        }
    // 11. Else if state is completed, return ! AsyncGeneratorResolve(generator, undefined, true).
    } else if (state == JSAsyncGeneratorState::COMPLETED) {
        JSHandle<JSTaggedValue> comVal(thread, JSTaggedValue::Undefined());
        return AsyncGeneratorResolve(thread, generator, comVal, true);
    }
    // 12. Assert: state is either suspendedStart or suspendedYield.
    ASSERT((state == JSAsyncGeneratorState::SUSPENDED_START) ||
           (state == JSAsyncGeneratorState::SUSPENDED_YIELD));
    // 13. Let genContext be generator.[[AsyncGeneratorContext]].
    JSTaggedValue val = generator->GetGeneratorContext();

    JSHandle<GeneratorContext> genContext(thread, val);
    // 14. Let callerContext be the running execution context.
    // 15. Suspend callerContext.
    // 16. Set generator.[[AsyncGeneratorState]] to executing.
    // 17. Push genContext onto the execution context stack; genContext is now the running execution context.
    // 18. Resume the suspended evaluation of genContext using completion as the result of the operation that
    //     suspended it. Let result be the completion record returned by the resumed computation.
    // 19. Assert: result is never an abrupt completion.
    // 20. Assert: When we return here, genContext has already been removed from the execution context stack and
    //     callerContext is the currently running execution context.
    // 21. Return undefined.
    generator->SetAsyncGeneratorState(JSAsyncGeneratorState::EXECUTING);

    if (completion->GetType() == CompletionRecordType::NORMAL) {
        AsyncGeneratorHelper::Next(thread, genContext, completion->GetValue());
    }
    if (completion->GetType() == CompletionRecordType::RETURN) {
        AsyncGeneratorHelper::Return(thread, genContext, completion);
    }
    if (completion->GetType() == CompletionRecordType::THROW) {
        AsyncGeneratorHelper::Throw(thread, genContext, completion);
    }
    return JSTaggedValue::Undefined();
}

JSTaggedValue JSAsyncGeneratorObject::AsyncGeneratorEnqueue(JSThread *thread, const JSHandle<JSTaggedValue> &gen,
                                                            const JSHandle<CompletionRecord> completionRecord)
{
    // 1. Let promiseCapability be ! NewPromiseCapability(%Promise%).
    JSHandle<GlobalEnv> env = thread->GetEcmaVM()->GetGlobalEnv();
    ObjectFactory *factory = thread->GetEcmaVM()->GetFactory();
    JSHandle<PromiseCapability> pcap =
        JSPromise::NewPromiseCapability(thread, JSHandle<JSTaggedValue>::Cast(env->GetPromiseFunction()));
    RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
    // 2. Let check be AsyncGeneratorValidate(generator, generatorBrand).
    AsyncGeneratorValidate(thread, gen, JSTaggedValue::Undefined());
    // 3. If check is an abrupt completion, then
    if (thread->HasPendingException()) {
        thread->ClearException();
        // a. Let badGeneratorError be a newly created TypeError object.
        JSHandle<JSObject> resolutionError =
            factory->GetJSError(ErrorType::TYPE_ERROR, "Resolve: The promise and resolution cannot be the same.");
        // b. Perform ! Call(promiseCapability.[[Reject]], undefined, « badGeneratorError »).
        const GlobalEnvConstants *constants = thread->GlobalConstants();
        JSHandle<JSTaggedValue> rstErr = JSHandle<JSTaggedValue>::Cast(resolutionError);
        JSHandle<JSTaggedValue> reject(thread, pcap->GetReject());
        JSHandle<JSTaggedValue> thisArg = constants->GetHandledUndefined();
        JSHandle<JSTaggedValue> undefined = constants->GetHandledUndefined();
        EcmaRuntimeCallInfo* info =
            EcmaInterpreter::NewRuntimeCallInfo(thread, reject, thisArg, undefined, 1);
        RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
        info->SetCallArg(rstErr.GetTaggedValue());
        [[maybe_unused]] JSTaggedValue res = JSFunction::Call(info);
        RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);

        // c. Return promiseCapability.[[Promise]].
        JSHandle<JSObject> promise(thread, pcap->GetPromise());
        return promise.GetTaggedValue();
    }
    // 4. Let queue be generator.[[AsyncGeneratorQueue]].
    JSHandle<JSObject> obj = JSTaggedValue::ToObject(thread, gen);
    RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
    JSHandle<JSAsyncGeneratorObject> generator = JSHandle<JSAsyncGeneratorObject>::Cast(obj);
    JSHandle<TaggedQueue> queue(thread, generator->GetAsyncGeneratorQueue());
    // 5. Let request be AsyncGeneratorRequest { [[Completion]]: completion, [[Capability]]: promiseCapability }.
    ObjectFactory *fty = thread->GetEcmaVM()->GetFactory();
    JSHandle<AsyncGeneratorRequest> asyncGeneratorRst = fty->NewAsyncGeneratorRequest();

    asyncGeneratorRst->SetCompletion(thread, completionRecord);
    asyncGeneratorRst->SetCapability(thread, pcap);
    // 6. Append request to the end of queue.

    TaggedQueue *newQueue = TaggedQueue::Push(thread, queue, JSHandle<JSTaggedValue>::Cast(asyncGeneratorRst));
    generator->SetAsyncGeneratorQueue(thread, JSTaggedValue(newQueue));

    // 7. Let state be generator.[[AsyncGeneratorState]].
    JSAsyncGeneratorState state = generator->GetAsyncGeneratorState();
    // 8. If state is not executing, then
    if (state != JSAsyncGeneratorState::EXECUTING) {
        // a. Perform ! AsyncGeneratorResumeNext(generator).
        AsyncGeneratorResumeNext(thread, generator);
    }
    // 9. Return promiseCapability.[[Promise]].
    JSHandle<JSObject> promise(thread, pcap->GetPromise());
    return promise.GetTaggedValue();
}

JSTaggedValue JSAsyncGeneratorObject::PromiseResolve(JSThread *thread, const JSHandle<JSTaggedValue> promise,
                                                     const JSHandle<JSTaggedValue> value)
{
    const GlobalEnvConstants *globalConst = thread->GlobalConstants();
    ASSERT(promise->IsECMAObject());
    if (value->IsJSPromise()) {
        JSHandle<JSTaggedValue> ctorKey(globalConst->GetHandledConstructorString());
        JSHandle<JSTaggedValue> ctorValue = JSObject::GetProperty(thread, value, ctorKey).GetValue();
        RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
        if (JSTaggedValue::SameValue(ctorValue.GetTaggedValue(), promise.GetTaggedValue())) {
            return value.GetTaggedValue();
        }
    }
    JSHandle<PromiseCapability> promiseCapability = JSPromise::NewPromiseCapability(thread, promise);
    RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
    JSHandle<JSTaggedValue> resolve(thread, promiseCapability->GetResolve());
    JSHandle<JSTaggedValue> undefined = globalConst->GetHandledUndefined();
    JSHandle<JSTaggedValue> thisArg = globalConst->GetHandledUndefined();
    EcmaRuntimeCallInfo* info =
        EcmaInterpreter::NewRuntimeCallInfo(thread, resolve, thisArg, undefined, 1);
    RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
    info->SetCallArg(value.GetTaggedValue());
    [[maybe_unused]] JSTaggedValue res = JSFunction::Call(info);

    RETURN_EXCEPTION_IF_ABRUPT_COMPLETION(thread);
    JSHandle<JSPromise> promiseObj(thread, promiseCapability->GetPromise());
    return promiseObj.GetTaggedValue();
}

JSTaggedValue JSAsyncGeneratorObject::ProcessorFulfilledFunc(EcmaRuntimeCallInfo *argv)
{
    // 1. Let F be the active function object.
    JSThread *thread = argv->GetThread();
    JSHandle<JSAsyncGeneratorResNextRetProRstFtn> asyncResNextRtnPro =
        JSHandle<JSAsyncGeneratorResNextRetProRstFtn>::Cast(base::BuiltinsBase::GetConstructor(argv));
    JSHandle<JSAsyncGeneratorObject> asyncGen(thread, asyncResNextRtnPro->GetAsyncGeneratorObject());

    // 2. Set F.[[Generator]].[[AsyncGeneratorState]] to completed.
    asyncGen->SetAsyncGeneratorState(JSAsyncGeneratorState::COMPLETED);

    // 3. Return ! AsyncGeneratorResolve(F.[[Generator]], value, true).
    JSHandle<JSTaggedValue> value = base::BuiltinsBase::GetCallArg(argv, 0);
    return AsyncGeneratorResolve(thread, asyncGen, value, true);
}

JSTaggedValue JSAsyncGeneratorObject::ProcessorRejectedFunc(EcmaRuntimeCallInfo *argv)
{
    // 1. Let F be the active function object.
    JSThread *thread = argv->GetThread();
    JSHandle<JSAsyncGeneratorResNextRetProRstFtn> asyncResNextRtnPro =
        JSHandle<JSAsyncGeneratorResNextRetProRstFtn>::Cast(base::BuiltinsBase::GetConstructor(argv));
    JSHandle<JSAsyncGeneratorObject> asyncGen(thread, asyncResNextRtnPro->GetAsyncGeneratorObject());
    // 2. Set F.[[Generator]].[[AsyncGeneratorState]] to completed.
    asyncGen->SetAsyncGeneratorState(JSAsyncGeneratorState::COMPLETED);
    // 3. Return ! AsyncGeneratorReject(F.[[Generator]], reason).
    JSHandle<JSTaggedValue> value = base::BuiltinsBase::GetCallArg(argv, 0);
    return AsyncGeneratorReject(thread, asyncGen, value);
}
}  // namespace panda::ecmascript