fix: modular builtin separation (#426)

Author: Guy Bedford

c-dependencies/js-compute-runtime/Makefile

@@ -279,7 +279,7 @@ $(OBJ_DIR)/js-compute-runtime-component.wasm: $(OBJ_DIR)/xqd-world/xqd_world_ada
 shared-builtins.a: $(OBJ_DIR)/shared-builtins.a
 	$(call cmd,cp,$@)
 
-$(OBJ_DIR)/shared-builtins.a: $(OBJ_DIR)/builtins/shared/console.o
+$(OBJ_DIR)/shared-builtins.a: $(OBJ_DIR)/builtins/shared/console.o $(OBJ_DIR)/builtin.o
 	$(call cmd,wasi_ar,$@)
 
 # These two rules copy the built artifacts into the $(FSM_SRC) directory, and

c-dependencies/js-compute-runtime/builtin-error-numbers.msg

@@ -0,0 +1,47 @@
+/*
+ * Our own version of spidermonkey/js/friend/ErrorNumbers.msg
+ * where we can add our own custom error messages for use within the runtime
+ */
+
+/*
+ * This is our JavaScript error message file.
+ *
+ * The format for each JS error message is:
+ *
+ * MSG_DEF(<SYMBOLIC_NAME>, <ARGUMENT_COUNT>, <EXCEPTION_NAME>,
+ *         <FORMAT_STRING>)
+ *
+ * where ;
+ * <SYMBOLIC_NAME> is a legal C identifer that will be used in the
+ * JS engine source.
+ *
+ * <ARGUMENT_COUNT> is an integer literal specifying the total number of
+ * replaceable arguments in the following format string.
+ *
+ * <EXCEPTION_NAME> is an enum JSExnType value, defined in js/ErrorReport.h.
+ *
+ * <FORMAT_STRING> is a string literal, optionally containing sequences
+ * {X} where X  is an integer representing the argument number that will
+ * be replaced with a string value when the error is reported.
+ *
+ * e.g.
+ *
+ * MSG_DEF(JSMSG_NOT_A_SUBSPECIES, 2, JSEXN_TYPEERROR,
+ *         "{0} is not a member of the {1} family")
+ *
+ * can be used:
+ *
+ * JS_ReportErrorNumberASCII(JSMSG_NOT_A_SUBSPECIES, "Rhino", "Monkey");
+ *
+ * to report:
+ *
+ * "TypeError: Rhino is not a member of the Monkey family"
+ */
+
+// clang-format off
+MSG_DEF(JSMSG_BUILTIN_NOT_AN_ERROR,                            0, JSEXN_ERR,     "<Error #0 is reserved>")
+MSG_DEF(JSMSG_BUILTIN_CTOR_NO_NEW,                             1, JSEXN_TYPEERR, "calling a builtin {0} constructor without new is forbidden")
+MSG_DEF(JSMSG_ILLEGAL_CTOR,                                    0, JSEXN_TYPEERR, "Illegal constructor")
+MSG_DEF(JSMSG_INVALID_INTERFACE,                               2, JSEXN_TYPEERR, "'{0}' called on an object that does not implement interface {1}")
+MSG_DEF(JSMSG_INCOMPATIBLE_INSTANCE,                           2, JSEXN_TYPEERR, "Method {0} called on receiver that's not an instance of {1}")
+//clang-format on

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

@@ -0,0 +1,38 @@
+#include "builtin.h"
+
+const JSErrorFormatString *GetErrorMessageBuiltin(void *userRef, unsigned errorNumber) {
+  if (errorNumber > 0 && errorNumber < JSBuiltinErrNum_Limit) {
+    return &js_ErrorFormatStringBuiltin[errorNumber];
+  }
+
+  return nullptr;
+}
+
+JS::UniqueChars encode(JSContext *cx, JS::HandleString str, size_t *encoded_len) {
+  JS::UniqueChars text = JS_EncodeStringToUTF8(cx, str);
+  if (!text)
+    return nullptr;
+
+  // This shouldn't fail, since the encode operation ensured `str` is linear.
+  JSLinearString *linear = JS_EnsureLinearString(cx, str);
+  *encoded_len = JS::GetDeflatedUTF8StringLength(linear);
+  return text;
+}
+
+JS::UniqueChars encode(JSContext *cx, JS::HandleValue val, size_t *encoded_len) {
+  JS::RootedString str(cx, JS::ToString(cx, val));
+  if (!str)
+    return nullptr;
+
+  return encode(cx, str, encoded_len);
+}
+
+jsurl::SpecString encode(JSContext *cx, JS::HandleValue val) {
+  jsurl::SpecString slice(nullptr, 0, 0);
+  auto chars = encode(cx, val, &slice.len);
+  if (!chars)
+    return slice;
+  slice.data = (uint8_t *)chars.release();
+  slice.cap = slice.len;
+  return slice;
+}

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

@@ -3,7 +3,43 @@
 
 #include <tuple>
 
-#include "js-compute-builtins.h"
+// TODO: remove these once the warnings are fixed
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#pragma clang diagnostic ignored "-Wdeprecated-enum-enum-conversion"
+#include "js/Conversions.h"
+#include "js/ForOfIterator.h"
+#include "js/Object.h"
+#include "js/Promise.h"
+#include "jsapi.h"
+#include "jsfriendapi.h"
+#include "rust-url/rust-url.h"
+
+#pragma clang diagnostic pop
+
+// TODO(performance): introduce a version that writes into an existing buffer, and use that
+// with the hostcall buffer where possible.
+// https://github.com/fastly/js-compute-runtime/issues/215
+JS::UniqueChars encode(JSContext *cx, JS::HandleString str, size_t *encoded_len);
+
+JS::UniqueChars encode(JSContext *cx, JS::HandleValue val, size_t *encoded_len);
+
+jsurl::SpecString encode(JSContext *cx, JS::HandleValue val);
+
+enum JSBuiltinErrNum {
+#define MSG_DEF(name, count, exception, format) name,
+#include "./builtin-error-numbers.msg"
+#undef MSG_DEF
+  JSBuiltinErrNum_Limit
+};
+
+const JSErrorFormatString js_ErrorFormatStringBuiltin[JSBuiltinErrNum_Limit] = {
+#define MSG_DEF(name, count, exception, format) {#name, format, count, exception},
+#include "./builtin-error-numbers.msg"
+#undef MSG_DEF
+};
+
+const JSErrorFormatString *GetErrorMessageBuiltin(void *userRef, unsigned errorNumber);
 
 #define DBG(...)                                                                                   \
   printf("%s#%d: ", __func__, __LINE__);                                                           \
@@ -45,7 +81,7 @@
                                                                                                    \
   bool check_receiver(JSContext *cx, JS::HandleValue receiver, const char *method_name) {          \
     if (!is_instance(receiver)) {                                                                  \
-      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_INSTANCE,         \
+      JS_ReportErrorNumberASCII(cx, GetErrorMessageBuiltin, nullptr, JSMSG_INCOMPATIBLE_INSTANCE,  \
                                 method_name, class_.name);                                         \
       return false;                                                                                \
     }                                                                                              \
@@ -131,7 +167,8 @@ inline bool ThrowIfNotConstructing(JSContext *cx, const JS::CallArgs &args,
     return true;
   }
 
-  JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_BUILTIN_CTOR_NO_NEW, builtinName);
+  JS_ReportErrorNumberASCII(cx, GetErrorMessageBuiltin, nullptr, JSMSG_BUILTIN_CTOR_NO_NEW,
+                            builtinName);
   return false;
 }
 namespace builtins {
@@ -172,7 +209,7 @@ template <typename Impl> class BuiltinImpl {
 
   static bool check_receiver(JSContext *cx, JS::HandleValue receiver, const char *method_name) {
     if (!Impl::is_instance(receiver)) {
-      JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr, JSMSG_INCOMPATIBLE_INSTANCE,
+      JS_ReportErrorNumberASCII(cx, GetErrorMessageBuiltin, nullptr, JSMSG_INCOMPATIBLE_INSTANCE,
                                 method_name, Impl::class_.name);
       return false;
     }

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

@@ -19,6 +19,7 @@
 
 #include "backend.h"
 #include "host_call.h"
+#include "js-compute-builtins.h"
 #include "js/Conversions.h"
 
 enum class Authentication : uint8_t {

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

@@ -2,6 +2,7 @@
 #define JS_COMPUTE_RUNTIME_BACKEND_H
 
 #include "builtin.h"
+#include "js-compute-builtins.h"
 
 namespace builtins {
 

c-dependencies/js-compute-runtime/builtins/cache-override.h

@@ -2,6 +2,7 @@
 #define JS_COMPUTE_RUNTIME_CACHE_OVERRIDE_H
 
 #include "builtin.h"
+#include "js-compute-builtins.h"
 
 namespace builtins {
 

c-dependencies/js-compute-runtime/builtins/compression-stream.h

@@ -2,6 +2,7 @@
 #define JS_COMPUTE_RUNTIME_COMPRESSION_STREAM_H
 
 #include "builtin.h"
+#include "js-compute-builtins.h"
 
 namespace builtins {
 

c-dependencies/js-compute-runtime/builtins/config-store.h

@@ -2,6 +2,7 @@
 #define JS_COMPUTE_RUNTIME_CONFIG_STORE_H
 
 #include "builtin.h"
+#include "js-compute-builtins.h"
 
 namespace builtins {
 

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

@@ -2,6 +2,7 @@
 #define JS_COMPUTE_RUNTIME_BUILTIN_CRYPTO_H
 
 #include "builtin.h"
+#include "js-compute-builtins.h"
 
 namespace builtins {