Update promise API in Thread class

Author: adazem009

include/scratchcpp/thread.h

@@ -10,6 +10,9 @@ namespace libscratchcpp
 
 class VirtualMachine;
 class Target;
+#ifdef USE_LLVM
+class Promise;
+#endif
 class IEngine;
 class Script;
 class ThreadPrivate;
@@ -32,8 +35,13 @@ class LIBSCRATCHCPP_EXPORT Thread
 
         bool isFinished() const;
 
+#ifdef USE_LLVM
+        std::shared_ptr<Promise> promise() const;
+        void setPromise(std::shared_ptr<Promise> promise);
+#else
         void promise();
         void resolvePromise();
+#endif
 
     private:
         spimpl::unique_impl_ptr<ThreadPrivate> impl;

src/engine/internal/engine.cpp

@@ -9,6 +9,7 @@
 #include <scratchcpp/broadcast.h>
 #ifdef USE_LLVM
 #include <scratchcpp/dev/compiler.h>
+#include <scratchcpp/dev/promise.h>
 #else
 #include <scratchcpp/compiler.h>
 #endif
@@ -593,8 +594,16 @@ void Engine::step()
         } else {
             Thread *th = senderThread;
 
-            if (std::find_if(m_threads.begin(), m_threads.end(), [th](std::shared_ptr<Thread> thread) { return thread.get() == th; }) != m_threads.end())
+            if (std::find_if(m_threads.begin(), m_threads.end(), [th](std::shared_ptr<Thread> thread) { return thread.get() == th; }) != m_threads.end()) {
+#ifdef USE_LLVM
+                auto promise = th->promise();
+
+                if (promise)
+                    promise->resolve();
+#else
                 th->resolvePromise();
+#endif
+            }
 
             resolved.push_back(broadcast);
             resolvedThreads.push_back(th);
@@ -2018,8 +2027,16 @@ void Engine::addBroadcastPromise(Broadcast *broadcast, Thread *sender, bool wait
     // Resolve broadcast promise if it's already running
     auto it = m_broadcastSenders.find(broadcast);
 
-    if (it != m_broadcastSenders.cend() && std::find_if(m_threads.begin(), m_threads.end(), [&it](std::shared_ptr<Thread> thread) { return thread.get() == it->second; }) != m_threads.end())
+    if (it != m_broadcastSenders.cend() && std::find_if(m_threads.begin(), m_threads.end(), [&it](std::shared_ptr<Thread> thread) { return thread.get() == it->second; }) != m_threads.end()) {
+#ifdef USE_LLVM
+        auto promise = it->second->promise();
+
+        if (promise)
+            promise->resolve();
+#else
         it->second->resolvePromise();
+#endif
+    }
 
     if (wait)
         m_broadcastSenders[broadcast] = sender;

src/engine/thread.cpp

@@ -5,6 +5,7 @@
 #ifdef USE_LLVM
 #include <scratchcpp/script.h>
 #include <scratchcpp/dev/executablecode.h>
+#include <scratchcpp/dev/executioncontext.h>
 #endif
 
 #include "thread_p.h"
@@ -87,22 +88,28 @@ bool Thread::isFinished() const
 #endif
 }
 
+#ifdef USE_LLVM
+/*! Returns the script promise. */
+std::shared_ptr<Promise> Thread::promise() const
+{
+    return impl->executionContext->promise();
+}
+
+/*! Sets the script promise (yields until the promise is resolved). */
+void Thread::setPromise(std::shared_ptr<Promise> promise)
+{
+    impl->executionContext->setPromise(promise);
+}
+#else
 /*! Pauses the script (when it's executed using run() again) until resolvePromise() is called. */
 void Thread::promise()
 {
-#ifdef USE_LLVM
-    impl->code->promise();
-#else
     impl->vm->promise();
-#endif
 }
 
 /*! Resolves the promise and resumes the script. */
 void Thread::resolvePromise()
 {
-#ifdef USE_LLVM
-    impl->code->resolvePromise();
-#else
     impl->vm->resolvePromise();
-#endif
 }
+#endif // USE_LLVM

test/thread/thread_test.cpp

@@ -2,6 +2,7 @@
 #include <scratchcpp/script.h>
 #include <scratchcpp/virtualmachine.h>
 #include <scratchcpp/dev/executioncontext.h>
+#include <scratchcpp/dev/promise.h>
 #include <targetmock.h>
 #include <enginemock.h>
 #include <executablecodemock.h>
@@ -76,5 +77,19 @@ TEST_F(ThreadTest, IsFinished)
     ASSERT_TRUE(m_thread->isFinished());
 }
 
-// TODO: Test promise() and resolvePromise()
+TEST_F(ThreadTest, Promise)
+{
+    ASSERT_EQ(m_thread->promise(), m_ctx->promise());
+
+    auto promise = std::make_shared<Promise>();
+    m_ctx->setPromise(promise);
+    ASSERT_EQ(m_thread->promise(), m_ctx->promise());
+
+    m_ctx->setPromise(nullptr);
+    ASSERT_EQ(m_thread->promise(), m_ctx->promise());
+
+    m_thread->setPromise(promise);
+    ASSERT_EQ(m_thread->promise(), promise);
+    ASSERT_EQ(m_ctx->promise(), promise);
+}
 #endif // USE_LLVM