@lucent-lang/lucent 0.0.4

package/runtime/cpp/lucent/generator.h

@@ -0,0 +1,244 @@
+// Lucent runtime — iterators and generators.
+//
+// Every iterable value is an Iter<T>: a shared iterator with next() and
+// ret() (JavaScript's iterator.return()). Generator functions are C++20
+// coroutines whose declared return type is Iter<T> (see the coroutine_traits
+// specialization below); they start lazily, like JavaScript generators.
+//
+// ret() resumes a suspended generator with a flag that makes its pending
+// co_yield throw GeneratorReturn. That unwinds through the generated
+// `finally` blocks (JS `catch` blocks let it pass), and the coroutine then
+// completes normally.
+#pragma once
+
+#include <coroutine>
+#include <exception>
+#include <optional>
+#include <tuple>
+#include <utility>
+
+#include "array.h"
+#include "bytes.h"
+#include "core.h"
+#include "jsstring.h"
+#include "map.h"
+
+namespace lucent {
+
+/// Thrown into a generator by iterator.return(); never seen by JS catch blocks.
+struct GeneratorReturn {};
+
+template <class T>
+class IterObject : public Object {
+ public:
+  /// The next value, or nullopt once the iterator is exhausted.
+  virtual std::optional<T> next() = 0;
+  /// iterator.return(): stops early, running a generator's finally blocks.
+  virtual void ret() {}
+};
+template <class T>
+using Iter = Ref<IterObject<T>>;
+
+/// `{ value, done }` from `iterator.next()`.
+template <class T>
+struct IterResult {
+  bool done = true;
+  Opt<T> value;
+};
+
+template <class T>
+IterResult<T> iterNext(const Iter<T>& it) {
+  auto v = it->next();
+  if (!v) return {};
+  return IterResult<T>{false, Opt<T>(std::move(*v))};
+}
+
+/// Calls ret() when a for-of or yield* exits before its iterator is exhausted.
+template <class T>
+class IterCloser {
+ public:
+  explicit IterCloser(Iter<T> it) : it_(std::move(it)), exceptions_(std::uncaught_exceptions()) {}
+  /// The iterator reported done: nothing to close.
+  void exhausted() { it_ = nullptr; }
+  ~IterCloser() noexcept(false) {
+    if (!it_) return;
+    if (std::uncaught_exceptions() > exceptions_) {
+      // Leaving because of an exception: it wins over one from return().
+      try {
+        it_->ret();
+      } catch (...) {
+      }
+    } else {
+      it_->ret();
+    }
+  }
+  IterCloser(const IterCloser&) = delete;
+  IterCloser& operator=(const IterCloser&) = delete;
+
+ private:
+  Iter<T> it_;
+  int exceptions_;
+};
+
+namespace detail {
+
+template <class T>
+class GeneratorIter;
+
+template <class T>
+struct GeneratorPromise {
+  std::optional<T> current;
+  std::exception_ptr error;
+  bool returning = false;
+
+  Iter<T> get_return_object();
+  std::suspend_always initial_suspend() noexcept { return {}; }
+  std::suspend_always final_suspend() noexcept { return {}; }
+  void return_void() {}
+  void unhandled_exception() {
+    try {
+      throw;
+    } catch (const GeneratorReturn&) {
+      // return() finished running the finally blocks.
+    } catch (...) {
+      error = std::current_exception();
+    }
+  }
+
+  struct Yield {
+    GeneratorPromise& p;
+    bool await_ready() const noexcept { return false; }
+    void await_suspend(std::coroutine_handle<>) const noexcept {}
+    void await_resume() const {
+      if (p.returning) throw GeneratorReturn{};
+    }
+  };
+  Yield yield_value(T v) {
+    current = std::move(v);
+    return Yield{*this};
+  }
+};
+
+template <class T>
+class GeneratorIter final : public IterObject<T> {
+ public:
+  using Handle = std::coroutine_handle<GeneratorPromise<T>>;
+  explicit GeneratorIter(Handle h) : h_(h) {}
+  ~GeneratorIter() override {
+    if (h_) h_.destroy();
+  }
+
+  std::optional<T> next() override {
+    if (done_) return std::nullopt;
+    started_ = true;
+    h_.resume();
+    return settle();
+  }
+
+  void ret() override {
+    if (done_) return;
+    if (!started_) {
+      done_ = true;
+      return;
+    }
+    h_.promise().returning = true;
+    h_.resume();
+    settle();
+    done_ = true;
+  }
+
+ private:
+  std::optional<T> settle() {
+    auto& p = h_.promise();
+    if (h_.done()) {
+      done_ = true;
+      if (p.error) std::rethrow_exception(std::exchange(p.error, nullptr));
+      return std::nullopt;
+    }
+    return std::exchange(p.current, std::nullopt);
+  }
+
+  Handle h_;
+  bool started_ = false;
+  bool done_ = false;
+};
+
+template <class T>
+Iter<T> GeneratorPromise<T>::get_return_object() {
+  return std::make_shared<GeneratorIter<T>>(GeneratorIter<T>::Handle::from_promise(*this));
+}
+
+// --- iterators over collections (live, like JavaScript's) --------------------------------------
+
+template <class T>
+class ArrayIter final : public IterObject<T> {
+ public:
+  explicit ArrayIter(Array<T> a) : a_(std::move(a)) {}
+  std::optional<T> next() override {
+    if (i_ >= a_.size()) return std::nullopt;
+    return a_.at(i_++);
+  }
+
+ private:
+  Array<T> a_;
+  size_t i_ = 0;
+};
+
+template <class T, class Table, class Get>
+class TableIter final : public IterObject<T> {
+ public:
+  TableIter(Table t, Get get) : t_(std::move(t)), get_(get) {}
+  std::optional<T> next() override {
+    auto& table = t_.table();
+    while (i_ < table.slotCount()) {
+      size_t i = i_++;
+      if (table.slotLive(i)) return get_(table.slot(i));
+    }
+    return std::nullopt;
+  }
+
+ private:
+  Table t_;
+  Get get_;
+  size_t i_ = 0;
+};
+
+}  // namespace detail
+
+template <class T>
+Iter<T> iterOf(const Iter<T>& it) {
+  return it;
+}
+template <class T>
+Iter<T> iterOf(const Array<T>& a) {
+  return std::make_shared<detail::ArrayIter<T>>(a);
+}
+template <class T>
+Iter<T> iterOf(const Set<T>& s) {
+  auto get = [](const auto& slot) { return slot.key; };
+  return std::make_shared<detail::TableIter<T, Set<T>, decltype(get)>>(s, get);
+}
+template <class K, class V>
+Iter<std::tuple<K, V>> iterOf(const Map<K, V>& m) {
+  auto get = [](const auto& slot) { return std::tuple<K, V>(slot.key, slot.value); };
+  return std::make_shared<detail::TableIter<std::tuple<K, V>, Map<K, V>, decltype(get)>>(m, get);
+}
+/// Strings iterate by code point.
+Iter<String> iterOf(const String& s);
+Iter<double> iterOf(const Bytes& b);
+
+/// `[...it]` / `Array.from(it)`.
+template <class T>
+Array<T> iterToArray(const Iter<T>& it) {
+  Array<T> out;
+  while (auto v = it->next()) out.push(std::move(*v));
+  return out;
+}
+
+}  // namespace lucent
+
+/// Coroutines declared to return Iter<T> are generators.
+template <class T, class... Args>
+struct std::coroutine_traits<lucent::Iter<T>, Args...> {
+  using promise_type = lucent::detail::GeneratorPromise<T>;
+};

package/runtime/cpp/lucent/helpers.h

@@ -0,0 +1,226 @@
+// Lucent runtime — small helpers the compiler emits calls to.
+#pragma once
+
+#include <chrono>
+#include <cmath>
+#include <initializer_list>
+#include <tuple>
+#include <variant>
+
+#include "array.h"
+#include "async.h"
+#include "bytes.h"
+#include "core.h"
+#include "jserror.h"
+#include "map.h"
+#include "number.h"
+#include "ops.h"
+#include "jsstring.h"
+
+namespace lucent {
+
+/// `this` as a strong reference, inside a member function.
+template <class T>
+Ref<T> selfRef(T* p) {
+  return std::static_pointer_cast<T>(static_cast<Object*>(p)->shared_from_this());
+}
+template <class T>
+Ref<T> selfRef(const T* p) {
+  return selfRef(const_cast<T*>(p));
+}
+
+// --- element access for compound assignment ------------------------------------------
+
+template <class T>
+T elementAt(const Array<T>& a, double i) {
+  Opt<T> v = a.get(i);
+  if (!v.has()) throwRangeError("Array index out of bounds");
+  return v.get();
+}
+template <class T, class V>
+T setElement(Array<T>& a, double i, V&& v) {
+  T value(std::forward<V>(v));
+  a.set(i, value);
+  return value;
+}
+template <class T, class V>
+T setElement(const Array<T>& a, double i, V&& v) {
+  Array<T> copy = a;
+  return setElement(copy, i, std::forward<V>(v));
+}
+inline double elementAt(const Bytes& b, double i) {
+  Opt<double> v = b.get(i);
+  if (!v.has()) throwRangeError("Uint8Array index out of bounds");
+  return v.get();
+}
+inline double setElement(const Bytes& b, double i, double v) {
+  Bytes copy = b;
+  copy.set(i, v);
+  return v;
+}
+template <class V>
+V entryAt(const Dict<V>& d, const String& k) {
+  Opt<V> v = d.get(k);
+  if (!v.has()) throwTypeError("Record has no such key");
+  return v.get();
+}
+template <class V, class X>
+V setEntry(const Dict<V>& d, const String& k, X&& v) {
+  Dict<V> copy = d;
+  V value(std::forward<X>(v));
+  copy.set(k, value);
+  return value;
+}
+template <class V>
+void assignEntries(Dict<V>& target, const Dict<V>& source) {
+  Array<String> ks = source.keys();
+  for (const auto& k : ks.items()) target.set(k, source.get(k).get());
+}
+
+/// `s[i]`: undefined when out of range (unlike `s.at(i)`, no negative indexes).
+inline Opt<String> stringIndex(const String& s, double i) {
+  if (i >= 0 && i < static_cast<double>(s.length()) && std::trunc(i) == i) return String::fromCodeUnit(s.unit(static_cast<size_t>(i)));
+  return undefined;
+}
+
+// --- instanceof ---------------------------------------------------------------------------
+
+template <class C, class V>
+bool isInstance(const V& v) {
+  if constexpr (IsRef<V>::value) {
+    return std::dynamic_pointer_cast<C>(v) != nullptr;
+  } else if constexpr (IsOpt<V>::value) {
+    return v.has() && isInstance<C>(v.get());
+  } else if constexpr (IsVariant<V>::value) {
+    return std::visit([](const auto& x) { return isInstance<C>(x); }, v);
+  } else {
+    return false;
+  }
+}
+
+/// `e instanceof Error` / `TypeError` / `RangeError` (kind null = any error).
+template <class V>
+bool isErrorOf(const V& v, const char* kind) {
+  if constexpr (std::is_same_v<V, Error>) {
+    return v && (kind == nullptr || v->name == String::fromLatin1(kind));
+  } else if constexpr (IsRef<V>::value) {
+    auto e = std::dynamic_pointer_cast<ErrorObject>(v);
+    return e && (kind == nullptr || e->name == String::fromLatin1(kind));
+  } else if constexpr (IsOpt<V>::value) {
+    return v.has() && isErrorOf(v.get(), kind);
+  } else if constexpr (IsVariant<V>::value) {
+    return std::visit([kind](const auto& x) { return isErrorOf(x, kind); }, v);
+  } else {
+    return false;
+  }
+}
+
+/// Checked downcast after `instanceof` narrowing.
+template <class C, class V>
+Ref<C> downcast(const Ref<V>& v) {
+  auto r = std::dynamic_pointer_cast<C>(v);
+  if (!r) throwTypeError("Value is not an instance of the expected class");
+  return r;
+}
+
+inline Error errorWithCode(const String& code, const String& message) {
+  Error e = makeError(message);
+  e->code = code;
+  return e;
+}
+
+// --- time ------------------------------------------------------------------------------------
+
+inline double dateNow() {
+  return static_cast<double>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch()).count());
+}
+inline double monotonicNow() {
+  return static_cast<double>(std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::steady_clock::now().time_since_epoch()).count()) / 1000.0;
+}
+
+// --- strings ----------------------------------------------------------------------------------
+
+inline String stringFromCharCodes(std::initializer_list<double> codes) {
+  if (codes.size() == 1) return String::fromCodeUnit(static_cast<char16_t>(toUint32(*codes.begin()) & 0xFFFF));
+  std::u16string out;
+  for (double c : codes) out.push_back(static_cast<char16_t>(toUint32(c) & 0xFFFF));
+  return String::fromUtf16(out);
+}
+inline String stringFromCodePoints(std::initializer_list<double> cps) {
+  String out;
+  for (double c : cps) out += String::fromCodePoint(c);
+  return out;
+}
+
+// --- Math.min(...xs) ------------------------------------------------------------------------
+
+namespace math {
+inline double minOf(const Array<double>& xs) {
+  double r = kInfinity;
+  for (double v : xs.items()) r = min(r, v);
+  return r;
+}
+inline double maxOf(const Array<double>& xs) {
+  double r = -kInfinity;
+  for (double v : xs.items()) r = max(r, v);
+  return r;
+}
+}  // namespace math
+
+// --- entries --------------------------------------------------------------------------------
+
+template <class V>
+Array<std::tuple<String, V>> dictEntries(const Dict<V>& d) {
+  Array<std::tuple<String, V>> out;
+  Array<String> ks = d.keys();
+  for (const auto& k : ks.items()) out.push(std::tuple<String, V>(k, d.get(k).get()));
+  return out;
+}
+template <class V>
+Dict<V> dictFromEntries(const Array<std::tuple<String, V>>& entries) {
+  Dict<V> out;
+  for (const auto& e : entries.items()) out.set(std::get<0>(e), std::get<1>(e));
+  return out;
+}
+template <class K, class V>
+Array<std::tuple<K, V>> mapEntries(const Map<K, V>& m) {
+  Array<std::tuple<K, V>> out;
+  auto& t = m.table();
+  for (size_t i = 0; i < t.slotCount(); i++) {
+    if (t.slotLive(i)) out.push(std::tuple<K, V>(t.slot(i).key, t.slot(i).value));
+  }
+  return out;
+}
+template <class K, class V>
+Map<K, V> mapFromEntries(const Array<std::tuple<K, V>>& entries) {
+  Map<K, V> out;
+  for (const auto& e : entries.items()) out.set(std::get<0>(e), std::get<1>(e));
+  return out;
+}
+template <class T>
+Array<std::tuple<double, T>> arrayEntries(const Array<T>& a) {
+  Array<std::tuple<double, T>> out;
+  for (size_t i = 0; i < a.size(); i++) out.push(std::tuple<double, T>(static_cast<double>(i), a.at(i)));
+  return out;
+}
+
+// --- tuples ---------------------------------------------------------------------------------------
+
+template <class... Ts>
+String toJsString(const std::tuple<Ts...>& t) {
+  String out;
+  size_t i = 0;
+  std::apply(
+      [&](const auto&... x) {
+        ((out += (i++ ? String::fromLatin1(",") : String()), out += toJsString(x)), ...);
+      },
+      t);
+  return out;
+}
+template <class... Ts>
+bool strictEquals(const std::tuple<Ts...>& a, const std::tuple<Ts...>& b) {
+  // Tuples are values in Lucent; compare element-wise.
+  return std::apply([&](const auto&... x) { return std::apply([&](const auto&... y) { return (strictEquals(x, y) && ...); }, b); }, a);
+}
+
+}  // namespace lucent

package/runtime/cpp/lucent/jserror.cpp

@@ -0,0 +1,51 @@
+#include "jserror.h"
+
+#include <new>
+#include <stdexcept>
+
+namespace lucent {
+
+Error makeError(const String& name, const String& message) {
+  auto e = std::make_shared<ErrorObject>();
+  e->name = name;
+  e->message = message;
+  return e;
+}
+
+Exception::Exception(Error error) : error_(std::move(error)) {
+  what_ = error_->name.toUtf8() + ": " + error_->message.toUtf8();
+}
+
+void throwError(const Error& error) { throw Exception(error); }
+
+void throwError(const String& name, const String& message) { throw Exception(makeError(name, message)); }
+
+void throwTypeError(const char* message) {
+  throwError(String::fromLatin1("TypeError"), String::fromUtf8(message));
+}
+
+void throwRangeError(const char* message) {
+  throwError(String::fromLatin1("RangeError"), String::fromUtf8(message));
+}
+
+Error currentError(std::exception_ptr ex) {
+  try {
+    std::rethrow_exception(ex);
+  } catch (const Exception& e) {
+    return e.error();
+  } catch (const std::bad_alloc&) {
+    return makeError(String::fromLatin1("RangeError"), String::fromLatin1("Out of memory"));
+  } catch (const std::exception& e) {
+    return makeError(String::fromLatin1("Error"), String::fromUtf8(e.what()));
+  } catch (...) {
+    return makeError(String::fromLatin1("Error"), String::fromLatin1("Unknown native exception"));
+  }
+}
+
+String errorToString(const Error& e) {
+  if (e->message.empty()) return e->name;
+  if (e->name.empty()) return e->message;
+  return e->name + String::fromLatin1(": ") + e->message;
+}
+
+}  // namespace lucent

package/runtime/cpp/lucent/jserror.h

@@ -0,0 +1,66 @@
+// Lucent runtime — Error objects and exceptions.
+//
+// `throw new Error("x")` in Lucent throws a C++ `lucent::Exception` holding
+// an ErrorObject. At the JavaScript boundary it becomes a real JS Error with
+// the same name, message and `code`.
+#pragma once
+
+#include <exception>
+#include <string>
+
+#include "core.h"
+#include "jsstring.h"
+
+namespace lucent {
+
+struct ErrorObject : Object {
+  String name;
+  String message;
+  Opt<String> code;
+  /// For errors that came from JavaScript: the original stack.
+  Opt<String> stack;
+  /// Where Lucent code created the error: `fn (file.lucent.ts:line)`.
+  Opt<String> site;
+  /// Class name when a Lucent class extends Error, for `instanceof`.
+  const char* kind = "Error";
+};
+using Error = Ref<ErrorObject>;
+
+Error makeError(const String& name, const String& message);
+inline Error makeError(const String& message) { return makeError(String::fromLatin1("Error"), message); }
+
+/// Records where Lucent code created `e` (generated code passes __FILE__ and
+/// __LINE__, which #line directives point at the .lucent.ts source).
+template <class E>
+E withSite(E e, const char* file, int line, const char* function) {
+  if (e && !e->site.has()) e->site = String::fromUtf8(std::string(function) + " (" + file + ":" + std::to_string(line) + ")");
+  return e;
+}
+
+class Exception : public std::exception {
+ public:
+  explicit Exception(Error error);
+  const Error& error() const { return error_; }
+  const char* what() const noexcept override { return what_.c_str(); }
+
+ private:
+  Error error_;
+  std::string what_;
+};
+
+[[noreturn]] void throwError(const Error& error);
+[[noreturn]] void throwError(const String& name, const String& message);
+/// A platform branch (`if (PLATFORM === "ios")`) reached on a target that is
+/// neither platform, the host; typed as the value it stands for.
+template <class T = void>
+[[noreturn]] T platformOnly(const String& message) {
+  throwError(String::fromLatin1("Error"), message);
+}
+
+/// Converts whatever is being caught into a Lucent Error, including C++
+/// exceptions from the standard library.
+Error currentError(std::exception_ptr ex);
+
+String errorToString(const Error& e);
+
+}  // namespace lucent