@lucent-lang/lucent 0.0.4 → 0.1.0

package/runtime/cpp/lucent/equality.h

@@ -1,7 +1,20 @@
-// Lucent runtime — `===` and SameValueZero.
+// Lucent runtime — `===`, loose `==` and SameValueZero.
+//
+// Each type's `strictEquals` (and `toJsString`) is declared at namespace
+// scope, next to the type (array.h, map.h, bytes.h, …), never as a hidden
+// friend: generated code calls `lucent::strictEquals` qualified, and
+// qualified lookup does not see hidden friends.
+//
+// Operands may have different C++ types: TypeScript allows comparing types
+// that overlap, and a generic instantiated with an object type still
+// compares it with `undefined` or `0`. Optionals and unions compare what
+// they hold; class instances compare as objects; any other pair of
+// different types holds no common JavaScript value, so it is never equal.
 #pragma once
 
 #include <cmath>
+#include <tuple>
+#include <type_traits>
 #include <variant>
 
 #include "core.h"
@@ -9,6 +22,43 @@
 
 namespace lucent {
 
+namespace detail {
+
+template <class T>
+struct TupleArity : std::integral_constant<int, -1> {};
+template <class... Ts>
+struct TupleArity<std::tuple<Ts...>> : std::integral_constant<int, sizeof...(Ts)> {};
+
+/// Types whose values another C++ type can also hold: an optional's or a
+/// union's (they compare what they hold).
+template <class T>
+inline constexpr bool holdsOthers = IsOpt<T>::value || IsVariant<T>::value;
+
+/// Numbers of two C++ types compare as numbers (by conversion), not as
+/// different types.
+template <class T>
+inline constexpr bool numeric = std::is_arithmetic_v<T> && !std::is_same_v<T, bool>;
+
+}  // namespace detail
+
+/// No JavaScript value is both an A and a B. Excluded, because they may be
+/// one value: one type (its own overload), optionals and unions (they
+/// compare what they hold), two class instances (one object seen through
+/// a base class), two tuples of one length (element by element), and two
+/// numeric types (one number).
+template <class A, class B>
+concept Disjoint = !std::is_same_v<A, B> && !detail::holdsOthers<A> && !detail::holdsOthers<B> &&
+                   !(IsRef<A>::value && IsRef<B>::value) &&
+                   !(detail::TupleArity<A>::value >= 0 && detail::TupleArity<A>::value == detail::TupleArity<B>::value) &&
+                   !(detail::numeric<A> && detail::numeric<B>);
+
+/// A number and a bigint, null and undefined, an array and `0`: never `===`.
+template <class A, class B>
+  requires Disjoint<A, B>
+constexpr bool strictEquals(const A&, const B&) {
+  return false;
+}
+
 inline bool strictEquals(double a, double b) { return a == b; }
 inline bool strictEquals(bool a, bool b) { return a == b; }
 inline bool strictEquals(const String& a, const String& b) { return a == b; }
@@ -20,10 +70,10 @@ bool strictEquals(const Ref<A>& a, const Ref<B>& b) {
   return static_cast<const void*>(a.get()) == static_cast<const void*>(b.get());
 }
 
-template <class T>
-bool strictEquals(const Opt<T>& a, const Opt<T>& b) {
-  if (a.state() != b.state()) return false;
-  return !a.has() || strictEquals(a.get(), b.get());
+template <class A, class B>
+bool strictEquals(const Opt<A>& a, const Opt<B>& b) {
+  if (a.has() && b.has()) return strictEquals(a.get(), b.get());
+  return a.isUndefined() == b.isUndefined() && a.isNull() == b.isNull();
 }
 template <class T>
 bool strictEquals(const Opt<T>& a, Undefined) {
@@ -41,47 +91,76 @@ template <class T>
 bool strictEquals(Null, const Opt<T>& a) {
   return a.isNull();
 }
-template <class T, class U, std::enable_if_t<!IsOpt<U>::value && !std::is_same_v<U, Undefined> && !std::is_same_v<U, Null>, int> = 0>
+template <class T, class U>
+  requires(!IsOpt<U>::value && !IsAbsent<U>)
 bool strictEquals(const Opt<T>& a, const U& b) {
   return a.has() && strictEquals(a.get(), b);
 }
-template <class T, class U, std::enable_if_t<!IsOpt<U>::value && !std::is_same_v<U, Undefined> && !std::is_same_v<U, Null>, int> = 0>
+template <class T, class U>
+  requires(!IsOpt<U>::value && !IsAbsent<U>)
 bool strictEquals(const U& b, const Opt<T>& a) {
   return a.has() && strictEquals(b, a.get());
 }
 
-template <class... Ts>
-bool strictEquals(const std::variant<Ts...>& a, const std::variant<Ts...>& b) {
-  if (a.index() != b.index()) return false;
-  return std::visit(
-      [&](const auto& x) {
-        using X = std::decay_t<decltype(x)>;
-        return strictEquals(x, std::get<X>(b));
-      },
-      a);
-}
-template <class... Ts, class U, std::enable_if_t<!IsOpt<U>::value, int> = 0>
+/// Unions compare the members they hold, so members of different types
+/// meet the rules above (`number | string` against `string | boolean`).
+template <class... As, class... Bs>
+bool strictEquals(const std::variant<As...>& a, const std::variant<Bs...>& b) {
+  return std::visit([](const auto& x, const auto& y) { return strictEquals(x, y); }, a, b);
+}
+template <class... Ts, class U>
+  requires(!IsOpt<U>::value && !IsVariant<U>::value)
 bool strictEquals(const std::variant<Ts...>& a, const U& b) {
-  if (const U* p = std::get_if<U>(&a)) return strictEquals(*p, b);
-  return false;
+  return std::visit([&](const auto& x) { return strictEquals(x, b); }, a);
+}
+template <class... Ts, class U>
+  requires(!IsOpt<U>::value && !IsVariant<U>::value)
+bool strictEquals(const U& a, const std::variant<Ts...>& b) {
+  return std::visit([&](const auto& y) { return strictEquals(a, y); }, b);
 }
 
-/// Loose `==` only differs from `===` for null/undefined in Lucent's typed
-/// world: `x == null` is true for both absent states.
+/// `x == null`: true for undefined and null, false for any present value.
+template <class T>
+bool looseEqualsNull(const T&) {
+  return false;
+}
+inline bool looseEqualsNull(Undefined) { return true; }
+inline bool looseEqualsNull(Null) { return true; }
 template <class T>
 bool looseEqualsNull(const Opt<T>& a) {
   return !a.has();
 }
 
-inline bool sameValueZero(double a, double b) { return a == b || (std::isnan(a) && std::isnan(b)); }
+/// Loose `==` differs from `===` only for null and undefined in Lucent's
+/// typed world (the compiler refuses the comparisons JavaScript converts).
 template <class A, class B>
-bool sameValueZero(const A& a, const B& b) {
-  return strictEquals(a, b);
+bool looseEquals(const A& a, const B& b) {
+  return strictEquals(a, b) || (looseEqualsNull(a) && looseEqualsNull(b));
+}
+
+namespace detail {
+
+/// Whether `v` holds NaN, where SameValueZero differs from `===`.
+template <class T>
+bool holdsNaN(const T& v) {
+  if constexpr (std::is_floating_point_v<T>) return std::isnan(v);
+  return false;
 }
 template <class T>
-bool sameValueZero(const Opt<T>& a, const Opt<T>& b) {
-  if (a.state() != b.state()) return false;
-  return !a.has() || sameValueZero(a.get(), b.get());
+bool holdsNaN(const Opt<T>& v) {
+  return v.has() && holdsNaN(v.get());
+}
+template <class... Ts>
+bool holdsNaN(const std::variant<Ts...>& v) {
+  return std::visit([](const auto& x) { return holdsNaN(x); }, v);
+}
+
+}  // namespace detail
+
+/// SameValueZero (includes, Map and Set keys): `===`, but NaN is NaN.
+template <class A, class B>
+bool sameValueZero(const A& a, const B& b) {
+  return strictEquals(a, b) || (detail::holdsNaN(a) && detail::holdsNaN(b));
 }
 
 }  // namespace lucent

package/runtime/cpp/lucent/execution.cpp

@@ -0,0 +1,416 @@
+#include "execution.h"
+
+#include <mutex>
+#include <stdexcept>
+
+// The legacy module context is entered by its lock rather than by the
+// thread-local below, so current() asks the lock first.
+#include "scheduler.h"
+#include "trace.h"
+
+namespace lucent {
+
+namespace {
+
+// Constant-initialized: safe to use during static initialization.
+std::atomic<ContextId> nextContextId{1};
+
+// The context this thread entered, other than the legacy module context.
+thread_local ExecutionContext* entered = nullptr;
+
+/// Runs the main context's timers: the platform's main loop has none that
+/// every platform shares, and they must not wait behind module code.
+WorkerThread& clock() {
+  static auto* thread = new std::shared_ptr<WorkerThread>(WorkerThread::start([](Job& job) { detail::runGuarded(job, "job"); }));
+  return **thread;
+}
+
+class MainContext final : public ExecutionContext {
+ public:
+  MainContext() = default;
+
+ private:
+  bool dispatch(Job job) override {
+    postToMain([this, job = std::move(job)]() mutable { runTurn(job); });
+    return true;
+  }
+
+  bool dispatchDelayed(double ms, Job job) override {
+    return clock().postDelayed(ms, [this, job = std::move(job)]() mutable { post(std::move(job)); });
+  }
+
+  bool onExecutor() const override { return onMainThread(); }
+};
+
+}  // namespace
+
+void detail::runGuarded(Job& job, const char* where) {
+  try {
+    job();
+  } catch (...) {
+    reportUncaught(std::current_exception(), where);
+  }
+}
+
+void detail::runOn(ExecutionContext* on, Job job) {
+  if (on && !on->onExecutor()) {
+    // Kept here as well: a context that refuses the job destroys it.
+    auto kept = std::make_shared<Job>(std::move(job));
+    if (on->post([kept] { (*kept)(); })) return;
+
+    job = std::move(*kept);
+  }
+
+  job();
+}
+
+// --- WorkerThread ---------------------------------------------------------------
+
+std::shared_ptr<WorkerThread> WorkerThread::start(Run run) {
+  std::shared_ptr<WorkerThread> worker(new WorkerThread(std::move(run)));
+
+  std::thread thread([worker] { worker->loop(); });
+  worker->id_ = thread.get_id();
+  thread.detach();
+
+  return worker;
+}
+
+bool WorkerThread::post(Job job) {
+  {
+    std::lock_guard<std::mutex> g(m_);
+
+    if (stopping_) return false;
+
+    jobs_.push_back(std::move(job));
+  }
+
+  cv_.notify_one();
+  return true;
+}
+
+bool WorkerThread::postDelayed(double ms, Job job) {
+  if (!(ms > 0)) ms = 0;
+  auto at = std::chrono::steady_clock::now() + std::chrono::microseconds(static_cast<int64_t>(ms * 1000));
+
+  {
+    std::lock_guard<std::mutex> g(m_);
+
+    if (stopping_) return false;
+
+    timers_.push(Timer{at, timerSeq_++, std::move(job)});
+  }
+
+  cv_.notify_one();
+  return true;
+}
+
+size_t WorkerThread::pendingWork() {
+  std::lock_guard<std::mutex> g(m_);
+  return jobs_.size() + timers_.size() + running_;
+}
+
+bool WorkerThread::waitIdle(double timeoutMs) {
+  std::unique_lock<std::mutex> g(m_);
+  return idleCv_.wait_for(g, std::chrono::microseconds(static_cast<int64_t>(timeoutMs * 1000)),
+                          [this] { return stopped_ || (jobs_.empty() && timers_.empty() && running_ == 0); });
+}
+
+void WorkerThread::stop(Job last) {
+  {
+    std::lock_guard<std::mutex> g(m_);
+
+    if (stopping_) return;
+
+    stopping_ = true;
+    last_ = std::move(last);
+  }
+
+  cv_.notify_all();
+}
+
+bool WorkerThread::waitStopped(double timeoutMs) {
+  std::unique_lock<std::mutex> g(m_);
+  return idleCv_.wait_for(g, std::chrono::microseconds(static_cast<int64_t>(timeoutMs * 1000)), [this] { return stopped_; });
+}
+
+void WorkerThread::loop() {
+  std::unique_lock<std::mutex> g(m_);
+
+  while (!stopping_) {
+    auto now = std::chrono::steady_clock::now();
+    while (!timers_.empty() && timers_.top().at <= now) {
+      jobs_.push_back(std::move(const_cast<Timer&>(timers_.top()).job));
+      timers_.pop();
+    }
+
+    if (!jobs_.empty()) {
+      Job job = std::move(jobs_.front());
+      jobs_.pop_front();
+      running_++;
+      g.unlock();
+
+      run_(job);
+      // Unlocked: what the job captured may post again.
+      job = nullptr;
+
+      g.lock();
+      running_--;
+      if (jobs_.empty() && timers_.empty() && running_ == 0) idleCv_.notify_all();
+      continue;
+    }
+
+    if (timers_.empty()) {
+      cv_.wait(g);
+    } else {
+      // A copy: wait_until reads the deadline after unlocking, when a
+      // postDelayed may have reallocated the heap.
+      const auto deadline = timers_.top().at;
+      cv_.wait_until(g, deadline);
+    }
+  }
+
+  Job last = std::move(last_);
+  std::deque<Job> dropped;
+  dropped.swap(jobs_);
+  auto timers = std::move(timers_);
+  g.unlock();
+
+  if (last) detail::runGuarded(last, "job");
+
+  // Released here, on this thread, like the jobs that ran.
+  last = nullptr;
+  dropped.clear();
+  timers = {};
+
+  g.lock();
+  stopped_ = true;
+  g.unlock();
+  idleCv_.notify_all();
+}
+
+// --- ExecutionContext -----------------------------------------------------------
+
+ExecutionContext::ExecutionContext(size_t* microtaskCount)
+    : id_(nextContextId.fetch_add(1, std::memory_order_relaxed)),
+      pendingMicrotasks_(microtaskCount ? microtaskCount : &ownMicrotasks_) {}
+
+ExecutionContext* ExecutionContext::current() {
+  if (Scheduler::lock().heldByCurrentThread()) return &Scheduler::instance();
+
+  return entered;
+}
+
+ContextRef ExecutionContext::currentRef() {
+  if (Scheduler::lock().heldByCurrentThread()) return nullptr;
+
+  ExecutionContext* context = entered;
+  return context ? context->shared_from_this() : nullptr;
+}
+
+ExecutionContext& ExecutionContext::legacy() { return Scheduler::instance(); }
+
+namespace {
+
+struct ModuleScope {
+  std::mutex m;
+  std::shared_ptr<Scope> scope;
+};
+
+/// Never destroyed: a scope released during static destruction could need
+/// contexts already gone.
+ModuleScope& moduleScopeState() {
+  static auto* state = new ModuleScope();
+  return *state;
+}
+
+}  // namespace
+
+std::shared_ptr<Scope> moduleScope() {
+  ModuleScope& state = moduleScopeState();
+
+  {
+    std::lock_guard<std::mutex> g(state.m);
+    if (state.scope) return state.scope;
+  }
+
+  return ExecutionContext::legacy().root();
+}
+
+void setModuleScope(std::shared_ptr<Scope> scope) {
+  ModuleScope& state = moduleScopeState();
+  std::lock_guard<std::mutex> g(state.m);
+
+  state.scope = std::move(scope);
+}
+
+ExecutionContext& ExecutionContext::main() {
+  // Leaked, like the main loop it stands for.
+  static auto* context = [] {
+    auto* kept = new std::shared_ptr<MainContext>(std::make_shared<MainContext>());
+    (*kept)->makeRoot();
+    return kept;
+  }();
+  return **context;
+}
+
+namespace {
+
+/// `job`, recording how long it waits for its owner and how long it runs,
+/// under one correlation id: the one a Correlate carried from the caller
+/// (a JS call), or a new one. The job running where it was posted is its
+/// parent.
+Job traced(Job job) {
+  uint64_t id = trace::takeCorrelation();
+  if (!id) id = trace::newId();
+
+  uint64_t parent = trace::currentId();
+  trace::Mark wait = trace::begin(trace::Category::Queue, "wait");
+
+  return [job = std::move(job), id, parent, wait]() mutable {
+    trace::end(wait, trace::Category::Queue, "wait", {.id = id, .parent = parent});
+
+    struct Running {
+      trace::Mark mark = trace::begin(trace::Category::Run, "run");
+      trace::Current current;
+      uint64_t id;
+      uint64_t parent;
+
+      Running(uint64_t id, uint64_t parent) : current(id), id(id), parent(parent) {}
+
+      ~Running() { trace::end(mark, trace::Category::Run, "run", {.id = id, .parent = parent}); }
+    } running(id, parent);
+
+    job();
+  };
+}
+
+}  // namespace
+
+bool ExecutionContext::post(Job job) {
+  if (trace::enabled()) [[unlikely]]
+    job = traced(std::move(job));
+
+  return dispatch(std::move(job));
+}
+
+bool ExecutionContext::post(Job job, const std::shared_ptr<Scope>& owner) {
+  if (!owner) return post(std::move(job));
+
+  if (owner->state() != Scope::State::Active) return false;
+
+  std::weak_ptr<Scope> weak = owner;
+  Generation generation = owner->generation();
+
+  return post([weak, generation, job = std::move(job)]() mutable {
+    auto scope = weak.lock();
+    if (!scope || scope->state() != Scope::State::Active || scope->generation() != generation) return;
+
+    job();
+  });
+}
+
+bool ExecutionContext::postDelayed(double ms, Job job) { return dispatchDelayed(ms, std::move(job)); }
+
+void ExecutionContext::enqueueMicrotask(Job job) {
+  if (!isCurrent()) throw std::logic_error("A microtask is queued on its own context; post to another one");
+
+  microtasks_.push_back(std::move(job));
+  ++*pendingMicrotasks_;
+}
+
+void ExecutionContext::drainMicrotasks() {
+  if (!isCurrent()) throw std::logic_error("A context's microtasks run on that context");
+
+  while (!microtasks_.empty()) {
+    Job job = std::move(microtasks_.front());
+    microtasks_.pop_front();
+    --*pendingMicrotasks_;
+
+    detail::runGuarded(job, "job");
+  }
+}
+
+void ExecutionContext::runTurn(Job& job) {
+  ContextEntry entry(*this);
+  Job local = std::move(job);
+
+  detail::runGuarded(local, "job");
+}
+
+// --- ContextEntry ---------------------------------------------------------------
+
+ContextEntry::ContextEntry(ExecutionContext& context) : context_(context), previous_(entered) {
+  if (&context == &ExecutionContext::legacy()) throw std::logic_error("The legacy module context is entered with LucentScope");
+
+  if (Scheduler::lock().heldByCurrentThread()) {
+    throw std::logic_error("Code holding the Lucent lock cannot enter another context; post to it");
+  }
+
+  if (previous_ && previous_ != &context) throw std::logic_error("A context cannot enter another one; post to it");
+
+  if (!context.onExecutor()) throw std::logic_error("A context is entered only on its own thread; post to it");
+
+  entered = &context;
+}
+
+ContextEntry::~ContextEntry() {
+  // The outermost entry: the stack is empty once it leaves.
+  if (previous_ != &context_) context_.drainMicrotasks();
+
+  entered = previous_;
+}
+
+// --- IsolatedContext ------------------------------------------------------------
+
+IsolatedContext::IsolatedContext() = default;
+
+std::shared_ptr<IsolatedContext> IsolatedContext::create() {
+  std::shared_ptr<IsolatedContext> context(new IsolatedContext());
+  std::weak_ptr<IsolatedContext> weak = context;
+
+  context->makeRoot();
+
+  // A job whose context is gone is dropped, destroyed on the thread.
+  context->worker_ = WorkerThread::start([weak](Job& job) {
+    if (auto self = weak.lock()) self->runTurn(job);
+  });
+
+  return context;
+}
+
+IsolatedContext::~IsolatedContext() { shutdown(); }
+
+void IsolatedContext::shutdown() {
+  if (stopping_.exchange(true)) return;
+
+  // Expired when called from the destructor: the root is then disposed
+  // outside a turn.
+  std::weak_ptr<ExecutionContext> weak = weak_from_this();
+
+  worker_->stop([weak, root = root()] {
+    Job dispose = [root] {
+      if (auto e = root->dispose()) reportUncaught(e, "scope");
+    };
+
+    if (auto self = weak.lock()) {
+      static_cast<IsolatedContext&>(*self).runTurn(dispose);
+    } else {
+      dispose();
+    }
+  });
+}
+
+bool IsolatedContext::dispatch(Job job) {
+  if (stopping_.load()) return false;
+
+  return worker_->post(std::move(job));
+}
+
+bool IsolatedContext::dispatchDelayed(double ms, Job job) {
+  if (stopping_.load()) return false;
+
+  return worker_->postDelayed(ms, std::move(job));
+}
+
+}  // namespace lucent