Add a template to avoid the cpp for initializing js classes (#178)

Author: elliottt

c-dependencies/js-compute-runtime/builtin.h

@@ -123,4 +123,63 @@
     return false;                                                                                  \
   }
 
+namespace builtins {
+
+template <typename Impl> class BuiltinImpl {
+private:
+  static constexpr const JSClassOps class_ops{};
+  static constexpr const uint32_t class_flags = 0;
+
+public:
+  static constexpr JSClass class_{
+      Impl::class_name,
+      JSCLASS_HAS_RESERVED_SLOTS(Impl::Slots::Count) | class_flags,
+      &class_ops,
+  };
+
+  static JS::PersistentRooted<JSObject *> proto_obj;
+
+  static bool is_instance(JSObject *obj) { return obj != nullptr && JS::GetClass(obj) == &class_; }
+
+  static bool is_instance(JS::Value val) { return val.isObject() && is_instance(&val.toObject()); }
+
+  static bool check_receiver(JSContext *cx, JS::HandleValue receiver, const char *method_name) {
+    if (!Impl::is_instance(receiver)) {
+      JS_ReportErrorUTF8(cx, "Method %s called on receiver that's not an instance of %s\n",
+                         method_name, Impl::class_.name);
+      return false;
+    }
+
+    return true;
+  }
+
+  static bool init_class_impl(JSContext *cx, JS::HandleObject global,
+                              JS::HandleObject parent_proto = nullptr) {
+    proto_obj.init(cx, JS_InitClass(cx, global, parent_proto, &class_, Impl::constructor,
+                                    Impl::ctor_length, Impl::properties, Impl::methods, nullptr,
+                                    nullptr));
+
+    return proto_obj != nullptr;
+  }
+};
+
+template <typename Impl> JS::PersistentRooted<JSObject *> BuiltinImpl<Impl>::proto_obj{};
+
+template <typename Impl> class BuiltinNoConstructor : public BuiltinImpl<Impl> {
+public:
+  static const int ctor_length = 1;
+
+  static bool constructor(JSContext *cx, unsigned argc, JS::Value *vp) {
+    JS_ReportErrorUTF8(cx, "%s can't be instantiated directly", Impl::class_name);
+    return false;
+  }
+
+  static bool init_class(JSContext *cx, JS::HandleObject global) {
+    return BuiltinImpl<Impl>::init_class_impl(cx, global) &&
+           JS_DeleteProperty(cx, global, BuiltinImpl<Impl>::class_.name);
+  }
+};
+
+} // namespace builtins
+
 #endif

c-dependencies/js-compute-runtime/builtins/logger.cpp

@@ -1,21 +1,13 @@
 #include "logger.h"
 #include "host_call.h"
 
-namespace Logger {
-namespace Slots {
-enum { Endpoint, Count };
-};
+namespace builtins {
 
-bool check_receiver(JSContext *cx, JS::HandleValue receiver, const char *method_name);
-
-namespace {
-
-const unsigned ctor_length = 1;
-
-static bool log(JSContext *cx, unsigned argc, JS::Value *vp) {
+bool Logger::log(JSContext *cx, unsigned argc, JS::Value *vp) {
   METHOD_HEADER(1)
 
-  auto endpoint = LogEndpointHandle{(uint32_t)JS::GetReservedSlot(self, Slots::Endpoint).toInt32()};
+  auto endpoint =
+      LogEndpointHandle{(uint32_t)JS::GetReservedSlot(self, Logger::Slots::Endpoint).toInt32()};
 
   size_t msg_len;
   JS::UniqueChars msg = encode(cx, args.get(0), &msg_len);
@@ -30,15 +22,11 @@ static bool log(JSContext *cx, unsigned argc, JS::Value *vp) {
   return true;
 }
 
-const JSFunctionSpec methods[] = {JS_FN("log", log, 1, JSPROP_ENUMERATE), JS_FS_END};
+const JSFunctionSpec Logger::methods[] = {JS_FN("log", log, 1, JSPROP_ENUMERATE), JS_FS_END};
 
-const JSPropertySpec properties[] = {JS_PS_END};
+const JSPropertySpec Logger::properties[] = {JS_PS_END};
 
-} // namespace
-
-CLASS_BOILERPLATE_NO_CTOR(Logger)
-
-JSObject *create(JSContext *cx, const char *name) {
+JSObject *Logger::create(JSContext *cx, const char *name) {
   JS::RootedObject logger(cx, JS_NewObjectWithGivenProto(cx, &class_, proto_obj));
   if (!logger)
     return nullptr;
@@ -52,4 +40,5 @@ JSObject *create(JSContext *cx, const char *name) {
 
   return logger;
 }
-} // namespace Logger
+
+} // namespace builtins

c-dependencies/js-compute-runtime/builtins/logger.h

@@ -3,12 +3,23 @@
 
 #include "builtin.h"
 
-namespace Logger {
-// Register the Logger class.
-bool init_class(JSContext *cx, JS::HandleObject global);
+namespace builtins {
 
-// Create an instance of the logger class.
-JSObject *create(JSContext *cx, const char *name);
-} // namespace Logger
+class Logger : public BuiltinNoConstructor<Logger> {
+private:
+  static bool log(JSContext *cx, unsigned argc, JS::Value *vp);
+
+public:
+  static constexpr const char *class_name = "Logger";
+
+  enum Slots { Endpoint, Count };
+
+  static const JSFunctionSpec methods[];
+  static const JSPropertySpec properties[];
+
+  static JSObject *create(JSContext *cx, const char *name);
+};
+
+} // namespace builtins
 
 #endif

c-dependencies/js-compute-runtime/js-compute-builtins.cpp

@@ -483,7 +483,7 @@ bool getLogger(JSContext *cx, unsigned argc, Value *vp) {
   if (!name)
     return false;
 
-  RootedObject logger(cx, Logger::create(cx, name.get()));
+  RootedObject logger(cx, builtins::Logger::create(cx, name.get()));
   if (!logger)
     return false;
 
@@ -6271,7 +6271,7 @@ bool define_fastly_sys(JSContext *cx, HandleObject global) {
     return false;
   if (!TextDecoder::init_class(cx, global))
     return false;
-  if (!Logger::init_class(cx, global))
+  if (!builtins::Logger::init_class(cx, global))
     return false;
   if (!URL::init_class(cx, global))
     return false;