Bug 1736060 - Part 4: Implement HostGetSupportedImportAssertions. r=mgaudet,arai

Differential Revision: https://phabricator.services.mozilla.com/D126044

dom/script/ScriptLoader.cpp

@@ -1037,6 +1037,20 @@ static LoadedScript* GetLoadedScriptOrNull(
   return script;
 }
 
+bool HostGetSupportedImportAssertions(JSContext* aCx,
+                                      JS::ImportAssertionVector& aValues) {
+  MOZ_ASSERT(aValues.empty());
+
+  if (!aValues.reserve(1)) {
+    JS_ReportOutOfMemory(aCx);
+    return false;
+  }
+
+  aValues.infallibleAppend(JS::ImportAssertion::Type);
+
+  return true;
+}
+
 // 8.1.3.8.1 HostResolveImportedModule(referencingModule, moduleRequest)
 JSObject* HostResolveImportedModule(JSContext* aCx,
                                     JS::Handle<JS::Value> aReferencingPrivate,
@@ -1284,6 +1298,7 @@ void ScriptLoader::EnsureModuleHooksInitialized() {
   JS::SetModuleMetadataHook(rt, HostPopulateImportMeta);
   JS::SetScriptPrivateReferenceHooks(rt, HostAddRefTopLevelScript,
                                      HostReleaseTopLevelScript);
+  JS::SetSupportedAssertionsHook(rt, HostGetSupportedImportAssertions);
 
   Preferences::RegisterCallbackAndCall(DynamicImportPrefChangedCallback,
                                        "javascript.options.dynamicImport",

js/public/Modules.h

@@ -13,9 +13,11 @@
 
 #include "jstypes.h"  // JS_PUBLIC_API
 
+#include "js/AllocPolicy.h"     // js::SystemAllocPolicy
 #include "js/CompileOptions.h"  // JS::ReadOnlyCompileOptions
 #include "js/RootingAPI.h"      // JS::{Mutable,}Handle
 #include "js/Value.h"           // JS::Value
+#include "js/Vector.h"          // js::Vector
 
 struct JS_PUBLIC_API JSContext;
 class JS_PUBLIC_API JSObject;
@@ -33,6 +35,28 @@ union Utf8Unit;
 
 namespace JS {
 
+enum class ImportAssertion { Type };
+
+using ImportAssertionVector =
+    js::Vector<ImportAssertion, 1, js::SystemAllocPolicy>;
+
+using SupportedAssertionsHook = bool (*)(JSContext*,
+                                         ImportAssertionVector& values);
+
+/**
+ * Get the HostGetSupportedImportAssertions hook for the runtime.
+ */
+extern JS_PUBLIC_API SupportedAssertionsHook
+GetSupportedAssertionsHook(JSRuntime* rt);
+
+/**
+ * Set the HostGetSupportedImportAssertions hook for the runtime to the given
+ * function.
+ * https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions
+ */
+extern JS_PUBLIC_API void SetSupportedAssertionsHook(
+    JSRuntime* rt, SupportedAssertionsHook func);
+
 using ModuleResolveHook = JSObject* (*)(JSContext*, Handle<Value>,
                                         Handle<JSObject*>);
 

js/src/shell/ModuleLoader.cpp

@@ -60,6 +60,8 @@ bool ModuleLoader::init(JSContext* cx, HandleString loadPath) {
   JS::SetModuleResolveHook(rt, ModuleLoader::ResolveImportedModule);
   JS::SetModuleMetadataHook(rt, ModuleLoader::GetImportMetaProperties);
   JS::SetModuleDynamicImportHook(rt, ModuleLoader::ImportModuleDynamically);
+  JS::SetSupportedAssertionsHook(rt,
+                                 ModuleLoader::GetSupportedImportAssertions);
 
   return true;
 }
@@ -91,6 +93,21 @@ bool ModuleLoader::ImportModuleDynamically(JSContext* cx,
                                           promise);
 }
 
+// static
+bool ModuleLoader::GetSupportedImportAssertions(
+    JSContext* cx, JS::ImportAssertionVector& values) {
+  MOZ_ASSERT(values.empty());
+
+  if (!values.reserve(1)) {
+    ReportOutOfMemory(cx);
+    return false;
+  }
+
+  values.infallibleAppend(JS::ImportAssertion::Type);
+
+  return true;
+}
+
 bool ModuleLoader::loadRootModule(JSContext* cx, HandleString path) {
   RootedValue rval(cx);
   if (!loadAndExecute(cx, path, &rval)) {

js/src/shell/ModuleLoader.h

@@ -33,6 +33,8 @@ class ModuleLoader {
                                       HandleValue referencingPrivate,
                                       HandleObject moduleRequest,
                                       HandleObject promise);
+  static bool GetSupportedImportAssertions(JSContext* cx,
+                                           JS::ImportAssertionVector& values);
 
   static bool DynamicImportDelayFulfilled(JSContext* cx, unsigned argc,
                                           Value* vp);

js/src/vm/Modules.cpp

@@ -32,6 +32,20 @@ using js::AssertHeapIsIdle;
 using js::ModuleObject;
 using js::RequestedModuleObject;
 
+JS_PUBLIC_API JS::SupportedAssertionsHook JS::GetSupportedAssertionsHook(
+    JSRuntime* rt) {
+  AssertHeapIsIdle();
+
+  return rt->supportedAssertionsHook;
+}
+
+JS_PUBLIC_API void JS::SetSupportedAssertionsHook(
+    JSRuntime* rt, SupportedAssertionsHook func) {
+  AssertHeapIsIdle();
+
+  rt->supportedAssertionsHook = func;
+}
+
 JS_PUBLIC_API JS::ModuleResolveHook JS::GetModuleResolveHook(JSRuntime* rt) {
   AssertHeapIsIdle();
 

js/src/vm/Runtime.h

@@ -1026,6 +1026,11 @@ struct JSRuntime {
   // module import and can accessed by off-thread parsing.
   mozilla::Atomic<JS::ModuleDynamicImportHook> moduleDynamicImportHook;
 
+  // A hook that implements the abstract operation
+  // HostGetSupportedImportAssertions.
+  // https://tc39.es/proposal-import-assertions/#sec-hostgetsupportedimportassertions
+  mozilla::Atomic<JS::SupportedAssertionsHook> supportedAssertionsHook;
+
   // Hooks called when script private references are created and destroyed.
   js::MainThreadData<JS::ScriptPrivateReferenceHook> scriptPrivateAddRefHook;
   js::MainThreadData<JS::ScriptPrivateReferenceHook> scriptPrivateReleaseHook;