@lucent-lang/lucent 0.0.4 → 0.1.1

package/runtime/cpp/lucent/native.h

@@ -16,27 +16,54 @@
 
 namespace lucent {
 
-/// How many platform objects Lucent holds (NativeRefs, not copies): debug
-/// builds report what is left when the module goes.
+/// How many platform objects Lucent holds (NativeRefs, not copies), until
+/// each is released.
 long liveNativeRefs();
 
+/// The part of liveNativeRefs() module code made: not the main context's
+/// (views' setups and the callbacks they give the platform, which the
+/// renderer and the platform's garbage collector release on their own
+/// schedule), nor the ones kept for the process. Debug builds report what
+/// is left when a JavaScript runtime's module goes.
+long moduleNativeRefs();
+
 namespace detail {
-void countNativeRef(int delta);
-}
+/// Counts a platform object Lucent now holds; whether module code made it.
+bool countNativeRef();
+
+/// Counts one released (or kept for the process: `held` then stays true).
+void uncountNativeRef(bool module, bool held = false);
+
+/// Releases `handle` on `on`'s thread: at once there, or with no context;
+/// else posted to it (or here, if it takes no more work).
+void releaseNative(void* handle, void (*release)(void*), ExecutionContext* on, bool module);
+}  // namespace detail
 
 class NativeRef {
  public:
   NativeRef() = default;
-  /// Takes ownership of `handle`; `release` runs when the last copy goes.
-  NativeRef(void* handle, void (*release)(void*), bool (*same)(void*, void*))
-      : p_(handle, Release{release}), same_(same) {
-    if (handle) detail::countNativeRef(1);
-  }
+
+  /// Takes ownership of `handle`; `release` runs when the last copy goes,
+  /// on the thread `releaseOn` runs on if the object requires one (UIKit
+  /// objects, the main context's), whichever thread dropped that copy.
+  NativeRef(void* handle, void (*release)(void*), bool (*same)(void*, void*), ExecutionContext* releaseOn = nullptr)
+      : p_(handle, Release{release, releaseOn, handle && detail::countNativeRef()}), same_(same) {}
 
   void* get() const { return p_.get(); }
   explicit operator bool() const { return p_ != nullptr; }
   const void* identity() const { return p_.get(); }
 
+  /// The object lives as long as the process (the Android Application):
+  /// the teardown report leaves it out. Any copy; once.
+  void keepForProcess() {
+    auto* r = std::get_deleter<Release>(p_);
+
+    if (r && r->module) {
+      r->module = false;
+      detail::uncountNativeRef(true, true);
+    }
+  }
+
   /// The same platform object: pointer identity on iOS, IsSameObject on Android.
   bool same(const NativeRef& o) const {
     if (p_ == o.p_) return true;
@@ -47,10 +74,12 @@ class NativeRef {
  private:
   struct Release {
     void (*release)(void*);
+    ExecutionContext* on;
+    /// Counted as module code's (moduleNativeRefs).
+    bool module;
+
     void operator()(void* p) const {
-      if (!p) return;
-      detail::countNativeRef(-1);
-      release(p);
+      if (p) detail::releaseNative(p, release, on, module);
     }
   };
   std::shared_ptr<void> p_;
@@ -61,23 +90,24 @@ class NativeRef {
 inline bool strictEquals(const NativeRef& a, const NativeRef& b) { return a.same(b); }
 inline String toJsString(const NativeRef&) { return String::fromLatin1("[object NativeObject]"); }
 
-/// Runs `job` on the platform's main thread (main queue, main Looper; a
-/// dedicated thread standing in for it on other hosts).
-void postToMain(std::function<void()> job);
-bool onMainThread();
+// --- the legacy module context ----------------------------------------------
+//
+// What generated module code calls: each enters module code by taking the
+// Lucent lock.
 
-/// A platform callback into Lucent code that returns nothing and outlives
-/// the call: queued on the Lucent thread, so the platform never waits for
-/// Lucent code. `f` owns what it captured and is released after it runs.
+/// A platform callback into module code that returns nothing and outlives
+/// the call: a turn of the legacy module context on the Lucent thread, so
+/// the platform never waits for Lucent code. `f` owns what it captured and
+/// is released after it runs.
 template <class F>
 void postCallback(F f) {
   Scheduler::instance().post(std::move(f));
 }
 
-/// A platform callback the platform waits for (for its result, or because
-/// it runs during the call or on the main thread): runs on the calling
-/// thread, holding the Lucent lock. A Lucent error is reported and the
-/// platform gets a default result.
+/// A platform callback into module code the platform waits for (for its
+/// result, or because it runs during the call or on the main thread): runs
+/// on the calling thread, holding the Lucent lock. A Lucent error is
+/// reported and the platform gets a default result.
 template <class F>
 auto callNow(F f) -> std::invoke_result_t<F&> {
   using R = std::invoke_result_t<F&>;
@@ -90,9 +120,11 @@ auto callNow(F f) -> std::invoke_result_t<F&> {
   }
 }
 
-/// `main(f)` from lucent:thread: runs `f` on the main thread holding the
-/// Lucent lock, and settles the promise with its result. The caller never
-/// waits for the main thread, so the lock order stays deadlock-free.
+/// `main(f)` from lucent:thread, kept for module code: runs `f` on the main
+/// thread holding the Lucent lock, and settles the promise with its result.
+/// The caller never waits for the main thread, so the lock order stays
+/// deadlock-free, but the main thread waits for any module job. UI work
+/// uses the main context (runIn) instead.
 template <class F>
 auto runOnMain(F f) -> Promise<std::invoke_result_t<F>> {
   using R = std::invoke_result_t<F>;
@@ -113,4 +145,62 @@ auto runOnMain(F f) -> Promise<std::invoke_result_t<F>> {
   return p;
 }
 
+// --- any other context -------------------------------------------------------
+//
+// The same entries for another context, such as the main context: none
+// takes the Lucent lock.
+
+/// A platform callback into `context` that returns nothing and outlives the
+/// call: a turn of that context. `f` owns what it captured and is released
+/// on the context after it runs (or at once if the context has shut down).
+template <class F>
+void postTo(ExecutionContext& context, F f) {
+  context.post(std::move(f));
+}
+
+/// A platform callback into `context` the platform waits for, made on the
+/// context's own thread (the main thread, for the main context): runs now,
+/// in the context, and the microtasks it queued run before it returns. A
+/// Lucent error, or a call from any other thread, is reported and the
+/// platform gets a default result.
+template <class F>
+auto callNowIn(ExecutionContext& context, F f) -> std::invoke_result_t<F&> {
+  using R = std::invoke_result_t<F&>;
+  try {
+    ContextEntry entry(context);
+    return f();
+  } catch (...) {
+    reportUncaught(std::current_exception(), "callback");
+    if constexpr (!std::is_void_v<R>) return R{};
+  }
+}
+
+/// Runs `f` as a turn of `context` and settles the promise, which belongs to
+/// the calling context, with its result there; a context that has shut down
+/// rejects it. Neither side waits for the other. What `f` captures and
+/// returns crosses threads, so it must not share mutable state with the
+/// caller.
+template <class F>
+auto runIn(ExecutionContext& context, F f) -> Promise<std::invoke_result_t<F>> {
+  using R = std::invoke_result_t<F>;
+  Promise<R> p;
+
+  bool posted = context.post([p, f = std::move(f)]() mutable {
+    try {
+      if constexpr (std::is_void_v<R>) {
+        f();
+        p.resolve(undefined);
+      } else {
+        p.resolve(f());
+      }
+    } catch (...) {
+      p.reject(currentError(std::current_exception()));
+    }
+  });
+
+  if (!posted) p.reject(makeError(String::fromLatin1("AbortError"), String::fromLatin1("The execution context has shut down")));
+
+  return p;
+}
+
 }  // namespace lucent

package/runtime/cpp/lucent/number.cpp

@@ -8,6 +8,12 @@
 #include <random>
 #include <string>
 
+// Dragonbox tests internal macros that may be undefined.
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wundef"
+#include "../third_party/dragonbox/dragonbox.h"
+#pragma GCC diagnostic pop
+
 namespace lucent {
 
 namespace {
@@ -58,31 +64,19 @@ Decimal roundHalfUp(double a, int significant) {
   return d;
 }
 
-Decimal withPrecision(double v, int precision) {
-  char buf[64];
-  std::snprintf(buf, sizeof buf, "%.*e", precision - 1, v);
-  return parseScientific(buf);
-}
-
-bool roundTrips(double v, int precision) {
-  char buf[64];
-  std::snprintf(buf, sizeof buf, "%.*e", precision - 1, v);
-  // strtod needs '.', which is what the C locale prints.
-  for (char* c = buf; *c; c++) {
-    if (*c == ',') *c = '.';
-  }
-  return std::strtod(buf, nullptr) == v;
-}
-
-// Shortest digit string that round-trips (ECMA-262 Number::toString step 5).
+/// The fewest digits that read back as `v` (finite, positive), the closest
+/// to it of those (ECMA-262 Number::toString step 5). The correctly rounded
+/// digits at that length are not always among them: below a power of two
+/// the doubles are twice as dense, so only a farther string reads back.
 Decimal shortest(double v) {
-  int lo = 1, hi = 17;
-  while (lo < hi) {
-    int mid = (lo + hi) / 2;
-    if (roundTrips(v, mid)) hi = mid;
-    else lo = mid + 1;
-  }
-  return withPrecision(v, lo);
+  auto decimal = jkj::dragonbox::to_decimal(v);
+  char digits[24];
+  auto end = std::to_chars(digits, digits + sizeof digits, decimal.significand).ptr;
+
+  Decimal d;
+  d.digits.assign(digits, end);
+  d.n = decimal.exponent + static_cast<int>(d.digits.size());
+  return d;
 }
 
 std::string formatDecimal(const Decimal& d) {
@@ -226,18 +220,19 @@ String numberToString(double v, double radixValue) {
       }
     } while (fraction >= delta);
   }
+  // Integer digits, least significant first. Those a double cannot tell
+  // apart (from 2^53 up) are zeros, as V8 prints them.
   std::string intDigits;
-  if (integer == 0) {
-    intDigits = "0";
-  } else {
-    while (integer >= 1) {
-      double q = std::floor(integer / radix);
-      int digit = static_cast<int>(integer - q * radix);
-      intDigits.push_back(chars[digit]);
-      integer = q;
-    }
-    std::reverse(intDigits.begin(), intDigits.end());
+  while (integer / radix >= 9007199254740992.0) {
+    integer /= radix;
+    intDigits.push_back('0');
   }
+  do {
+    double remainder = std::fmod(integer, radix);
+    intDigits.push_back(chars[static_cast<int>(remainder)]);
+    integer = (integer - remainder) / radix;
+  } while (integer > 0);
+  std::reverse(intDigits.begin(), intDigits.end());
   std::string out = negative ? "-" : "";
   out += intDigits;
   if (!fracDigits.empty()) out += "." + fracDigits;
@@ -249,10 +244,10 @@ String numberToFixed(double v, double digitsValue) {
   if (f < 0 || f > 100) throwRangeError("toFixed() digits argument must be between 0 and 100");
   if (std::isnan(v)) return String::fromLatin1("NaN");
   if (std::fabs(v) >= 1e21 || std::isinf(v)) return numberToString(v);
-  std::string digits = fixedDigits(v, static_cast<int>(f));
-  bool allZero = digits.find_first_not_of("0.") == std::string::npos;
-  std::string out = (v < 0 && !allZero) ? "-" : "";
-  return String::fromLatin1(out + digits);
+  // A negative value keeps its sign even when it rounds to zero (-0.00);
+  // only -0 has none.
+  std::string out = v < 0 ? "-" : "";
+  return String::fromLatin1(out + fixedDigits(v, static_cast<int>(f)));
 }
 
 String numberToExponential(double v, double digitsValue) {
@@ -542,4 +537,9 @@ double max(double a, double b) {
 
 }  // namespace math
 
+void throwInexactInteger(const std::string& value) {
+  std::string message = value + " is not an integer a number holds exactly (within +-(2^53 - 1))";
+  throwRangeError(message.c_str());
+}
+
 }  // namespace lucent

package/runtime/cpp/lucent/number.h

@@ -5,6 +5,7 @@
 #include <cmath>
 #include <cstdint>
 #include <limits>
+#include <string>
 #include <type_traits>
 
 #include "jsstring.h"
@@ -70,6 +71,38 @@ inline String toJsString(Null) { return String::fromLatin1("null"); }
 inline bool isInteger(double v) { return std::isfinite(v) && std::trunc(v) == v; }
 inline bool isSafeInteger(double v) { return isInteger(v) && std::fabs(v) <= 9007199254740991.0; }
 
+[[noreturn]] void throwInexactInteger(const std::string& value);
+
+/// A native integer (a 64-bit one: Int64, NSInteger, Java's long) as a
+/// number, exactly: RangeError beyond +-(2^53 - 1), which a number cannot
+/// tell apart from its neighbors. Never rounded.
+template <class I>
+  requires std::is_integral_v<I>
+double exactNumber(I v) {
+  constexpr uint64_t kMax = 9007199254740991;  // 2^53 - 1
+  bool fits;
+  if constexpr (std::is_signed_v<I>)
+    fits = v >= -static_cast<int64_t>(kMax) && v <= static_cast<int64_t>(kMax);
+  else
+    fits = static_cast<uint64_t>(v) <= kMax;
+
+  if (!fits) throwInexactInteger(std::to_string(v));
+  return static_cast<double>(v);
+}
+
+/// A number as a native 64-bit integer, as WebIDL's [EnforceRange] long
+/// long converts it: truncated toward zero; RangeError when it is not
+/// finite or beyond what a number holds exactly (below 0 for unsigned).
+template <class I>
+  requires std::is_integral_v<I>
+I toExactInteger(double v) {
+  double t = std::trunc(v);
+  double low = std::is_signed_v<I> ? -9007199254740991.0 : 0.0;
+  if (!(t >= low && t <= 9007199254740991.0)) throwInexactInteger(numberToString(v).toUtf8());
+
+  return static_cast<I>(t);
+}
+
 namespace math {
 inline double abs(double v) { return std::fabs(v); }
 inline double floor(double v) { return std::floor(v); }

package/runtime/cpp/lucent/operation.h

@@ -0,0 +1,65 @@
+// Lucent runtime — native operations as promises.
+//
+// Native work that completes later, on any thread (a Kotlin coroutine, a
+// platform callback), becomes a promise of the context that started it: an
+// Operation (scope.h) under that context's root scope, whose outcome settles
+// the promise there. Disposing the scope, or the AbortSignal the caller gave
+// aborting, cancels it: the promise rejects at once, the registration's
+// cleanup tells the native work to stop, and whatever it produces after that
+// is released, never delivered.
+#pragma once
+
+#include <functional>
+#include <memory>
+#include <utility>
+
+#include "abort.h"
+#include "async.h"
+#include "execution.h"
+#include "scope.h"
+
+namespace lucent {
+
+/// Starts native work for the calling context: `registration` begins it and
+/// returns what ends it (see Operation::start). Already aborted, the work
+/// never starts.
+template <class T>
+Promise<T> nativeOperation(typename Operation<T>::Registration registration, Opt<AbortSignal> signal = {}) {
+  ContextRef owner = ExecutionContext::currentRef();
+  std::shared_ptr<Scope> scope = ExecutionContext::of(owner).root();
+  AbortSignal abort = signal.has() ? signal.get() : nullptr;
+
+  Opt<Error> abortedBy;
+  if (abort && abort->aborted.load()) abortedBy = abort->reason;
+
+  Promise<T> promise;
+  auto operation = Operation<T>::start(scope, registration, abortedBy);
+
+  // The signal holds a listener only while the operation is pending.
+  if (abort && operation->state() == OperationState::Pending) {
+    std::weak_ptr<Operation<T>> pending = operation;
+    std::weak_ptr<AbortSignalObject> weak = abort;
+
+    uint64_t id = abort->add([pending, weak] {
+      auto op = pending.lock();
+      auto s = weak.lock();
+      if (op && s) op->cancel(s->reason);
+    });
+
+    operation->onSettled([weak, id](const typename Operation<T>::Outcome&) {
+      if (auto s = weak.lock(); s && id) s->remove(id);
+    });
+  }
+
+  operation->onSettled([promise](const typename Operation<T>::Outcome& outcome) {
+    if (outcome.state == OperationState::Succeeded) {
+      promise.resolve(*outcome.value);
+    } else {
+      promise.reject(outcome.error);
+    }
+  });
+
+  return promise;
+}
+
+}  // namespace lucent

package/runtime/cpp/lucent/ops.h

@@ -7,6 +7,7 @@
 
 #include "array.h"
 #include "async.h"
+#include "bigint.h"
 #include "bytes.h"
 #include "core.h"
 #include "jserror.h"
@@ -21,6 +22,7 @@ namespace lucent {
 inline bool truthy(bool v) { return v; }
 inline bool truthy(double v) { return v != 0 && !std::isnan(v); }
 inline bool truthy(const String& s) { return !s.empty(); }
+inline bool truthy(const BigInt& v) { return !v.isZero(); }
 inline bool truthy(Undefined) { return false; }
 inline bool truthy(Null) { return false; }
 template <class T>
@@ -59,6 +61,7 @@ String toJsString(const std::variant<Ts...>& v) {
 inline String typeOf(double) { return String::fromLatin1("number"); }
 inline String typeOf(bool) { return String::fromLatin1("boolean"); }
 inline String typeOf(const String&) { return String::fromLatin1("string"); }
+inline String typeOf(const BigInt&) { return String::fromLatin1("bigint"); }
 inline String typeOf(Undefined) { return String::fromLatin1("undefined"); }
 inline String typeOf(Null) { return String::fromLatin1("object"); }
 template <class Sig>
@@ -81,11 +84,6 @@ String typeOf(const T&) {
 }
 
 // --- unions -------------------------------------------------------------------
-template <class T>
-struct IsVariant : std::false_type {};
-template <class... Ts>
-struct IsVariant<std::variant<Ts...>> : std::true_type {};
-
 template <class T, class V>
 constexpr bool variantHolds() {
   if constexpr (IsVariant<V>::value) {
@@ -109,14 +107,24 @@ To convertImpl(const From& from) {
     return from;
   } else if constexpr (IsOpt<To>::value) {
     using Inner = typename To::ValueType;
+    // `null | undefined` (Opt<Undefined>) holds no value: narrowing proved
+    // any present one away, and throws here. Not in a helper returning To
+    // that only throws: clang 18 (Android NDK r27's) then returns garbage
+    // for the absent values beside it.
     if constexpr (IsOpt<F>::value) {
       if (from.isUndefined()) return To(undefined);
       if (from.isNull()) return To(null);
-      return To(convert<Inner>(from.get()));
+      if constexpr (IsAbsent<Inner>) {
+        throwTypeError("Value does not match the expected type");
+      } else {
+        return To(convert<Inner>(from.get()));
+      }
     } else if constexpr (std::is_same_v<F, Undefined>) {
       return To(undefined);
     } else if constexpr (std::is_same_v<F, Null>) {
       return To(null);
+    } else if constexpr (IsAbsent<Inner>) {
+      throwTypeError("Value does not match the expected type");
     } else {
       return To(convert<Inner>(from));
     }