@lucent-lang/lucent 0.0.4

package/runtime/cpp/lucent/jsi/host.cpp

@@ -0,0 +1,322 @@
+#include "host.h"
+
+#include <cstring>
+#include <vector>
+
+namespace lucent::js {
+
+namespace {
+
+std::mutex& registryMutex() {
+  static std::mutex m;
+  return m;
+}
+std::unordered_map<jsi::Runtime*, std::weak_ptr<Host>>& registry() {
+  static auto* r = new std::unordered_map<jsi::Runtime*, std::weak_ptr<Host>>();
+  return *r;
+}
+
+// Changes whenever the registry does, so a thread's cached host is known
+// stale. Constant-initialized: reading it needs no guard.
+std::atomic<uint64_t> registryGeneration{1};
+
+// The last host this thread looked up: every call from JavaScript asks for
+// it, and a thread nearly always talks to one runtime. One thread_local, as
+// each costs a lookup on some platforms (__tlv_get_addr on Apple's).
+struct CachedHost {
+  jsi::Runtime* runtime = nullptr;
+  Host* host = nullptr;
+  uint64_t generation = 0;
+};
+thread_local CachedHost cached;
+
+// Installed on the JS global object so the runtime's teardown releases our
+// JSI references on the JS thread while the runtime still exists.
+class HostAnchor : public jsi::HostObject {
+ public:
+  explicit HostAnchor(std::shared_ptr<Host> host) : host_(std::move(host)) {}
+  ~HostAnchor() override {
+    if (host_) host_->invalidate();
+  }
+
+ private:
+  std::shared_ptr<Host> host_;
+};
+
+}  // namespace
+
+std::shared_ptr<Host> Host::create(jsi::Runtime& rt, JsPoster poster) {
+  std::shared_ptr<Host> host(new Host(rt, std::move(poster)));
+  {
+    std::lock_guard<std::mutex> g(registryMutex());
+    registry()[&rt] = host;
+    registryGeneration++;
+  }
+  rt.global().setProperty(rt, "__lucentHost", jsi::Object::createFromHostObject(rt, std::make_shared<HostAnchor>(host)));
+  {
+    LucentScope scope;
+    resetModuleState();
+  }
+  return host;
+}
+
+Host& Host::get(jsi::Runtime& rt) {
+  uint64_t generation = registryGeneration.load(std::memory_order_acquire);
+  CachedHost& c = cached;
+  if (c.runtime == &rt && c.generation == generation) return *c.host;
+  std::lock_guard<std::mutex> g(registryMutex());
+  auto it = registry().find(&rt);
+  if (it != registry().end()) {
+    if (auto h = it->second.lock()) {
+      c = {&rt, h.get(), registryGeneration.load(std::memory_order_relaxed)};
+      return *h;
+    }
+  }
+  throw jsi::JSError(rt, "Lucent is not initialized for this runtime");
+}
+
+const jsi::PropNameID& Host::makeProp(jsi::Runtime& rt, const PropName& name) {
+  if (name.id >= props_.size()) props_.resize(name.id + 1);
+  props_[name.id] = std::make_unique<jsi::PropNameID>(jsi::PropNameID::forUtf8(rt, name.text));
+  return *props_[name.id];
+}
+
+Host::Host(jsi::Runtime& rt, JsPoster poster) : rt_(rt), poster_(std::move(poster)), jsThread_(std::this_thread::get_id()) {}
+
+Host::~Host() {
+  std::lock_guard<std::mutex> g(registryMutex());
+  auto it = registry().find(&rt_);
+  if (it != registry().end() && it->second.expired()) registry().erase(it);
+  registryGeneration++;
+}
+
+void Host::postToJs(JsTask task) {
+  if (!alive_.load()) return;
+  std::weak_ptr<Host> weak = weak_from_this();
+  poster_([weak, task = std::move(task)](jsi::Runtime& rt) {
+    auto self = weak.lock();
+    if (!self || !self->alive()) return;
+    task(rt);
+  });
+}
+
+void Host::invalidate() {
+  if (!alive_.exchange(false)) return;
+  promises_.clear();
+  functions_.clear();
+  prototypes_.clear();
+  modules_.clear();
+  identities_.clear();
+  props_.clear();
+  std::lock_guard<std::mutex> g(registryMutex());
+  auto it = registry().find(&rt_);
+  if (it != registry().end()) registry().erase(it);
+  registryGeneration++;
+}
+
+jsi::Value Host::module(jsi::Runtime& rt, const std::string& name) {
+  auto it = modules_.find(name);
+  if (it != modules_.end()) return jsi::Value(rt, it->second);
+  size_t count = 0;
+  const ModuleDef* defs = registeredModules(count);
+  for (size_t i = 0; i < count; i++) {
+    if (name == defs[i].name) {
+      jsi::Object exports(rt);
+      {
+        LucentScope scope;
+        defs[i].install(rt, *this, exports);
+      }
+      jsi::Value v(rt, exports);
+      modules_.emplace(name, jsi::Value(rt, v));
+      return v;
+    }
+  }
+  return jsi::Value::undefined();
+}
+
+jsi::Object Host::modules(jsi::Runtime& rt) {
+  jsi::Object all(rt);
+  size_t count = 0;
+  const ModuleDef* defs = registeredModules(count);
+  for (size_t i = 0; i < count; i++) all.setProperty(rt, defs[i].name, module(rt, defs[i].name));
+  return all;
+}
+
+jsi::Value Host::createPromise(jsi::Runtime& rt, uint64_t& id) {
+  id = nextId_++;
+  auto slot = std::make_shared<std::pair<std::optional<jsi::Function>, std::optional<jsi::Function>>>();
+  auto executor = jsi::Function::createFromHostFunction(
+      rt, jsi::PropNameID::forAscii(rt, "executor"), 2,
+      [slot](jsi::Runtime& rt, const jsi::Value&, const jsi::Value* args, size_t count) -> jsi::Value {
+        slot->first.emplace(args[0].getObject(rt).getFunction(rt));
+        slot->second.emplace(args[1].getObject(rt).getFunction(rt));
+        return jsi::Value::undefined();
+      });
+  jsi::Value promise = rt.global().getPropertyAsFunction(rt, "Promise").callAsConstructor(rt, executor);
+  promises_.emplace(id, Resolvers{std::move(*slot->first), std::move(*slot->second)});
+  slot->first.reset();
+  slot->second.reset();
+  return promise;
+}
+
+void Host::resolve(jsi::Runtime& rt, uint64_t id, const jsi::Value& value) {
+  auto it = promises_.find(id);
+  if (it == promises_.end()) return;
+  Resolvers r = std::move(it->second);
+  promises_.erase(it);
+  r.resolve.call(rt, value);
+}
+
+void Host::reject(jsi::Runtime& rt, uint64_t id, const jsi::Value& error) {
+  auto it = promises_.find(id);
+  if (it == promises_.end()) return;
+  Resolvers r = std::move(it->second);
+  promises_.erase(it);
+  r.reject.call(rt, error);
+}
+
+uint64_t Host::retain(jsi::Runtime&, jsi::Function fn) {
+  uint64_t id = nextId_++;
+  functions_.emplace(id, std::move(fn));
+  return id;
+}
+
+jsi::Function* Host::retained(uint64_t id) {
+  auto it = functions_.find(id);
+  return it == functions_.end() ? nullptr : &it->second;
+}
+
+void Host::release(uint64_t id) {
+  if (onJsThread()) {
+    functions_.erase(id);
+    return;
+  }
+  std::weak_ptr<Host> weak = weak_from_this();
+  postToJs([weak, id](jsi::Runtime&) {
+    if (auto self = weak.lock()) self->functions_.erase(id);
+  });
+}
+
+jsi::Object& Host::prototype(jsi::Runtime& rt, const char* key, PrototypeInit init) {
+  auto it = prototypes_.find(key);
+  if (it != prototypes_.end()) return it->second;
+  // A class keeps one prototype per runtime, not per host: JavaScript may
+  // hold a replaced host's exports, and instanceof compares their prototypes
+  // with the ones this host gives new instances. A kept prototype gets this
+  // host's methods, so they call it directly.
+  jsi::Object global = rt.global();
+  jsi::Value storeValue = global.getProperty(rt, "__lucentPrototypes");
+  jsi::Object store = storeValue.isObject() ? storeValue.getObject(rt) : jsi::Object(rt);
+  if (!storeValue.isObject()) global.setProperty(rt, "__lucentPrototypes", store);
+  jsi::Value kept = store.getProperty(rt, key);
+  jsi::Object proto = kept.isObject() ? kept.getObject(rt) : jsi::Object(rt);
+  init(rt, *this, proto);
+  if (!kept.isObject()) store.setProperty(rt, key, proto);
+  return prototypes_.emplace(key, std::move(proto)).first->second;
+}
+
+namespace {
+std::atomic<uint64_t> nextIdentity{1};
+}  // namespace
+
+Ref<Object> instanceOf(jsi::Runtime& rt, const jsi::Value& v) {
+  if (!v.isObject()) return nullptr;
+  jsi::Object o = v.getObject(rt);
+  if (!o.hasNativeState(rt)) return nullptr;
+  auto s = std::dynamic_pointer_cast<InstanceState>(o.getNativeState(rt));
+  return s ? s->object : nullptr;
+}
+
+void defineFunction(jsi::Runtime& rt, jsi::Object& target, const char* name, unsigned argc, HostFn fn) {
+  target.setProperty(rt, name, jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forUtf8(rt, name), argc, std::move(fn)));
+}
+
+void defineAccessor(jsi::Runtime& rt, jsi::Object& target, const char* name, HostFn getter, HostFn setter) {
+  jsi::Object descriptor(rt);
+  descriptor.setProperty(rt, "enumerable", true);
+  descriptor.setProperty(rt, "configurable", true);
+  descriptor.setProperty(rt, "get", jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forUtf8(rt, name), 0, std::move(getter)));
+  if (setter) {
+    descriptor.setProperty(rt, "set", jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forUtf8(rt, name), 1, std::move(setter)));
+  }
+  rt.global()
+      .getPropertyAsObject(rt, "Object")
+      .getPropertyAsFunction(rt, "defineProperty")
+      .call(rt, target, jsi::String::createFromUtf8(rt, name), descriptor);
+}
+
+void defineClass(jsi::Runtime& rt, Host& host, jsi::Object& exports, const char* name, const char* key, Host::PrototypeInit init,
+                 unsigned argc, HostFn construct) {
+  jsi::Function factory = jsi::Function::createFromHostFunction(rt, jsi::PropNameID::forUtf8(rt, name), argc, std::move(construct));
+  factory.setProperty(rt, "prototype", jsi::Value(rt, host.prototype(rt, key, init)));
+  exports.setProperty(rt, name, factory);
+}
+
+jsi::Value Host::wrap(jsi::Runtime& rt, const Ref<Object>& instance, const char* key, PrototypeInit init) {
+  if (!instance) return jsi::Value::null();
+  if (instance->jsIdentity != 0) {
+    auto it = identities_.find(instance->jsIdentity);
+    if (it != identities_.end()) {
+      jsi::Value v = it->second.lock(rt);
+      if (v.isObject()) return v;
+    }
+  } else {
+    instance->jsIdentity = nextIdentity.fetch_add(1);
+  }
+  jsi::Object& proto = prototype(rt, key, init);
+  jsi::Object obj = jsi::Object::create(rt, jsi::Value(rt, proto));
+  obj.setNativeState(rt, std::make_shared<InstanceState>(instance));
+  // Periodically drop cache entries whose JS objects were collected.
+  if (++identitySweep_ >= 256) {
+    identitySweep_ = 0;
+    std::vector<uint64_t> dead;
+    for (auto& [id, weak] : identities_) {
+      if (!weak.lock(rt).isObject()) dead.push_back(id);
+    }
+    for (uint64_t id : dead) identities_.erase(id);
+  }
+  identities_.insert_or_assign(instance->jsIdentity, jsi::WeakObject(rt, obj));
+  return jsi::Value(std::move(obj));
+}
+
+jsi::Value Host::errorToJs(jsi::Runtime& rt, const Error& e) {
+  std::string name = e->name.toUtf8();
+  const char* ctor = (name == "TypeError" || name == "RangeError") ? name.c_str() : "Error";
+  jsi::Object err = rt.global()
+                        .getPropertyAsFunction(rt, ctor)
+                        .callAsConstructor(rt, jsi::String::createFromUtf8(rt, e->message.toUtf8()))
+                        .getObject(rt);
+  if (name != ctor) err.setProperty(rt, "name", jsi::String::createFromUtf8(rt, name));
+  if (e->code.has()) err.setProperty(rt, "code", jsi::String::createFromUtf8(rt, e->code.get().toUtf8()));
+  if (e->stack.has()) {
+    // An error that came from JavaScript keeps its original stack.
+    err.setProperty(rt, "stack", jsi::String::createFromUtf8(rt, e->stack.get().toUtf8()));
+  } else if (e->site.has()) {
+    // The Lucent frame where the error was created, above the JavaScript frames.
+    jsi::Value current = err.getProperty(rt, "stack");
+    std::string stack = current.isString() ? current.getString(rt).utf8(rt) : "";
+    size_t firstFrame = stack.find('\n');
+    std::string head = firstFrame == std::string::npos ? stack : stack.substr(0, firstFrame);
+    std::string frames = firstFrame == std::string::npos ? "" : stack.substr(firstFrame);
+    err.setProperty(rt, "stack", jsi::String::createFromUtf8(rt, head + "\n    at " + e->site.get().toUtf8() + frames));
+  }
+  return jsi::Value(std::move(err));
+}
+
+Error Host::errorFromJs(jsi::Runtime& rt, const jsi::JSError& e) {
+  Error out = makeError(String::fromLatin1("Error"), String::fromUtf8(e.getMessage()));
+  out->stack = String::fromUtf8(e.getStack());
+  const jsi::Value& v = e.value();
+  if (v.isObject()) {
+    jsi::Object o = v.getObject(rt);
+    jsi::Value name = o.getProperty(rt, "name");
+    if (name.isString()) out->name = String::fromUtf8(name.getString(rt).utf8(rt));
+    jsi::Value code = o.getProperty(rt, "code");
+    if (code.isString()) out->code = String::fromUtf8(code.getString(rt).utf8(rt));
+    jsi::Value message = o.getProperty(rt, "message");
+    if (message.isString()) out->message = String::fromUtf8(message.getString(rt).utf8(rt));
+  }
+  return out;
+}
+
+}  // namespace lucent::js

package/runtime/cpp/lucent/jsi/host.h

@@ -0,0 +1,166 @@
+// Lucent runtime — the JavaScript side of the boundary.
+//
+// A Host is created per JS runtime (the React Native TurboModule creates it;
+// tests create it directly). It owns every JSI object Lucent keeps alive:
+// pending promise resolvers, JS callbacks, class prototypes and the identity
+// cache. JSI values may only be touched on the JS thread, so native code
+// refers to them by id and hops to the JS thread to use them.
+#pragma once
+
+#include <jsi/jsi.h>
+
+#include <atomic>
+#include <functional>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <thread>
+#include <unordered_map>
+#include <vector>
+
+#include "../lucent.h"
+
+namespace lucent::js {
+
+namespace jsi = facebook::jsi;
+
+using JsTask = std::function<void(jsi::Runtime&)>;
+/// Schedules a task on the JS thread (CallInvoker::invokeAsync in React Native).
+using JsPoster = std::function<void(JsTask)>;
+
+class Host;
+
+/// A property name generated code reads or writes on JavaScript objects
+/// (a struct's fields): its jsi::PropNameID is made once per runtime and kept
+/// by the Host, instead of interning the name on every access.
+struct PropName {
+  const char* text;
+  size_t id;
+  explicit PropName(const char* t) : text(t), id(next()) {}
+
+ private:
+  static size_t next() {
+    static std::atomic<size_t> count{0};
+    return count++;
+  }
+};
+
+/// One Lucent module as seen from JavaScript: fills `exports` with the
+/// module's functions, classes and constants.
+struct ModuleDef {
+  const char* name;
+  void (*install)(jsi::Runtime& rt, Host& host, jsi::Object& exports);
+};
+
+/// Implemented by generated code: the modules of this app.
+const ModuleDef* registeredModules(size_t& count);
+/// Implemented by generated code: resets module-level state for a new runtime.
+void resetModuleState();
+
+class Host : public std::enable_shared_from_this<Host> {
+ public:
+  /// Creates the host for `rt`. Call on the JS thread.
+  static std::shared_ptr<Host> create(jsi::Runtime& rt, JsPoster poster);
+  static Host& get(jsi::Runtime& rt);
+  /// The host for a call to a function `installed` defined: that host while
+  /// it lives, without get()'s lookup (a thread_local, which Android builds
+  /// for minSdk < 29 emulate with pthread_getspecific), else get()'s.
+  static Host& from(jsi::Runtime& rt, const std::shared_ptr<Host>& installed) {
+    return installed->alive() ? *installed : get(rt);
+  }
+  ~Host();
+
+  jsi::Runtime& runtime() { return rt_; }
+  bool onJsThread() const { return std::this_thread::get_id() == jsThread_; }
+  bool alive() const { return alive_.load(); }
+
+  /// Runs `task` on the JS thread unless the host was invalidated.
+  void postToJs(JsTask task);
+  /// Drops every JSI reference. Call on the JS thread before the runtime dies.
+  void invalidate();
+
+  /// The exports object of a module, created on first use.
+  jsi::Value module(jsi::Runtime& rt, const std::string& name);
+  /// The object with every module as a property (for tests and debugging).
+  jsi::Object modules(jsi::Runtime& rt);
+
+  // --- promises ---------------------------------------------------------
+  /// Creates a JS promise; settle it later with resolve/reject on the JS thread.
+  jsi::Value createPromise(jsi::Runtime& rt, uint64_t& id);
+  void resolve(jsi::Runtime& rt, uint64_t id, const jsi::Value& value);
+  void reject(jsi::Runtime& rt, uint64_t id, const jsi::Value& error);
+
+  // --- callbacks ----------------------------------------------------------
+  uint64_t retain(jsi::Runtime& rt, jsi::Function fn);
+  jsi::Function* retained(uint64_t id);
+  /// Safe from any thread: releases on the JS thread.
+  void release(uint64_t id);
+
+  // --- classes --------------------------------------------------------------
+  using PrototypeInit = void (*)(jsi::Runtime& rt, Host& host, jsi::Object& proto);
+  /// The prototype for class `key`: the runtime's own across hosts (kept on
+  /// the global object), with this host's methods.
+  jsi::Object& prototype(jsi::Runtime& rt, const char* key, PrototypeInit init);
+  /// The JS object for a native instance: the same object each time while
+  /// JavaScript still references it.
+  jsi::Value wrap(jsi::Runtime& rt, const Ref<Object>& instance, const char* key, PrototypeInit init);
+
+  /// Converts a Lucent error into a JS Error object (not thrown).
+  jsi::Value errorToJs(jsi::Runtime& rt, const Error& e);
+  /// Converts a caught JS exception into a Lucent error.
+  static Error errorFromJs(jsi::Runtime& rt, const jsi::JSError& e);
+
+  /// The runtime's id for a property name, made on first use.
+  const jsi::PropNameID& prop(jsi::Runtime& rt, const PropName& name) {
+    if (name.id < props_.size() && props_[name.id]) return *props_[name.id];
+    return makeProp(rt, name);
+  }
+
+ private:
+  Host(jsi::Runtime& rt, JsPoster poster);
+
+  struct Resolvers {
+    jsi::Function resolve;
+    jsi::Function reject;
+  };
+
+  jsi::Runtime& rt_;
+  JsPoster poster_;
+  std::thread::id jsThread_;
+  std::atomic<bool> alive_{true};
+  uint64_t nextId_ = 1;
+  std::unordered_map<uint64_t, Resolvers> promises_;
+  std::unordered_map<uint64_t, jsi::Function> functions_;
+  std::unordered_map<std::string, jsi::Object> prototypes_;
+  std::unordered_map<std::string, jsi::Value> modules_;
+  std::unordered_map<uint64_t, jsi::WeakObject> identities_;
+  size_t identitySweep_ = 0;
+  std::vector<std::unique_ptr<jsi::PropNameID>> props_;
+  const jsi::PropNameID& makeProp(jsi::Runtime& rt, const PropName& name);
+};
+
+/// Holds a strong reference to the Host while posting results back to JS.
+using HostRef = std::shared_ptr<Host>;
+
+/// NativeState attached to the JS object of a Lucent class instance.
+struct InstanceState : jsi::NativeState {
+  explicit InstanceState(Ref<Object> o) : object(std::move(o)) {}
+  Ref<Object> object;
+};
+using InstanceStateBase = InstanceState;
+
+/// The native instance behind a JS object, or null.
+Ref<Object> instanceOf(jsi::Runtime& rt, const jsi::Value& v);
+
+using HostFn = jsi::HostFunctionType;
+
+void defineFunction(jsi::Runtime& rt, jsi::Object& target, const char* name, unsigned argc, HostFn fn);
+/// Defines an enumerable accessor property; `setter` may be null.
+void defineAccessor(jsi::Runtime& rt, jsi::Object& target, const char* name, HostFn getter, HostFn setter);
+/// Exports a class: `name` is a factory function whose `prototype` is the
+/// class prototype. The JS proxy wraps it in a real constructor so `new` and
+/// `instanceof` work.
+void defineClass(jsi::Runtime& rt, Host& host, jsi::Object& exports, const char* name, const char* key, Host::PrototypeInit init,
+                 unsigned argc, HostFn construct);
+
+}  // namespace lucent::js