Merge pull request #5424 from cloudflare/jasnell/tech-debt-jsvalue-stuff

Author: jasnell

src/workerd/jsg/jsvalue.c++

@@ -171,6 +171,88 @@ JsValue JsObject::getPrototype(Lock& js) {
   return JsValue(inner->GetPrototypeV2());
 }
 
+kj::String JsSymbol::description(Lock& js) const {
+  auto desc = inner->Description(js.v8Isolate);
+  if (desc.IsEmpty() || desc->IsUndefined()) {
+    return kj::String();
+  }
+  return kj::str(desc);
+}
+
+void JsSet::add(Lock& js, const JsValue& value) {
+  check(inner->Add(js.v8Context(), value.inner));
+}
+
+bool JsSet::has(Lock& js, const JsValue& value) const {
+  return check(inner->Has(js.v8Context(), value.inner));
+}
+
+bool JsSet::delete_(Lock& js, const JsValue& value) {
+  return check(inner->Delete(js.v8Context(), value.inner));
+}
+
+void JsSet::addAll(Lock& js, kj::ArrayPtr<const JsValue> values) {
+  for (const JsValue& value: values) {
+    check(inner->Add(js.v8Context(), value.inner));
+  }
+}
+
+void JsSet::clear() {
+  inner->Clear();
+}
+
+size_t JsSet::size() const {
+  return inner->Size();
+}
+
+JsSet::operator JsArray() const {
+  return JsArray(inner->AsArray());
+}
+
+kj::Maybe<int32_t> JsInt32::value(Lock& js) const {
+  KJ_ASSERT(!inner.IsEmpty());
+  int32_t value;
+  // The Int32Value(...) operation can fail with a JS exception, in which case
+  // we return kj::none and the error should be allowed to propagate.
+  if (inner->Int32Value(js.v8Context()).To(&value)) {
+    return value;
+  }
+  return kj::none;
+}
+
+kj::Maybe<uint32_t> JsUint32::value(Lock& js) const {
+  KJ_ASSERT(!inner.IsEmpty());
+  uint32_t value;
+  // The Uint32Value(...) operation can fail with a JS exception, in which case
+  // we return kj::none and the error should be allowed to propagate.
+  if (inner->Uint32Value(js.v8Context()).To(&value)) {
+    return value;
+  }
+  return kj::none;
+};
+
+kj::Maybe<int64_t> JsBigInt::toInt64(Lock& js) const {
+  KJ_ASSERT(!inner.IsEmpty());
+  bool lossless = false;
+  int64_t value = inner->Int64Value(&lossless);
+  if (!lossless) {
+    js.v8Isolate->ThrowException(js.rangeError("BigInt value does not fit in int64_t"));
+    return kj::none;
+  }
+  return value;
+}
+
+kj::Maybe<uint64_t> JsBigInt::toUint64(Lock& js) const {
+  KJ_ASSERT(!inner.IsEmpty());
+  bool lossless = false;
+  uint64_t value = inner->Uint64Value(&lossless);
+  if (!lossless) {
+    js.v8Isolate->ThrowException(js.rangeError("BigInt value does not fit in uint64_t"));
+    return kj::none;
+  }
+  return value;
+}
+
 kj::Maybe<double> JsNumber::value(Lock& js) const {
   KJ_ASSERT(!inner.IsEmpty());
   double value;

src/workerd/jsg/jsvalue.h

@@ -334,19 +334,59 @@ class JsProxy final: public JsBase<v8::Proxy, JsProxy> {
   using JsBase<v8::Proxy, JsProxy>::JsBase;
 };
 
-#define V(Name)                                                                                    \
-  class Js##Name final: public JsBase<v8::Name, Js##Name> {                                        \
-   public:                                                                                         \
-    using JsBase<v8::Name, Js##Name>::JsBase;                                                      \
-  };
+class JsSymbol final: public JsBase<v8::Symbol, JsSymbol> {
+ public:
+  kj::String description(Lock& js) const KJ_WARN_UNUSED_RESULT;
 
-V(Symbol)
-V(BigInt)
-V(Int32)
-V(Uint32)
-V(Set)
+  using JsBase<v8::Symbol, JsSymbol>::JsBase;
+};
 
-#undef V
+class JsSet final: public JsBase<v8::Set, JsSet> {
+ public:
+  void add(Lock& js, const JsValue& value);
+  bool has(Lock& js, const JsValue& value) const;
+  bool delete_(Lock& js, const JsValue& value);
+  void clear();
+  size_t size() const;
+
+  template <IsJsValue... Args>
+  void addAll(Lock& js, Args... args) {
+    (check(inner->Add(js.v8Context(), args.inner)), ...);
+  }
+
+  void addAll(Lock& js, kj::ArrayPtr<const JsValue> values);
+
+  operator JsArray() const;
+
+  using JsBase<v8::Set, JsSet>::JsBase;
+};
+
+class JsBigInt final: public JsBase<v8::BigInt, JsBigInt> {
+ public:
+  // If the BigInt value does not fit in int64_t, returns kj::none
+  // and schedules an exception on the isolate.
+  kj::Maybe<int64_t> toInt64(Lock& js) const KJ_WARN_UNUSED_RESULT;
+
+  // If the BigInt value does not fit in int64_t, returns kj::none
+  // and schedules an exception on the isolate.
+  kj::Maybe<uint64_t> toUint64(Lock& js) const KJ_WARN_UNUSED_RESULT;
+
+  using JsBase<v8::BigInt, JsBigInt>::JsBase;
+};
+
+class JsInt32 final: public JsBase<v8::Int32, JsInt32> {
+ public:
+  kj::Maybe<int32_t> value(Lock& js) const KJ_WARN_UNUSED_RESULT;
+
+  using JsBase<v8::Int32, JsInt32>::JsBase;
+};
+
+class JsUint32 final: public JsBase<v8::Uint32, JsUint32> {
+ public:
+  kj::Maybe<uint32_t> value(Lock& js) const KJ_WARN_UNUSED_RESULT;
+
+  using JsBase<v8::Uint32, JsUint32>::JsBase;
+};
 
 class JsNumber final: public JsBase<v8::Number, JsNumber> {
  public: