tor-browser

commit a278af2759c343173c898684d3a3c0d08c29c9bf
parent 386979b1d183b4111bbfc3d99bf893294200a380
Author: Yoshi Cheng-Hao Huang <allstars.chh@gmail.com>
Date:   Fri, 19 Dec 2025 21:40:07 +0000

Bug 2006871 - Part 2: Add [[Phase]] in ModuleRequestObject. r=jonco

ModuleRequest fields change:
Defer Import Evaluation: https://tc39.es/proposal-defer-import-eval/#table-modulerequest-fields
Source Phase Import: https://tc39.es/proposal-source-phase-imports/#table-modulerequest-record-fields

Import Call:
Defer Import Evaluation: https://tc39.es/proposal-defer-import-eval/#sec-import-call-runtime-semantics-evaluation
Source Phase Import: https://tc39.es/proposal-source-phase-imports/#sec-import-call-runtime-semantics-evaluation

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

Diffstat:
M
js/src/builtin/ModuleObject.cpp
 | 
23
++++++++++++++++++++---
M
js/src/builtin/ModuleObject.h
 | 
13
+++++++++----

2 files changed, 29 insertions(+), 7 deletions(-)
diff --git a/js/src/builtin/ModuleObject.cpp b/js/src/builtin/ModuleObject.cpp
@@ -66,6 +66,17 @@ static JS::ModuleType ValueToModuleType(const Value& value) {
   return static_cast<JS::ModuleType>(i);
 }
 
+static Value ImportPhaseToValue(ImportPhase phase) {
+  static_assert(size_t(ImportPhase::Limit) <= INT32_MAX);
+  return Int32Value(int32_t(phase));
+}
+
+static ImportPhase ValueToImportPhase(const Value& value) {
+  int32_t i = value.toInt32();
+  MOZ_ASSERT(i >= 0 && i <= int32_t(ImportPhase::Limit));
+  return static_cast<ImportPhase>(i);
+}
+
 #define DEFINE_ATOM_ACCESSOR_METHOD(cls, name, slot) \
   JSAtom* cls::name() const {                        \
     Value value = getReservedSlot(slot);             \
@@ -212,6 +223,10 @@ JS::ModuleType ModuleRequestObject::moduleType() const {
   return ValueToModuleType(getReservedSlot(ModuleTypeSlot));
 }
 
+ImportPhase ModuleRequestObject::phase() const {
+  return ValueToImportPhase(getReservedSlot(PhaseSlot));
+}
+
 static bool GetModuleType(JSContext* cx,
                           Handle<ImportAttributeVector> maybeAttributes,
                           JS::ModuleType& moduleType) {
@@ -249,19 +264,20 @@ bool ModuleRequestObject::isInstance(HandleValue value) {
 /* static */
 ModuleRequestObject* ModuleRequestObject::create(
     JSContext* cx, Handle<JSAtom*> specifier,
-    Handle<ImportAttributeVector> maybeAttributes) {
+    Handle<ImportAttributeVector> maybeAttributes, ImportPhase phase) {
   JS::ModuleType moduleType = JS::ModuleType::JavaScript;
   if (!GetModuleType(cx, maybeAttributes, moduleType)) {
     return nullptr;
   }
 
-  return create(cx, specifier, moduleType);
+  return create(cx, specifier, moduleType, phase);
 }
 
 /* static */
 ModuleRequestObject* ModuleRequestObject::create(JSContext* cx,
                                                  Handle<JSAtom*> specifier,
-                                                 JS::ModuleType moduleType) {
+                                                 JS::ModuleType moduleType,
+                                                 ImportPhase phase) {
   ModuleRequestObject* self =
       NewObjectWithGivenProto<ModuleRequestObject>(cx, nullptr);
   if (!self) {
@@ -270,6 +286,7 @@ ModuleRequestObject* ModuleRequestObject::create(JSContext* cx,
 
   self->initReservedSlot(SpecifierSlot, StringOrNullValue(specifier));
   self->initReservedSlot(ModuleTypeSlot, ModuleTypeToValue(moduleType));
+  self->initReservedSlot(PhaseSlot, ImportPhaseToValue(phase));
 
   return self;
 }
diff --git a/js/src/builtin/ModuleObject.h b/js/src/builtin/ModuleObject.h
@@ -66,12 +66,15 @@ class ImportAttribute {
 
 using ImportAttributeVector = GCVector<ImportAttribute, 0, SystemAllocPolicy>;
 
+enum class ImportPhase : uint8_t { Evaluation, Limit };
+
 class ModuleRequestObject : public NativeObject {
  public:
   enum {
     SpecifierSlot = 0,
     FirstUnsupportedAttributeKeySlot,
     ModuleTypeSlot,
+    PhaseSlot,
     SlotCount
   };
 
@@ -79,13 +82,15 @@ class ModuleRequestObject : public NativeObject {
   static bool isInstance(HandleValue value);
   [[nodiscard]] static ModuleRequestObject* create(
       JSContext* cx, Handle<JSAtom*> specifier,
-      Handle<ImportAttributeVector> maybeAttributes);
-  [[nodiscard]] static ModuleRequestObject* create(JSContext* cx,
-                                                   Handle<JSAtom*> specifier,
-                                                   JS::ModuleType moduleType);
+      Handle<ImportAttributeVector> maybeAttributes,
+      ImportPhase phase = ImportPhase::Evaluation);
+  [[nodiscard]] static ModuleRequestObject* create(
+      JSContext* cx, Handle<JSAtom*> specifier, JS::ModuleType moduleType,
+      ImportPhase phase = ImportPhase::Evaluation);
 
   JSAtom* specifier() const;
   JS::ModuleType moduleType() const;
+  ImportPhase phase() const;
 
   // We process import attributes earlier in the process, but according to the
   // spec, we should error during module evaluation if we encounter an