Bug 1916277 - Part 10: Add a debug slot [[IsPreload]] in ModuleObject. r=jonco

This will allow us to identify the module is loaded during preloading
phase.

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

Author: allstarschh

js/loader/LoadedScript.cpp

@@ -456,6 +456,13 @@ void ModuleScript::SetModuleRecord(Handle<JSObject*> aModuleRecord) {
     SetModulePrivate(mModuleRecord, PrivateValue(this));
   }
 
+#ifdef DEBUG
+  // Sync the [[PreloadSlot]] in ModuleObject.
+  if (mModuleRecord) {
+    SetModulePreload(mModuleRecord, mForPreload);
+  }
+#endif
+
   mozilla::HoldJSObjects(this);
 }
 
@@ -479,7 +486,14 @@ void ModuleScript::SetErrorToRethrow(const Value& aError) {
   mErrorToRethrow = aError;
 }
 
-void ModuleScript::SetForPreload(bool aValue) { mForPreload = aValue; }
+void ModuleScript::SetForPreload(bool aValue) {
+  mForPreload = aValue;
+#ifdef DEBUG
+  if (ModuleRecord()) {
+    SetModulePreload(ModuleRecord(), aValue);
+  }
+#endif
+}
 void ModuleScript::SetHadImportMap(bool aValue) { mHadImportMap = aValue; }
 
 ResolvedModuleSet* ModuleScript::GetPreloadedResolvedSet() {

js/loader/ModuleLoaderBase.cpp

@@ -1055,8 +1055,8 @@ nsresult ModuleLoaderBase::CreateModuleScript(ModuleLoadRequest* aRequest) {
     moduleScript->SetModuleRecord(module);
   }
 
-  LOG(("ScriptLoadRequest (%p):   module script == %p", aRequest,
-       aRequest->mModuleScript.get()));
+  LOG(("ScriptLoadRequest (%p):   module script == %p ForPreload %d", aRequest,
+       aRequest->mModuleScript.get(), aRequest->mModuleScript->ForPreload()));
 
   return rv;
 }

js/public/Modules.h

@@ -246,6 +246,14 @@ extern JS_PUBLIC_API Value GetModulePrivate(JSObject* module);
  */
 extern JS_PUBLIC_API bool IsCyclicModule(JSObject* module);
 
+#ifdef DEBUG
+/**
+ * A helper function to set the isPreload flag on the ModuleObject.
+ * The flag will be verified later when ResetPreloadedModule is called.
+ */
+extern JS_PUBLIC_API void SetModulePreload(JSObject* module, bool isPreload);
+#endif
+
 /*
  * Perform the ModuleLink operation on the given source text module record.
  *

js/src/builtin/ModuleObject.cpp

@@ -1342,6 +1342,16 @@ void ModuleObject::setMetaObject(JSObject* obj) {
   cyclicModuleFields()->metaObject = obj;
 }
 
+#ifdef DEBUG
+void ModuleObject::setPreload(bool isPreload) {
+  setReservedSlot(PreloadSlot, BooleanValue(isPreload));
+}
+
+bool ModuleObject::isPreload() const {
+  return getReservedSlot(PreloadSlot).toBoolean();
+}
+#endif
+
 /* static */
 void ModuleObject::trace(JSTracer* trc, JSObject* obj) {
   ModuleObject& module = obj->as<ModuleObject>();

js/src/builtin/ModuleObject.h

@@ -395,6 +395,9 @@ class ModuleObject : public NativeObject {
     CyclicModuleFieldsSlot,
     // `SyntheticModuleFields` if a synthetic module. Otherwise `undefined`.
     SyntheticModuleFieldsSlot,
+#ifdef DEBUG
+    PreloadSlot,
+#endif
     SlotCount
   };
 
@@ -501,6 +504,11 @@ class ModuleObject : public NativeObject {
   void initAsyncSlots(JSContext* cx, bool hasTopLevelAwait,
                       Handle<ListObject*> asyncParentModules);
 
+#ifdef DEBUG
+  void setPreload(bool isPreload);
+  bool isPreload() const;
+#endif
+
  private:
   static const JSClassOps classOps_;
 

js/src/vm/Modules.cpp

@@ -338,6 +338,13 @@ JS_PUBLIC_API bool JS::IsCyclicModule(JSObject* module) {
   return module->as<ModuleObject>().hasCyclicModuleFields();
 }
 
+#ifdef DEBUG
+JS_PUBLIC_API void JS::SetModulePreload(JSObject* module, bool isPreload) {
+  MOZ_ASSERT(module->is<ModuleObject>());
+  module->as<ModuleObject>().setPreload(isPreload);
+}
+#endif
+
 JS_PUBLIC_API bool JS::ModuleLink(JSContext* cx, Handle<JSObject*> moduleArg) {
   AssertHeapIsIdle();
   CHECK_THREAD(cx);