@lucent-lang/lucent 0.0.4

package/runtime/cpp/lucent/number.h

@@ -0,0 +1,190 @@
+// Lucent runtime — ECMAScript number semantics.
+#pragma once
+
+#include <charconv>
+#include <cmath>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+
+#include "jsstring.h"
+
+namespace lucent {
+
+inline constexpr double kNaN = std::numeric_limits<double>::quiet_NaN();
+inline constexpr double kInfinity = std::numeric_limits<double>::infinity();
+
+/// ECMAScript ToInt32.
+inline int32_t toInt32(double v) {
+  if (v >= -2147483648.0 && v <= 2147483647.0) return static_cast<int32_t>(v);  // fast path, truncates
+  if (v >= 0 && v < 4294967296.0) return static_cast<int32_t>(static_cast<uint32_t>(v));  // results of >>> 0
+  if (!std::isfinite(v)) return 0;
+  double m = std::fmod(std::trunc(v), 4294967296.0);
+  if (m < 0) m += 4294967296.0;
+  return static_cast<int32_t>(static_cast<uint32_t>(m));
+}
+inline uint32_t toUint32(double v) { return static_cast<uint32_t>(toInt32(v)); }
+
+inline double jsMod(double a, double b) {
+  // Exact integer operands with a positive divisor: an integer remainder,
+  // keeping the dividend's sign (including -0) as JavaScript does.
+  constexpr double kExact = 9007199254740992.0;  // 2^53
+  if (a >= -kExact && a <= kExact && b >= 1.0 && b <= kExact) {
+    auto ia = static_cast<int64_t>(a);
+    auto ib = static_cast<int64_t>(b);
+    if (static_cast<double>(ia) == a && static_cast<double>(ib) == b) {
+      int64_t r = ia % ib;
+      return r == 0 && std::signbit(a) ? -0.0 : static_cast<double>(r);
+    }
+  }
+  return std::fmod(a, b);
+}
+inline double jsShl(double a, double b) { return static_cast<double>(static_cast<int32_t>(toUint32(a) << (toUint32(b) & 31))); }
+inline double jsSar(double a, double b) { return static_cast<double>(toInt32(a) >> (toUint32(b) & 31)); }
+inline double jsShr(double a, double b) { return static_cast<double>(toUint32(a) >> (toUint32(b) & 31)); }
+inline double jsAnd(double a, double b) { return static_cast<double>(toInt32(a) & toInt32(b)); }
+inline double jsOr(double a, double b) { return static_cast<double>(toInt32(a) | toInt32(b)); }
+inline double jsXor(double a, double b) { return static_cast<double>(toInt32(a) ^ toInt32(b)); }
+inline double jsNot(double a) { return static_cast<double>(~toInt32(a)); }
+double jsPow(double a, double b);
+
+/// Number.prototype.toString() / String(number).
+String numberToString(double v);
+String numberToString(double v, double radix);
+String numberToFixed(double v, double digits);
+String numberToPrecision(double v, double precision);
+String numberToExponential(double v, double digits);
+String numberToExponential(double v);
+/// Number(string) / unary plus.
+double stringToNumber(const String& s);
+double parseFloat(const String& s);
+double parseInt(const String& s);
+double parseInt(const String& s, double radix);
+
+inline String toJsString(double v) { return numberToString(v); }
+inline String toJsString(bool v) { return String::fromLatin1(v ? "true" : "false"); }
+inline String toJsString(const String& v) { return v; }
+inline String toJsString(Undefined) { return String::fromLatin1("undefined"); }
+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; }
+
+namespace math {
+inline double abs(double v) { return std::fabs(v); }
+inline double floor(double v) { return std::floor(v); }
+inline double ceil(double v) { return std::ceil(v); }
+inline double trunc(double v) { return std::trunc(v); }
+double round(double v);
+inline double sign(double v) { return std::isnan(v) ? v : (v > 0 ? 1.0 : (v < 0 ? -1.0 : v)); }
+inline double sqrt(double v) { return std::sqrt(v); }
+/// fdlibm's cbrt (exact for perfect cubes, like JavaScript engines).
+double cbrt(double v);
+inline double exp(double v) { return std::exp(v); }
+inline double expm1(double v) { return std::expm1(v); }
+inline double log(double v) { return std::log(v); }
+inline double log2(double v) { return std::log2(v); }
+inline double log10(double v) { return std::log10(v); }
+inline double log1p(double v) { return std::log1p(v); }
+inline double sin(double v) { return std::sin(v); }
+inline double cos(double v) { return std::cos(v); }
+inline double tan(double v) { return std::tan(v); }
+inline double asin(double v) { return std::asin(v); }
+inline double acos(double v) { return std::acos(v); }
+inline double atan(double v) { return std::atan(v); }
+inline double atan2(double y, double x) { return std::atan2(y, x); }
+inline double sinh(double v) { return std::sinh(v); }
+inline double cosh(double v) { return std::cosh(v); }
+inline double tanh(double v) { return std::tanh(v); }
+inline double asinh(double v) { return std::asinh(v); }
+inline double acosh(double v) { return std::acosh(v); }
+inline double atanh(double v) { return std::atanh(v); }
+inline double pow(double a, double b) { return jsPow(a, b); }
+inline double fround(double v) { return static_cast<double>(static_cast<float>(v)); }
+inline double imul(double a, double b) {
+  return static_cast<double>(static_cast<int32_t>(toUint32(a) * toUint32(b)));
+}
+inline double clz32(double v) {
+  uint32_t x = toUint32(v);
+  if (x == 0) return 32;
+  double n = 0;
+  while (!(x & 0x80000000u)) {
+    x <<= 1;
+    n++;
+  }
+  return n;
+}
+double hypot(double a, double b);
+double hypot(double a, double b, double c);
+double random();
+double min();
+double max();
+double min(double a);
+double max(double a);
+double min(double a, double b);
+double max(double a, double b);
+template <class... Rest>
+double min(double a, double b, double c, Rest... rest) {
+  return min(min(a, b), c, rest...);
+}
+template <class... Rest>
+double max(double a, double b, double c, Rest... rest) {
+  return max(max(a, b), c, rest...);
+}
+}  // namespace math
+
+namespace detail {
+/// One part of a concatenation: a string, or a number already formatted
+/// into `digits`, so the total length is known before allocating.
+struct ConcatPiece {
+  const String* s = nullptr;
+  String formatted;  // numbers without a short form (fractions, exponents)
+  char digits[24];
+  uint8_t n = 0;
+  const String* string() const { return s ? s : formatted.empty() ? nullptr : &formatted; }
+  size_t length() const { return string() ? string()->length() : n; }
+  bool oneByte() const { return !string() || string()->isOneByte(); }
+  void appendTo(StringBuilder& b) const {
+    if (auto* str = string()) b.append(*str);
+    else b.appendAscii(std::string_view(digits, n));
+  }
+};
+void formatNumber(double v, ConcatPiece& out);
+
+template <class P>
+ConcatPiece concatPiece(const P& p) {
+  ConcatPiece piece;
+  if constexpr (std::is_floating_point_v<P>) {
+    formatNumber(static_cast<double>(p), piece);
+  } else if constexpr (std::is_arithmetic_v<P> && !std::is_same_v<P, bool>) {
+    // Exact integers (from integer inference) print as their digits.
+    auto r = std::to_chars(piece.digits, piece.digits + sizeof piece.digits, p);
+    piece.n = static_cast<uint8_t>(r.ptr - piece.digits);
+  } else {
+    piece.s = &p;
+  }
+  return piece;
+}
+}  // namespace detail
+
+/// A template literal: strings and numbers joined into one string, allocating
+/// only the result.
+template <class... P>
+String concat(const P&... parts) {
+  if constexpr (sizeof...(P) == 1 && (std::is_same_v<P, String> && ...)) {
+    return (parts, ...);
+  } else {
+    detail::ConcatPiece pieces[] = {detail::concatPiece(parts)...};
+    size_t length = 0;
+    bool oneByte = true;
+    for (auto& p : pieces) {
+      length += p.length();
+      oneByte = oneByte && p.oneByte();
+    }
+    StringBuilder b(length, oneByte);
+    for (auto& p : pieces) p.appendTo(b);
+    return std::move(b).build();
+  }
+}
+
+}  // namespace lucent

package/runtime/cpp/lucent/ops.h

@@ -0,0 +1,165 @@
+// Lucent runtime — generic operations the compiler emits: truthiness,
+// string conversion, typeof, and conversions between union representations.
+#pragma once
+
+#include <cmath>
+#include <variant>
+
+#include "array.h"
+#include "async.h"
+#include "bytes.h"
+#include "core.h"
+#include "jserror.h"
+#include "function.h"
+#include "map.h"
+#include "number.h"
+#include "jsstring.h"
+
+namespace lucent {
+
+// --- truthiness ----------------------------------------------------------
+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(Undefined) { return false; }
+inline bool truthy(Null) { return false; }
+template <class T>
+bool truthy(const Ref<T>& r) {
+  return r != nullptr;
+}
+template <class T>
+bool truthy(const Opt<T>& v) {
+  return v.has() && truthy(v.get());
+}
+template <class... Ts>
+bool truthy(const std::variant<Ts...>& v) {
+  return std::visit([](const auto& x) { return truthy(x); }, v);
+}
+template <class T>
+bool truthy(const T&) {
+  return true;  // arrays, maps, functions, promises, bytes: objects are truthy
+}
+
+// --- String(x) -------------------------------------------------------------
+template <class T, std::enable_if_t<std::is_base_of_v<Object, T> && !std::is_base_of_v<ErrorObject, T>, int> = 0>
+String toJsString(const Ref<T>&) {
+  return String::fromLatin1("[object Object]");
+}
+inline String toJsString(const Error& e) { return errorToString(e); }
+template <class Sig>
+String toJsString(const Fn<Sig>&) {
+  return String::fromLatin1("function () { [native code] }");
+}
+template <class... Ts>
+String toJsString(const std::variant<Ts...>& v) {
+  return std::visit([](const auto& x) { return toJsString(x); }, v);
+}
+
+// --- typeof -----------------------------------------------------------------
+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(Undefined) { return String::fromLatin1("undefined"); }
+inline String typeOf(Null) { return String::fromLatin1("object"); }
+template <class Sig>
+String typeOf(const Fn<Sig>&) {
+  return String::fromLatin1("function");
+}
+template <class T>
+String typeOf(const Opt<T>& v) {
+  if (v.isUndefined()) return String::fromLatin1("undefined");
+  if (v.isNull()) return String::fromLatin1("object");
+  return typeOf(v.get());
+}
+template <class... Ts>
+String typeOf(const std::variant<Ts...>& v) {
+  return std::visit([](const auto& x) { return typeOf(x); }, v);
+}
+template <class T>
+String typeOf(const T&) {
+  return String::fromLatin1("object");
+}
+
+// --- 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) {
+    return []<class... Ts>(std::variant<Ts...>*) { return (std::is_same_v<T, Ts> || ...); }(static_cast<V*>(nullptr));
+  } else {
+    return false;
+  }
+}
+
+/// Converts between value representations the type checker has proven
+/// compatible: member → union, union → wider union, union → narrower union,
+/// union → member (after narrowing), and T ↔ Opt<T>.
+template <class To, class From>
+To convert(From&& from);
+
+namespace detail {
+template <class To, class From>
+To convertImpl(const From& from) {
+  using F = std::decay_t<From>;
+  if constexpr (std::is_same_v<To, F>) {
+    return from;
+  } else if constexpr (IsOpt<To>::value) {
+    using Inner = typename To::ValueType;
+    if constexpr (IsOpt<F>::value) {
+      if (from.isUndefined()) return To(undefined);
+      if (from.isNull()) return To(null);
+      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 {
+      return To(convert<Inner>(from));
+    }
+  } else if constexpr (IsOpt<F>::value) {
+    // Proven present by narrowing; still checked.
+    return convert<To>(from.value());
+  } else if constexpr (IsVariant<F>::value) {
+    return std::visit(
+        [](const auto& x) -> To {
+          using X = std::decay_t<decltype(x)>;
+          if constexpr (std::is_same_v<X, To> || std::is_constructible_v<To, X>) {
+            if constexpr (IsVariant<To>::value && !variantHolds<X, To>()) {
+              throwTypeError("Value does not match the expected union member");
+            } else {
+              return To(x);
+            }
+          } else {
+            throwTypeError("Value does not match the expected type");
+          }
+        },
+        from);
+  } else if constexpr (IsVariant<To>::value) {
+    return To(from);
+  } else {
+    return To(from);
+  }
+}
+}  // namespace detail
+
+template <class To, class From>
+To convert(From&& from) {
+  return detail::convertImpl<To>(from);
+}
+
+/// Narrows a union to one member; the checker proved it holds.
+template <class T, class... Ts>
+const T& narrow(const std::variant<Ts...>& v) {
+  if (const T* p = std::get_if<T>(&v)) return *p;
+  throwTypeError("Value does not match the narrowed type");
+}
+template <class T, class... Ts>
+bool holds(const std::variant<Ts...>& v) {
+  return std::holds_alternative<T>(v);
+}
+
+}  // namespace lucent