@lucent-lang/lucent 0.0.4 → 0.1.1

package/runtime/cpp/lucent/lifecycle.cpp

@@ -0,0 +1,260 @@
+#include "lifecycle.h"
+
+#include <algorithm>
+#include <atomic>
+#include <map>
+#include <mutex>
+#include <stdexcept>
+#include <string>
+
+#include "execution.h"
+#include "report.h"
+
+namespace lucent {
+
+namespace detail {
+
+/// One subscription's listener. `live` turns false when it closes, so a
+/// report that already took it skips it.
+struct LifecycleListener {
+  enum class Kind : uint8_t { App, Scene };
+
+  Kind kind;
+  uint8_t event;
+  Lifecycle::AppListener app;
+  Lifecycle::SceneListener scene;
+  std::atomic<bool> live{true};
+};
+
+struct LifecycleState {
+  struct Scene {
+    SceneId id;
+    /// When it last connected or activated: the order of scenes().
+    uint64_t touched;
+    std::shared_ptr<Scope> scope;
+  };
+
+  struct Subscription {
+    std::shared_ptr<LifecycleListener> listener;
+    /// Kept here: the subscription lasts until it closes, not until its
+    /// handle goes.
+    std::shared_ptr<Resource> handle;
+  };
+
+  mutable std::mutex m;
+  std::vector<Scene> scenes;
+  uint64_t touches = 0;
+  uint64_t nextSubscription = 1;
+  // Keyed by id, so listeners run in subscription order.
+  std::map<uint64_t, Subscription> subscriptions;
+
+  Scene* find(SceneId id) {
+    auto it = std::find_if(scenes.begin(), scenes.end(), [id](const Scene& s) { return s.id == id; });
+    return it == scenes.end() ? nullptr : &*it;
+  }
+
+  /// The open listeners of an event, in subscription order.
+  std::vector<std::shared_ptr<LifecycleListener>> listenersOf(LifecycleListener::Kind kind, uint8_t event) const {
+    std::lock_guard<std::mutex> g(m);
+    std::vector<std::shared_ptr<LifecycleListener>> out;
+
+    for (const auto& [id, s] : subscriptions)
+      if (s.listener->kind == kind && s.listener->event == event) out.push_back(s.listener);
+
+    return out;
+  }
+};
+
+}  // namespace detail
+
+namespace {
+
+// Constant-initialized: safe to use during static initialization.
+std::atomic<SceneId> nextScene{1};
+
+void requireMain(const char* what) {
+  if (!onMainThread()) throw std::logic_error(std::string("Lifecycle::") + what + " is reported on the main thread");
+}
+
+/// Runs the listeners a report took, skipping those closed since.
+void run(const std::vector<std::shared_ptr<detail::LifecycleListener>>& listeners, SceneId scene) {
+  for (const auto& l : listeners) {
+    if (!l->live.load(std::memory_order_acquire)) continue;
+
+    try {
+      if (l->kind == detail::LifecycleListener::Kind::App) {
+        l->app();
+      } else {
+        l->scene(scene);
+      }
+    } catch (...) {
+      reportUncaught(std::current_exception(), "lifecycle listener");
+    }
+  }
+}
+
+}  // namespace
+
+Lifecycle::Lifecycle() : state_(std::make_shared<detail::LifecycleState>()) {}
+
+Lifecycle::~Lifecycle() {
+  std::vector<detail::LifecycleState::Scene> scenes;
+  std::map<uint64_t, detail::LifecycleState::Subscription> subscriptions;
+  {
+    std::lock_guard<std::mutex> g(state_->m);
+    scenes.swap(state_->scenes);
+    subscriptions.swap(state_->subscriptions);
+  }
+
+  for (auto& [id, s] : subscriptions) s.listener->live.store(false, std::memory_order_release);
+
+  for (auto& scene : scenes)
+    if (auto e = scene.scope->dispose()) reportUncaught(e, "scene");
+}
+
+Lifecycle& Lifecycle::shared() {
+  // Never destroyed: the platform may report while the process exits.
+  static auto* lifecycle = new Lifecycle();
+  return *lifecycle;
+}
+
+SceneId Lifecycle::connect() {
+  requireMain("connect");
+
+  SceneId id = nextScene.fetch_add(1);
+
+  std::lock_guard<std::mutex> g(state_->m);
+  state_->scenes.push_back({id, ++state_->touches, Scope::create(0)});
+
+  return id;
+}
+
+void Lifecycle::report(SceneId scene, SceneEvent event) {
+  requireMain("report");
+
+  {
+    std::lock_guard<std::mutex> g(state_->m);
+    detail::LifecycleState::Scene* known = state_->find(scene);
+    if (!known) return;
+
+    if (event == SceneEvent::DidActivate) known->touched = ++state_->touches;
+  }
+
+  run(state_->listenersOf(detail::LifecycleListener::Kind::Scene, static_cast<uint8_t>(event)), scene);
+
+  if (event != SceneEvent::DidDisconnect) return;
+
+  std::shared_ptr<Scope> scope;
+  {
+    std::lock_guard<std::mutex> g(state_->m);
+    auto& scenes = state_->scenes;
+    auto it = std::find_if(scenes.begin(), scenes.end(), [scene](const auto& s) { return s.id == scene; });
+    if (it == scenes.end()) return;
+
+    scope = std::move(it->scope);
+    scenes.erase(it);
+  }
+
+  if (auto e = scope->dispose()) reportUncaught(e, "scene");
+}
+
+void Lifecycle::report(AppEvent event) {
+  requireMain("report");
+
+  run(state_->listenersOf(detail::LifecycleListener::Kind::App, static_cast<uint8_t>(event)), 0);
+}
+
+std::vector<SceneId> Lifecycle::scenes() const {
+  std::vector<detail::LifecycleState::Scene> scenes;
+  {
+    std::lock_guard<std::mutex> g(state_->m);
+    scenes = state_->scenes;
+  }
+
+  std::sort(scenes.begin(), scenes.end(), [](const auto& a, const auto& b) { return a.touched > b.touched; });
+
+  std::vector<SceneId> out;
+  for (const auto& s : scenes) out.push_back(s.id);
+  return out;
+}
+
+std::shared_ptr<Scope> Lifecycle::sceneScope(SceneId scene) const {
+  std::lock_guard<std::mutex> g(state_->m);
+  detail::LifecycleState::Scene* known = state_->find(scene);
+
+  return known ? known->scope : nullptr;
+}
+
+std::shared_ptr<Resource> Lifecycle::subscribe(AppEvent event, AppListener listener, const std::shared_ptr<Scope>& scope) {
+  if (!listener) throw std::invalid_argument("A lifecycle listener must be a function");
+
+  auto l = std::make_shared<detail::LifecycleListener>();
+  l->kind = detail::LifecycleListener::Kind::App;
+  l->event = static_cast<uint8_t>(event);
+  l->app = std::move(listener);
+
+  return add(std::move(l), scope);
+}
+
+std::shared_ptr<Resource> Lifecycle::subscribe(SceneEvent event, SceneListener listener, const std::shared_ptr<Scope>& scope) {
+  if (!listener) throw std::invalid_argument("A lifecycle listener must be a function");
+
+  auto l = std::make_shared<detail::LifecycleListener>();
+  l->kind = detail::LifecycleListener::Kind::Scene;
+  l->event = static_cast<uint8_t>(event);
+  l->scene = std::move(listener);
+
+  return add(std::move(l), scope);
+}
+
+std::shared_ptr<Resource> Lifecycle::add(std::shared_ptr<detail::LifecycleListener> listener, const std::shared_ptr<Scope>& scope) {
+  uint64_t id;
+  {
+    std::lock_guard<std::mutex> g(state_->m);
+    id = state_->nextSubscription++;
+  }
+
+  std::weak_ptr<detail::LifecycleState> weak = state_;
+  auto release = [weak, listener, id] {
+    listener->live.store(false, std::memory_order_release);
+
+    // Taken out under the lock and destroyed after it: the listener's
+    // captures, and the table's reference to this subscription.
+    detail::LifecycleState::Subscription removed;
+    if (auto state = weak.lock()) {
+      std::lock_guard<std::mutex> g(state->m);
+      auto it = state->subscriptions.find(id);
+      if (it == state->subscriptions.end()) return;
+
+      removed = std::move(it->second);
+      state->subscriptions.erase(it);
+    }
+  };
+
+  // Opened first: under a scope that has ended, it closes at once, before
+  // it is ever listed.
+  std::shared_ptr<Resource> handle = Resource::open(String::fromLatin1("Lifecycle subscription"), std::move(release), nullptr, scope);
+  if (!handle->isOpen()) return handle;
+
+  std::lock_guard<std::mutex> g(state_->m);
+  // Closed by its scope on another thread in the meantime: never listed.
+  if (!listener->live.load(std::memory_order_acquire)) return handle;
+
+  state_->subscriptions.emplace(id, detail::LifecycleState::Subscription{std::move(listener), handle});
+  return handle;
+}
+
+size_t Lifecycle::subscriptions() const {
+  std::lock_guard<std::mutex> g(state_->m);
+  return state_->subscriptions.size();
+}
+
+std::optional<SceneId> presentingScene(const std::vector<SceneId>& scenes, const std::function<SceneState(SceneId)>& stateOf) {
+  for (SceneState wanted : {SceneState::ForegroundActive, SceneState::ForegroundInactive})
+    for (SceneId s : scenes)
+      if (stateOf(s) == wanted) return s;
+
+  return std::nullopt;
+}
+
+}  // namespace lucent

package/runtime/cpp/lucent/lifecycle.h

@@ -0,0 +1,124 @@
+// Lucent runtime — the app's and its scenes' lifecycle.
+//
+// The platform adapter (lucent/platform/ios_ui.mm) reports what the
+// platform posts, on the main thread: the app becoming active or going to
+// the background, and each scene connecting, activating, and
+// disconnecting. Lucent code subscribes to those events. Nothing here
+// knows UIKit: a scene is a SceneId, never a pointer, so nothing here can
+// keep a window or view controller alive.
+//
+// Each connected scene has a scope, disposed when the scene disconnects:
+// work tied to what the scene shows (a presentation, say) ends with it.
+#pragma once
+
+#include <cstdint>
+#include <functional>
+#include <memory>
+#include <optional>
+#include <vector>
+
+#include "resource.h"
+#include "scope.h"
+
+namespace lucent {
+
+/// Process-unique and never reused; 0 is none.
+using SceneId = uint64_t;
+
+/// UIApplication's lifecycle notifications.
+enum class AppEvent : uint8_t {
+  DidBecomeActive,
+  WillResignActive,
+  DidEnterBackground,
+  WillEnterForeground,
+  DidReceiveMemoryWarning,
+  WillTerminate,
+};
+
+/// UIScene's lifecycle notifications.
+enum class SceneEvent : uint8_t {
+  WillConnect,
+  DidDisconnect,
+  DidActivate,
+  WillDeactivate,
+  WillEnterForeground,
+  DidEnterBackground,
+};
+
+/// UIScene.ActivationState.
+enum class SceneState : uint8_t { Unattached, ForegroundActive, ForegroundInactive, Background };
+
+namespace detail {
+struct LifecycleState;
+struct LifecycleListener;
+}
+
+/// What the platform reported, and who listens. Construction does nothing
+/// else; destruction disposes the scopes of the scenes still connected.
+class Lifecycle {
+ public:
+  using AppListener = std::function<void()>;
+  using SceneListener = std::function<void(SceneId)>;
+
+  Lifecycle();
+  ~Lifecycle();
+
+  Lifecycle(const Lifecycle&) = delete;
+  Lifecycle& operator=(const Lifecycle&) = delete;
+
+  /// The process's, which the platform adapter reports to.
+  static Lifecycle& shared();
+
+  // --- what the platform reports: on the main thread only (std::logic_error
+  // elsewhere) -------------------------------------------------------------
+
+  /// A scene the platform connected, or found connected: its new id, and a
+  /// scope for it. Nothing is announced: the platform reports WillConnect
+  /// once it can name the scene.
+  SceneId connect();
+
+  /// Runs the event's listeners with the scene. DidActivate makes it the
+  /// most recently activated; DidDisconnect, after the listeners ran,
+  /// disposes its scope and forgets it. A scene it does not know is
+  /// ignored.
+  void report(SceneId scene, SceneEvent event);
+
+  void report(AppEvent event);
+
+  // --- what it knows: any thread ------------------------------------------
+
+  /// The connected scenes, most recently activated first (or, until
+  /// activated, connected).
+  std::vector<SceneId> scenes() const;
+
+  /// The scene's scope while it is connected, else null.
+  std::shared_ptr<Scope> sceneScope(SceneId scene) const;
+
+  // --- subscriptions: any thread ------------------------------------------
+
+  /// Calls `listener` on each `event`, on the main thread, from the next
+  /// report on. The subscription is open until it is closed or `scope` is
+  /// disposed (under a scope that has ended, it is closed at once);
+  /// dropping the handle does not end it. Closed on the main thread, its
+  /// listener never runs again; closed on another thread while an event is
+  /// being reported, it may still hear that event (closing never waits).
+  /// What a listener throws is reported (reportUncaught), and the rest
+  /// still run.
+  std::shared_ptr<Resource> subscribe(AppEvent event, AppListener listener, const std::shared_ptr<Scope>& scope = nullptr);
+  std::shared_ptr<Resource> subscribe(SceneEvent event, SceneListener listener, const std::shared_ptr<Scope>& scope = nullptr);
+
+  /// Open subscriptions (for debug ownership reports and tests).
+  size_t subscriptions() const;
+
+ private:
+  std::shared_ptr<Resource> add(std::shared_ptr<detail::LifecycleListener> listener, const std::shared_ptr<Scope>& scope);
+
+  const std::shared_ptr<detail::LifecycleState> state_;
+};
+
+/// The scene to present from, of `scenes` (most recently activated first):
+/// the first in the foreground and active, else the first in the
+/// foreground; none while every scene is in the background or unattached.
+std::optional<SceneId> presentingScene(const std::vector<SceneId>& scenes, const std::function<SceneState(SceneId)>& stateOf);
+
+}  // namespace lucent

package/runtime/cpp/lucent/lucent.h

@@ -4,11 +4,16 @@
 #include "abort.h"
 #include "array.h"
 #include "async.h"
+#include "bigint.h"
+#include "buffer.h"
 #include "bytes.h"
+#include "callback.h"
 #include "console.h"
+#include "conversions.h"
 #include "core.h"
 #include "date.h"
 #include "equality.h"
+#include "extension.h"
 #include "jserror.h"
 #include "function.h"
 #include "generator.h"
@@ -19,6 +24,8 @@
 #include "native.h"
 #include "number.h"
 #include "regexp.h"
+#include "report.h"
+#include "resource.h"
 #include "ops.h"
 #include "scheduler.h"
 #include "jsstring.h"

package/runtime/cpp/lucent/map.h

@@ -10,6 +10,7 @@
 #include <vector>
 
 #include "array.h"
+#include "bigint.h"
 #include "core.h"
 #include "equality.h"
 
@@ -28,10 +29,16 @@ struct KeyHash {
       return std::hash<uint64_t>()(bits);
     } else if constexpr (std::is_same_v<K, bool>) {
       return k ? 1 : 2;
-    } else if constexpr (std::is_same_v<K, String>) {
+    } else if constexpr (std::is_same_v<K, String> || std::is_same_v<K, BigInt>) {
       return k.hash();
     } else if constexpr (IsRef<K>::value) {
       return std::hash<const void*>()(static_cast<const void*>(k.get()));
+    } else if constexpr (IsOpt<K>::value) {
+      if (!k.has()) return k.isNull() ? 3 : 4;
+      return KeyHash<std::decay_t<decltype(k.get())>>()(k.get());
+    } else if constexpr (IsVariant<K>::value) {
+      // Equal members hash alike whichever alternative holds them.
+      return std::visit([](const auto& x) { return KeyHash<std::decay_t<decltype(x)>>()(x); }, k);
     } else {
       return std::hash<const void*>()(k.identity());
     }
@@ -224,13 +231,22 @@ class Map {
 
   Table& table() const { return *t_; }
   const void* identity() const { return t_.get(); }
-  friend bool strictEquals(const Map& a, const Map& b) { return a.t_ == b.t_; }
-  friend String toJsString(const Map&) { return String::fromLatin1("[object Map]"); }
 
  private:
   std::shared_ptr<Table> t_;
 };
 
+template <class K, class V>
+String toJsString(const Map<K, V>&) {
+  return String::fromLatin1("[object Map]");
+}
+
+/// `===`: the same map.
+template <class K, class V>
+bool strictEquals(const Map<K, V>& a, const Map<K, V>& b) {
+  return a.identity() == b.identity();
+}
+
 template <class T>
 class Set {
  public:
@@ -268,13 +284,22 @@ class Set {
 
   Table& table() const { return *t_; }
   const void* identity() const { return t_.get(); }
-  friend bool strictEquals(const Set& a, const Set& b) { return a.t_ == b.t_; }
-  friend String toJsString(const Set&) { return String::fromLatin1("[object Set]"); }
 
  private:
   std::shared_ptr<Table> t_;
 };
 
+template <class T>
+String toJsString(const Set<T>&) {
+  return String::fromLatin1("[object Set]");
+}
+
+/// `===`: the same set.
+template <class T>
+bool strictEquals(const Set<T>& a, const Set<T>& b) {
+  return a.identity() == b.identity();
+}
+
 /// `Record<string, V>` / `{ [key: string]: V }`: a plain object used as a
 /// dictionary.
 template <class V>
@@ -319,8 +344,6 @@ class Dict {
 
   Table& table() const { return *t_; }
   const void* identity() const { return t_.get(); }
-  friend bool strictEquals(const Dict& a, const Dict& b) { return a.t_ == b.t_; }
-  friend String toJsString(const Dict&) { return String::fromLatin1("[object Object]"); }
 
   static bool isArrayIndex(const String& k, double& out) {
     size_t n = k.length();
@@ -341,4 +364,15 @@ class Dict {
   std::shared_ptr<Table> t_;
 };
 
+template <class V>
+String toJsString(const Dict<V>&) {
+  return String::fromLatin1("[object Object]");
+}
+
+/// `===`: the same record.
+template <class V>
+bool strictEquals(const Dict<V>& a, const Dict<V>& b) {
+  return a.identity() == b.identity();
+}
+
 }  // namespace lucent

package/runtime/cpp/lucent/native.cpp

@@ -11,65 +11,53 @@
 namespace lucent {
 namespace {
 std::atomic<long> nativeRefs{0};
-}
+std::atomic<long> moduleRefs{0};
+}  // namespace
+
 long liveNativeRefs() { return nativeRefs.load(); }
-void detail::countNativeRef(int delta) { nativeRefs += delta; }
+
+long moduleNativeRefs() { return moduleRefs.load(); }
+
+bool detail::countNativeRef() {
+  nativeRefs++;
+
+  // Made in the main context: a view's, which the renderer releases with it.
+  if (ExecutionContext::current() == &ExecutionContext::main()) return false;
+
+  moduleRefs++;
+  return true;
+}
+
+void detail::uncountNativeRef(bool module, bool held) {
+  if (module) moduleRefs--;
+  if (!held) nativeRefs--;
+}
+
+void detail::releaseNative(void* handle, void (*release)(void*), ExecutionContext* on, bool module) {
+  detail::runOn(on, [handle, release, module] {
+    release(handle);
+    uncountNativeRef(module);
+  });
+}
 }  // namespace lucent
 
 #if !defined(__ANDROID__) && !(defined(TARGET_OS_IOS) && TARGET_OS_IOS)
 
-#include <condition_variable>
-#include <deque>
-#include <mutex>
-#include <thread>
-
 namespace lucent {
 
 namespace {
 
-class HostMainThread {
- public:
-  static HostMainThread& instance() {
-    static HostMainThread* t = new HostMainThread();  // lives for the process
-    return *t;
-  }
-  void post(std::function<void()> job) {
-    {
-      std::lock_guard<std::mutex> g(m_);
-      jobs_.push_back(std::move(job));
-    }
-    cv_.notify_one();
-  }
-  bool current() const { return std::this_thread::get_id() == id_; }
-
- private:
-  HostMainThread() {
-    std::thread t([this] { run(); });
-    id_ = t.get_id();
-    t.detach();
-  }
-  void run() {
-    for (;;) {
-      std::function<void()> job;
-      {
-        std::unique_lock<std::mutex> g(m_);
-        cv_.wait(g, [this] { return !jobs_.empty(); });
-        job = std::move(jobs_.front());
-        jobs_.pop_front();
-      }
-      job();
-    }
-  }
-  std::mutex m_;
-  std::condition_variable cv_;
-  std::deque<std::function<void()>> jobs_;
-  std::thread::id id_;
-};
+/// The host's stand-in for the platform's main thread: lives for the process.
+WorkerThread& hostMainThread() {
+  static auto* thread = new std::shared_ptr<WorkerThread>(WorkerThread::start([](Job& job) { detail::runGuarded(job, "job"); }));
+  return **thread;
+}
 
 }  // namespace
 
-void postToMain(std::function<void()> job) { HostMainThread::instance().post(std::move(job)); }
-bool onMainThread() { return HostMainThread::instance().current(); }
+void postToMain(std::function<void()> job) { hostMainThread().post(std::move(job)); }
+
+bool onMainThread() { return hostMainThread().isCurrent(); }
 
 }  // namespace lucent