Bug 1720619 - Part 2: Add JS::InstantiateOptions. r=tcampbell

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

dom/base/JSExecutionContext.cpp

@@ -199,7 +199,9 @@ nsresult JSExecutionContext::Decode(mozilla::Vector<uint8_t>& aBytecodeBuf,
     return mRv;
   }
 
-  mScript = JS::InstantiateGlobalStencil(mCx, options, stencil);
+  JS::InstantiateOptions instantiateOptions(options);
+
+  mScript = JS::InstantiateGlobalStencil(mCx, instantiateOptions, stencil);
   if (!mScript) {
     return NS_ERROR_OUT_OF_MEMORY;
   }
@@ -212,12 +214,13 @@ nsresult JSExecutionContext::Decode(mozilla::Vector<uint8_t>& aBytecodeBuf,
 }
 
 bool JSExecutionContext::UpdateDebugMetadata() {
-  if (!mCompileOptions.deferDebugMetadata) {
+  JS::InstantiateOptions options(mCompileOptions);
+
+  if (!options.deferDebugMetadata) {
     return true;
   }
-  return JS::UpdateDebugMetadata(mCx, mScript, mCompileOptions,
-                                 mDebuggerPrivateValue, nullptr,
-                                 mDebuggerIntroductionScript, nullptr);
+  return JS::UpdateDebugMetadata(mCx, mScript, options, mDebuggerPrivateValue,
+                                 nullptr, mDebuggerIntroductionScript, nullptr);
 }
 
 nsresult JSExecutionContext::JoinDecode(JS::OffThreadToken** aOffThreadToken) {

dom/base/nsFrameMessageManager.cpp

@@ -1202,14 +1202,9 @@ void nsMessageManagerScriptExecutor::LoadScriptInternal(
   if (stencil) {
     JS::CompileOptions options(cx);
     FillCompileOptionsForCachedStencil(options);
-
-    if (JS::StencilCanLazilyParse(stencil)) {
-      // See TryCacheLoadAndCompileScript.
-      options.setSourceIsLazy(false);
-    }
-
+    JS::InstantiateOptions instantiateOptions(options);
     JS::Rooted<JSScript*> script(
-        cx, JS::InstantiateGlobalStencil(cx, options, stencil));
+        cx, JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil));
 
     if (script) {
       if (aRunInUniqueScope) {

dom/base/nsJSUtils.cpp

@@ -90,7 +90,8 @@ nsresult nsJSUtils::UpdateFunctionDebugMetadata(
     return NS_OK;
   }
 
-  if (!JS::UpdateDebugMetadata(cx, script, aOptions, aPrivateValue,
+  JS::InstantiateOptions instantiateOptions(aOptions);
+  if (!JS::UpdateDebugMetadata(cx, script, instantiateOptions, aPrivateValue,
                                aElementAttributeName, nullptr, nullptr)) {
     return NS_ERROR_FAILURE;
   }

dom/events/EventListenerManager.cpp

@@ -1051,7 +1051,7 @@ nsresult EventListenerManager::CompileEventHandlerInternal(
   // Use line 0 to make the function body starts from line 1.
   options.setIntroductionType("eventHandler")
       .setFileAndLine(url.get(), 0)
-      .setdeferDebugMetadata(true);
+      .setDeferDebugMetadata(true);
 
   JS::Rooted<JSObject*> handler(cx);
   result = nsJSUtils::CompileFunction(jsapi, scopeChain, options,

dom/script/ScriptLoader.cpp

@@ -687,8 +687,10 @@ nsresult ScriptLoader::CreateModuleScript(ModuleLoadRequest* aRequest) {
     if (module) {
       JS::RootedValue privateValue(cx);
       JS::RootedScript moduleScript(cx, JS::GetModuleScript(module));
-      if (!JS::UpdateDebugMetadata(cx, moduleScript, options, privateValue,
-                                   nullptr, introductionScript, nullptr)) {
+      JS::InstantiateOptions instantiateOptions(options);
+      if (!JS::UpdateDebugMetadata(cx, moduleScript, instantiateOptions,
+                                   privateValue, nullptr, introductionScript,
+                                   nullptr)) {
         return NS_ERROR_OUT_OF_MEMORY;
       }
     }
@@ -2935,10 +2937,10 @@ nsresult ScriptLoader::FillCompileOptionsForRequest(
   }
 
   if (aRequest->IsModuleRequest()) {
-    aOptions->hideScriptFromDebugger = true;
+    aOptions->setHideScriptFromDebugger(true);
   }
 
-  aOptions->setdeferDebugMetadata(true);
+  aOptions->setDeferDebugMetadata(true);
 
   aOptions->borrowBuffer = true;
 

dom/xul/nsXULElement.cpp

@@ -1984,10 +1984,8 @@ nsresult nsXULPrototypeScript::InstantiateScript(
 
   JS::CompileOptions options(aCx);
   FillCompileOptions(options);
-  // We don't need setIntroductionType and setFileAndLine here, unlike
-  // nsXULPrototypeScript::Compile.
-  // mStencil already contains the information.
-  aScript.set(JS::InstantiateGlobalStencil(aCx, options, mStencil));
+  JS::InstantiateOptions instantiateOptions(options);
+  aScript.set(JS::InstantiateGlobalStencil(aCx, instantiateOptions, mStencil));
   if (!aScript) {
     JS_ClearPendingException(aCx);
     return NS_ERROR_OUT_OF_MEMORY;

js/public/CompilationAndEvaluation.h

@@ -13,8 +13,8 @@
 
 #include "jstypes.h"  // JS_PUBLIC_API
 
-#include "js/CompileOptions.h"  // JS::CompileOptions, JS::ReadOnlyCompileOptions
-#include "js/RootingAPI.h"      // JS::Handle, JS::MutableHandle
+#include "js/CompileOptions.h"  // JS::CompileOptions, JS::ReadOnlyCompileOptions, JS::InstantiateOptions
+#include "js/RootingAPI.h"  // JS::Handle, JS::MutableHandle
 #include "js/Value.h"  // JS::Value and specializations of JS::*Handle-related types
 
 struct JS_PUBLIC_API JSContext;
@@ -247,10 +247,9 @@ extern JS_PUBLIC_API void ExposeScriptToDebugger(JSContext* cx,
  * the debug metadata is provided by the UpdateDebugMetadata call.
  */
 extern JS_PUBLIC_API bool UpdateDebugMetadata(
-    JSContext* cx, Handle<JSScript*> script,
-    const ReadOnlyCompileOptions& options, HandleValue privateValue,
-    HandleString elementAttributeName, HandleScript introScript,
-    HandleScript scriptOrModule);
+    JSContext* cx, Handle<JSScript*> script, const InstantiateOptions& options,
+    HandleValue privateValue, HandleString elementAttributeName,
+    HandleScript introScript, HandleScript scriptOrModule);
 
 // The debugger API exposes an optional "element" property on DebuggerSource
 // objects.  The callback defined here provides that value.  SpiderMonkey

js/public/CompileOptions.h

@@ -52,6 +52,7 @@
 #ifndef js_CompileOptions_h
 #define js_CompileOptions_h
 
+#include "mozilla/Assertions.h"       // MOZ_ASSERT
 #include "mozilla/MemoryReporting.h"  // mozilla::MallocSizeOf
 
 #include <stddef.h>  // size_t
@@ -71,6 +72,8 @@ enum class AsmJSOption : uint8_t {
   DisabledByDebugger,
 };
 
+class JS_PUBLIC_API InstantiateOptions;
+
 /**
  * The common base class for the CompileOptions hierarchy.
  *
@@ -114,6 +117,17 @@ class JS_PUBLIC_API TransitiveCompileOptions {
   // See also SetFilenameValidationCallback.
   bool skipFilenameValidation_ = false;
 
+  bool hideScriptFromDebugger_ = false;
+
+  // If set, this script will be hidden from the debugger. The requirement
+  // is that once compilation is finished, a call to UpdateDebugMetadata will
+  // be made, which will update the SSO with the appropiate debug metadata,
+  // and expose the script to the debugger (if hideScriptFromDebugger_ isn't
+  // set)
+  bool deferDebugMetadata_ = false;
+
+  friend class JS_PUBLIC_API InstantiateOptions;
+
  public:
   // POD options.
   bool selfHostingMode = false;
@@ -123,17 +137,6 @@ class JS_PUBLIC_API TransitiveCompileOptions {
   bool discardSource = false;
   bool sourceIsLazy = false;
   bool allowHTMLComments = true;
-  bool hideScriptFromDebugger = false;
-
-  // If set, this script will be hidden from the debugger. The requirement
-  // is that once compilation is finished, a call to UpdateDebugMetadata will
-  // be made, which will update the SSO with the appropiate debug metadata,
-  // and expose the script to the debugger (if hideScriptFromDebugger isn't set)
-  bool deferDebugMetadata = false;
-
-  bool hideFromNewScriptInitial() const {
-    return deferDebugMetadata || hideScriptFromDebugger;
-  }
 
   bool nonSyntacticScope = false;
   bool privateClassFields = false;
@@ -196,7 +199,6 @@ class JS_PUBLIC_API TransitiveCompileOptions {
   bool mutedErrors() const { return mutedErrors_; }
   bool forceFullParse() const { return forceFullParse_; }
   bool forceStrictMode() const { return forceStrictMode_; }
-  bool skipFilenameValidation() const { return skipFilenameValidation_; }
   bool sourcePragmas() const { return sourcePragmas_; }
   const char* filename() const { return filename_; }
   const char* introducerFilename() const { return introducerFilename_; }
@@ -391,8 +393,13 @@ class MOZ_STACK_CLASS JS_PUBLIC_API CompileOptions final
     return *this;
   }
 
-  CompileOptions& setdeferDebugMetadata(bool v = true) {
-    deferDebugMetadata = v;
+  CompileOptions& setDeferDebugMetadata(bool v = true) {
+    deferDebugMetadata_ = v;
+    return *this;
+  }
+
+  CompileOptions& setHideScriptFromDebugger(bool v = true) {
+    hideScriptFromDebugger_ = v;
     return *this;
   }
 
@@ -439,6 +446,45 @@ class MOZ_STACK_CLASS JS_PUBLIC_API CompileOptions final
   CompileOptions& operator=(const CompileOptions& rhs) = delete;
 };
 
+/**
+ * Subset of CompileOptions fields used while instantiating Stencils.
+ */
+class JS_PUBLIC_API InstantiateOptions {
+ public:
+  bool skipFilenameValidation = false;
+  bool hideScriptFromDebugger = false;
+  bool deferDebugMetadata = false;
+
+  InstantiateOptions() = default;
+
+  explicit InstantiateOptions(const ReadOnlyCompileOptions& options)
+      : skipFilenameValidation(options.skipFilenameValidation_),
+        hideScriptFromDebugger(options.hideScriptFromDebugger_),
+        deferDebugMetadata(options.deferDebugMetadata_) {}
+
+  void copyTo(CompileOptions& options) const {
+    options.skipFilenameValidation_ = skipFilenameValidation;
+    options.hideScriptFromDebugger_ = hideScriptFromDebugger;
+    options.deferDebugMetadata_ = deferDebugMetadata;
+  }
+
+  bool hideFromNewScriptInitial() const {
+    return deferDebugMetadata || hideScriptFromDebugger;
+  }
+
+#ifdef DEBUG
+  // Assert that all fields have default value.
+  //
+  // This can be used when instantiation is performed as separate step than
+  // compile-to-stencil, and CompileOptions isn't available there.
+  void assertDefault() const {
+    MOZ_ASSERT(skipFilenameValidation == false);
+    MOZ_ASSERT(hideScriptFromDebugger == false);
+    MOZ_ASSERT(deferDebugMetadata == false);
+  }
+#endif
+};
+
 }  // namespace JS
 
 #endif /* js_CompileOptions_h */

js/public/experimental/JSStencil.h

@@ -81,7 +81,7 @@ extern JS_PUBLIC_API already_AddRefed<Stencil> FinishOffThreadStencil(
 
 // Instantiate the Stencil into current Realm and return the JSScript.
 extern JS_PUBLIC_API JSScript* InstantiateGlobalStencil(
-    JSContext* cx, const ReadOnlyCompileOptions& options, Stencil* stencil);
+    JSContext* cx, const InstantiateOptions& options, Stencil* stencil);
 
 // Return true if the stencil relies on external data as a result of XDR
 // decoding.
@@ -93,7 +93,7 @@ extern JS_PUBLIC_API bool StencilCanLazilyParse(Stencil* stencil);
 // Instantiate a module Stencil and return the associated object. Inside the
 // engine this is a js::ModuleObject.
 extern JS_PUBLIC_API JSObject* InstantiateModuleStencil(
-    JSContext* cx, const ReadOnlyCompileOptions& options, Stencil* stencil);
+    JSContext* cx, const InstantiateOptions& options, Stencil* stencil);
 
 // Serialize the Stencil into the transcode buffer.
 extern JS_PUBLIC_API TranscodeResult

js/src/builtin/Eval.cpp

@@ -301,7 +301,7 @@ static bool EvalKernel(JSContext* cx, HandleValue v, EvalType evalType,
     options.setIsRunOnce(true)
         .setNoScriptRval(false)
         .setMutedErrors(mutedErrors)
-        .setdeferDebugMetadata();
+        .setDeferDebugMetadata();
 
     RootedScript introScript(cx);
 
@@ -342,8 +342,9 @@ static bool EvalKernel(JSContext* cx, HandleValue v, EvalType evalType,
     }
 
     RootedValue undefValue(cx);
-    if (!JS::UpdateDebugMetadata(cx, script, options, undefValue, nullptr,
-                                 introScript, maybeScript)) {
+    JS::InstantiateOptions instantiateOptions(options);
+    if (!JS::UpdateDebugMetadata(cx, script, instantiateOptions, undefValue,
+                                 nullptr, introScript, maybeScript)) {
       return false;
     }
 

js/src/debugger/Source.cpp

@@ -617,7 +617,7 @@ static JSScript* ReparseSource(JSContext* cx, HandleScriptSourceObject sso) {
   ScriptSource* ss = sso->source();
 
   JS::CompileOptions options(cx);
-  options.hideScriptFromDebugger = true;
+  options.setHideScriptFromDebugger(true);
   options.setFileAndLine(ss->filename(), ss->startLine());
 
   UncompressedSourceCache::AutoHoldEntry holder;

js/src/frontend/BytecodeCompilation.h

@@ -9,11 +9,12 @@
 
 #include "mozilla/Utf8.h"  // mozilla::Utf8Unit
 
-#include "js/CompileOptions.h"  // JS::ReadOnlyCompileOptions
-#include "js/SourceText.h"      // JS::SourceText
-#include "js/TypeDecls.h"       // JS::Handle (fwd)
-#include "js/UniquePtr.h"       // js::UniquePtr
-#include "vm/ScopeKind.h"       // js::ScopeKind
+#include "js/CompileOptions.h"  // JS::ReadOnlyCompileOptions, JS::InstantiateOptions
+#include "js/GCVector.h"        // JS::GCVector
+#include "js/SourceText.h"  // JS::SourceText
+#include "js/TypeDecls.h"   // JS::Handle (fwd)
+#include "js/UniquePtr.h"   // js::UniquePtr
+#include "vm/ScopeKind.h"   // js::ScopeKind
 
 namespace js {
 
@@ -83,6 +84,12 @@ inline bool CanLazilyParse(const JS::ReadOnlyCompileOptions& options) {
          !options.forceFullParse();
 }
 
+void FireOnNewScript(JSContext* cx, const JS::InstantiateOptions& options,
+                     JS::Handle<JSScript*> script);
+
+void FireOnNewScripts(JSContext* cx, const JS::InstantiateOptions& options,
+                      JS::Handle<JS::GCVector<JSScript*>> scripts);
+
 }  // namespace frontend
 
 }  // namespace js

js/src/frontend/BytecodeCompiler.cpp

@@ -396,9 +396,8 @@ bool frontend::InstantiateStencils(JSContext* cx, CompilationInput& input,
     }
 
     Rooted<JSScript*> script(cx, gcOutput.script);
-    if (!input.options.hideFromNewScriptInitial()) {
-      DebugAPI::onNewScript(cx, script);
-    }
+    const JS::InstantiateOptions instantiateOptions(input.options);
+    FireOnNewScript(cx, instantiateOptions, script);
   }
 
   return true;
@@ -1220,10 +1219,9 @@ static JSFunction* CompileStandaloneFunction(
 
     MOZ_ASSERT(!cx->isHelperThreadContext());
 
+    const JS::InstantiateOptions instantiateOptions(options);
     Rooted<JSScript*> script(cx, gcOutput.get().script);
-    if (!options.hideFromNewScriptInitial()) {
-      DebugAPI::onNewScript(cx, script);
-    }
+    FireOnNewScript(cx, instantiateOptions, script);
   }
 
   assertException.reset();
@@ -1277,3 +1275,25 @@ JSFunction* frontend::CompileStandaloneFunctionInNonSyntacticScope(
                                    FunctionAsyncKind::SyncFunction,
                                    enclosingScope);
 }
+
+void frontend::FireOnNewScript(JSContext* cx,
+                               const JS::InstantiateOptions& options,
+                               JS::Handle<JSScript*> script) {
+  if (!options.hideFromNewScriptInitial()) {
+    DebugAPI::onNewScript(cx, script);
+  }
+}
+
+void frontend::FireOnNewScripts(JSContext* cx,
+                                const JS::InstantiateOptions& options,
+                                JS::Handle<JS::GCVector<JSScript*>> scripts) {
+  if (!options.hideFromNewScriptInitial()) {
+    JS::Rooted<JSScript*> rootedScript(cx);
+    for (auto& script : scripts) {
+      MOZ_ASSERT(script->isGlobalCode());
+
+      rootedScript = script;
+      DebugAPI::onNewScript(cx, rootedScript);
+    }
+  }
+}

js/src/frontend/CompilationStencil.h

@@ -26,6 +26,7 @@
 #include "frontend/Stencil.h"
 #include "frontend/TaggedParserAtomIndexHasher.h"  // TaggedParserAtomIndexHasher
 #include "frontend/UsedNameTracker.h"
+#include "js/CompileOptions.h"  // JS::ReadOnlyCompileOptions
 #include "js/GCVector.h"
 #include "js/HashTable.h"
 #include "js/RealmOptions.h"

js/src/frontend/Stencil.cpp

@@ -1106,9 +1106,10 @@ static bool InstantiateAtoms(JSContext* cx, CompilationAtomCache& atomCache,
   return InstantiateMarkedAtoms(cx, stencil.parserAtomData, atomCache);
 }
 
-static bool InstantiateScriptSourceObject(
-    JSContext* cx, const JS::ReadOnlyCompileOptions& options,
-    const CompilationStencil& stencil, CompilationGCOutput& gcOutput) {
+static bool InstantiateScriptSourceObject(JSContext* cx,
+                                          const JS::InstantiateOptions& options,
+                                          const CompilationStencil& stencil,
+                                          CompilationGCOutput& gcOutput) {
   MOZ_ASSERT(stencil.source);
 
   gcOutput.sourceObject = ScriptSourceObject::create(cx, stencil.source.get());
@@ -1553,6 +1554,7 @@ bool CompilationStencil::instantiateStencilAfterPreparation(
   MOZ_ASSERT(stencil.isInitialStencil() == input.isInitialStencil());
 
   CompilationAtomCache& atomCache = input.atomCache;
+  const JS::InstantiateOptions options(input.options);
 
   // Phase 1: Instantiate JSAtom/JSStrings.
   if (!InstantiateAtoms(cx, atomCache, stencil)) {
@@ -1561,7 +1563,7 @@ bool CompilationStencil::instantiateStencilAfterPreparation(
 
   // Phase 2: Instantiate ScriptSourceObject, ModuleObject, JSFunctions.
   if (isInitialParse) {
-    if (!InstantiateScriptSourceObject(cx, input.options, stencil, gcOutput)) {
+    if (!InstantiateScriptSourceObject(cx, options, stencil, gcOutput)) {
       return false;
     }
 
@@ -4051,16 +4053,12 @@ already_AddRefed<JS::Stencil> JS::CompileModuleScriptToStencil(
   return CompileModuleScriptToStencilImpl(cx, options, srcBuf);
 }
 
-JSScript* JS::InstantiateGlobalStencil(
-    JSContext* cx, const JS::ReadOnlyCompileOptions& options,
-    JS::Stencil* stencil) {
-  if (stencil->canLazilyParse != CanLazilyParse(options)) {
-    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
-                              JSMSG_STENCIL_OPTIONS_MISMATCH);
-    return nullptr;
-  }
-
-  Rooted<CompilationInput> input(cx, CompilationInput(options));
+JSScript* JS::InstantiateGlobalStencil(JSContext* cx,
+                                       const JS::InstantiateOptions& options,
+                                       JS::Stencil* stencil) {
+  CompileOptions compileOptions(cx);
+  options.copyTo(compileOptions);
+  Rooted<CompilationInput> input(cx, CompilationInput(compileOptions));
   Rooted<CompilationGCOutput> gcOutput(cx);
   if (!InstantiateStencils(cx, input.get(), *stencil, gcOutput.get())) {
     return nullptr;
@@ -4077,19 +4075,14 @@ JS_PUBLIC_API bool JS::StencilCanLazilyParse(Stencil* stencil) {
   return stencil->canLazilyParse;
 }
 
-JSObject* JS::InstantiateModuleStencil(
-    JSContext* cx, const JS::ReadOnlyCompileOptions& optionsInput,
-    JS::Stencil* stencil) {
-  JS::CompileOptions options(cx, optionsInput);
-  options.setModule();
+JSObject* JS::InstantiateModuleStencil(JSContext* cx,
+                                       const JS::InstantiateOptions& options,
+                                       JS::Stencil* stencil) {
+  CompileOptions compileOptions(cx);
+  options.copyTo(compileOptions);
+  compileOptions.setModule();
 
-  if (stencil->canLazilyParse != CanLazilyParse(options)) {
-    JS_ReportErrorNumberASCII(cx, GetErrorMessage, nullptr,
-                              JSMSG_STENCIL_OPTIONS_MISMATCH);
-    return nullptr;
-  }
-
-  Rooted<CompilationInput> input(cx, CompilationInput(options));
+  Rooted<CompilationInput> input(cx, CompilationInput(compileOptions));
   Rooted<CompilationGCOutput> gcOutput(cx);
   if (!InstantiateStencils(cx, input.get(), *stencil, gcOutput.get())) {
     return nullptr;

js/src/jsapi-tests/testStencil.cpp

@@ -48,8 +48,9 @@ bool basic_test(const CharT* chars) {
       JS::CompileGlobalScriptToStencil(cx, options, srcBuf);
   CHECK(stencil);
 
-  JS::RootedScript script(cx,
-                          JS::InstantiateGlobalStencil(cx, options, stencil));
+  JS::InstantiateOptions instantiateOptions(options);
+  JS::RootedScript script(
+      cx, JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil));
   CHECK(script);
 
   JS::RootedValue rval(cx);
@@ -88,8 +89,9 @@ bool basic_test(const CharT* chars) {
       JS::CompileModuleScriptToStencil(cx, options, srcBuf);
   CHECK(stencil);
 
+  JS::InstantiateOptions instantiateOptions(options);
   JS::RootedObject moduleObject(
-      cx, JS::InstantiateModuleStencil(cx, options, stencil));
+      cx, JS::InstantiateModuleStencil(cx, instantiateOptions, stencil));
   CHECK(moduleObject);
 
   // Link and evaluate the module graph. The link step used to be call
@@ -122,8 +124,9 @@ BEGIN_TEST(testStencil_NonSyntactic) {
       JS::CompileGlobalScriptToStencil(cx, options, srcBuf);
   CHECK(stencil);
 
-  JS::RootedScript script(cx,
-                          JS::InstantiateGlobalStencil(cx, options, stencil));
+  JS::InstantiateOptions instantiateOptions(options);
+  JS::RootedScript script(
+      cx, JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil));
   CHECK(script);
 
   JS::RootedObject obj(cx, JS_NewPlainObject(cx));
@@ -178,9 +181,9 @@ bool RunInNewGlobal(JSContext* cx, RefPtr<JS::Stencil> stencil) {
 
   JSAutoRealm ar(cx, otherGlobal);
 
-  JS::CompileOptions options(cx);
-  JS::RootedScript script(cx,
-                          JS::InstantiateGlobalStencil(cx, options, stencil));
+  JS::InstantiateOptions instantiateOptions;
+  JS::RootedScript script(
+      cx, JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil));
   CHECK(script);
 
   JS::RootedValue rval(cx);
@@ -215,8 +218,9 @@ BEGIN_TEST(testStencil_Transcode) {
     CHECK(!buffer.empty());
 
     // Instantiate and Run
-    JS::RootedScript script(cx,
-                            JS::InstantiateGlobalStencil(cx, options, stencil));
+    JS::InstantiateOptions instantiateOptions(options);
+    JS::RootedScript script(
+        cx, JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil));
     JS::RootedValue rval(cx);
     CHECK(script);
     CHECK(JS_ExecuteScript(cx, script, &rval));
@@ -250,8 +254,9 @@ BEGIN_TEST(testStencil_Transcode) {
     buffer.clear();
 
     // Instantiate and Run
-    JS::RootedScript script(cx,
-                            JS::InstantiateGlobalStencil(cx, options, stencil));
+    JS::InstantiateOptions instantiateOptions(options);
+    JS::RootedScript script(
+        cx, JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil));
     stencil = nullptr;
     JS::RootedValue rval(cx);
     CHECK(script);
@@ -301,7 +306,8 @@ BEGIN_TEST(testStencil_TranscodeBorrowing) {
         JS::DecodeStencil(cx, options, range, getter_AddRefs(stencil));
     CHECK(res == JS::TranscodeResult::Ok);
 
-    script = JS::InstantiateGlobalStencil(cx, options, stencil);
+    JS::InstantiateOptions instantiateOptions(options);
+    script = JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil);
     CHECK(script);
   }
 
@@ -350,8 +356,9 @@ BEGIN_TEST(testStencil_OffThread) {
   RefPtr<JS::Stencil> stencil = JS::FinishOffThreadStencil(cx, token);
   CHECK(stencil);
 
-  JS::RootedScript script(cx,
-                          JS::InstantiateGlobalStencil(cx, options, stencil));
+  JS::InstantiateOptions instantiateOptions(options);
+  JS::RootedScript script(
+      cx, JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil));
   CHECK(script);
 
   JS::RootedValue rval(cx);
@@ -399,8 +406,9 @@ BEGIN_TEST(testStencil_OffThreadModule) {
   RefPtr<JS::Stencil> stencil = JS::FinishOffThreadStencil(cx, token);
   CHECK(stencil);
 
+  JS::InstantiateOptions instantiateOptions(options);
   JS::RootedObject moduleObject(
-      cx, JS::InstantiateModuleStencil(cx, options, stencil));
+      cx, JS::InstantiateModuleStencil(cx, instantiateOptions, stencil));
   CHECK(moduleObject);
 
   JS::RootedValue rval(cx);

js/src/jsapi.cpp

@@ -2306,8 +2306,8 @@ void JS::TransitiveCompileOptions::copyPODTransitiveOptions(
   introductionLineno = rhs.introductionLineno;
   introductionOffset = rhs.introductionOffset;
   hasIntroductionInfo = rhs.hasIntroductionInfo;
-  hideScriptFromDebugger = rhs.hideScriptFromDebugger;
-  deferDebugMetadata = rhs.deferDebugMetadata;
+  hideScriptFromDebugger_ = rhs.hideScriptFromDebugger_;
+  deferDebugMetadata_ = rhs.deferDebugMetadata_;
   nonSyntacticScope = rhs.nonSyntacticScope;
   privateClassFields = rhs.privateClassFields;
   privateClassMethods = rhs.privateClassMethods;

js/src/shell/js.cpp

@@ -2298,7 +2298,7 @@ static bool Evaluate(JSContext* cx, unsigned argc, Value* vp) {
 
   options.setIntroductionType("js shell evaluate")
       .setFileAndLine("@evaluate", 1)
-      .setdeferDebugMetadata();
+      .setDeferDebugMetadata();
 
   options.borrowBuffer = true;
 
@@ -2497,7 +2497,8 @@ static bool Evaluate(JSContext* cx, unsigned argc, Value* vp) {
           return false;
         }
 
-        script = JS::InstantiateGlobalStencil(cx, options, stencil);
+        JS::InstantiateOptions instantiateOptions(options);
+        script = JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil);
         if (!script) {
           return false;
         }
@@ -2548,7 +2549,8 @@ static bool Evaluate(JSContext* cx, unsigned argc, Value* vp) {
       }
     }
 
-    if (!JS::UpdateDebugMetadata(cx, script, options, privateValue,
+    JS::InstantiateOptions instantiateOptions(options);
+    if (!JS::UpdateDebugMetadata(cx, script, instantiateOptions, privateValue,
                                  elementAttributeName, nullptr, nullptr)) {
       return false;
     }
@@ -5334,7 +5336,7 @@ static bool Compile(JSContext* cx, unsigned argc, Value* vp) {
       .setFileAndLine("<string>", 1)
       .setIsRunOnce(true)
       .setNoScriptRval(true)
-      .setdeferDebugMetadata();
+      .setDeferDebugMetadata();
   RootedValue privateValue(cx);
   RootedString elementAttributeName(cx);
 
@@ -5365,7 +5367,8 @@ static bool Compile(JSContext* cx, unsigned argc, Value* vp) {
     return false;
   }
 
-  if (!JS::UpdateDebugMetadata(cx, script, options, privateValue,
+  JS::InstantiateOptions instantiateOptions(options);
+  if (!JS::UpdateDebugMetadata(cx, script, instantiateOptions, privateValue,
                                elementAttributeName, nullptr, nullptr)) {
     return false;
   }
@@ -6227,7 +6230,7 @@ static bool OffThreadCompileScript(JSContext* cx, unsigned argc, Value* vp) {
   CompileOptions options(cx);
   options.setIntroductionType("js shell offThreadCompileScript")
       .setFileAndLine("<string>", 1)
-      .setdeferDebugMetadata();
+      .setDeferDebugMetadata();
 
   if (args.length() >= 2) {
     if (args[1].isPrimitive()) {
@@ -6340,8 +6343,10 @@ static bool runOffThreadScript(JSContext* cx, unsigned argc, Value* vp) {
   }
 
   CompileOptions dummyOptions(cx);
-  if (!JS::UpdateDebugMetadata(cx, script, dummyOptions, privateValue,
-                               elementAttributeName, nullptr, nullptr)) {
+  JS::InstantiateOptions dummyInstantiateOptions(dummyOptions);
+  if (!JS::UpdateDebugMetadata(cx, script, dummyInstantiateOptions,
+                               privateValue, elementAttributeName, nullptr,
+                               nullptr)) {
     return false;
   }
 
@@ -6370,7 +6375,7 @@ static bool OffThreadCompileToStencil(JSContext* cx, unsigned argc, Value* vp) {
   CompileOptions options(cx);
   options.setIntroductionType("js shell offThreadCompileToStencil")
       .setFileAndLine("<string>", 1)
-      .setdeferDebugMetadata();
+      .setDeferDebugMetadata();
 
   if (args.length() >= 2) {
     if (args[1].isPrimitive()) {

js/src/vm/CompilationAndEvaluation.cpp

@@ -422,10 +422,9 @@ JS_PUBLIC_API void JS::ExposeScriptToDebugger(JSContext* cx,
 }
 
 JS_PUBLIC_API bool JS::UpdateDebugMetadata(
-    JSContext* cx, Handle<JSScript*> script,
-    const ReadOnlyCompileOptions& options, HandleValue privateValue,
-    HandleString elementAttributeName, HandleScript introScript,
-    HandleScript scriptOrModule) {
+    JSContext* cx, Handle<JSScript*> script, const InstantiateOptions& options,
+    HandleValue privateValue, HandleString elementAttributeName,
+    HandleScript introScript, HandleScript scriptOrModule) {
   RootedScriptSourceObject sso(cx, script->sourceObject());
 
   if (!ScriptSourceObject::initElementProperties(cx, sso,

js/src/vm/HelperThreads.cpp

@@ -13,8 +13,8 @@
 
 #include <algorithm>
 
-#include "frontend/BytecodeCompilation.h"
-#include "frontend/BytecodeCompiler.h"
+#include "frontend/BytecodeCompilation.h"  // frontend::{CompileGlobalScriptToExtensibleStencil, FireOnNewScript, FireOnNewScripts}
+#include "frontend/BytecodeCompiler.h"  // frontend::ParseModuleToExtensibleStencil
 #include "frontend/CompilationStencil.h"  // frontend::{CompilationStencil, ExtensibleCompilationStencil, CompilationInput, CompilationGCOutput, BorrowingCompilationStencil}
 #include "frontend/ParserAtom.h"          // frontend::ParserAtomsTable
 #include "gc/GC.h"                        // gc::MergeRealms
@@ -2066,7 +2066,8 @@ UniquePtr<ParseTask> GlobalHelperThreadState::finishParseTaskCommon(
     for (auto& sourceObject : parseTask->sourceObjects) {
       RootedScriptSourceObject sso(cx, sourceObject);
 
-      if (!ScriptSourceObject::initFromOptions(cx, sso, parseTask->options)) {
+      const JS::InstantiateOptions instantiateOptions(parseTask->options);
+      if (!ScriptSourceObject::initFromOptions(cx, sso, instantiateOptions)) {
         return nullptr;
       }
 
@@ -2191,9 +2192,8 @@ JSScript* GlobalHelperThreadState::finishSingleParseTask(
 
     // The Debugger only needs to be told about the topmost script that was
     // compiled.
-    if (!parseTask->options.hideFromNewScriptInitial()) {
-      DebugAPI::onNewScript(cx, script);
-    }
+    const JS::InstantiateOptions instantiateOptions(parseTask->options);
+    frontend::FireOnNewScript(cx, instantiateOptions, script);
   } else {
     MOZ_ASSERT(parseTask->stencil_.get() ||
                parseTask->extensibleStencil_.get());

js/src/vm/JSFunction.cpp

@@ -1526,7 +1526,7 @@ static bool CreateDynamicFunction(JSContext* cx, const CallArgs& args,
       .setNoScriptRval(false)
       .setIntroductionInfo(introducerFilename, introductionType, lineno,
                            pcOffset)
-      .setdeferDebugMetadata();
+      .setDeferDebugMetadata();
 
   JSStringBuilder sb(cx);
 
@@ -1663,8 +1663,10 @@ static bool CreateDynamicFunction(JSContext* cx, const CallArgs& args,
 
   RootedValue undefValue(cx);
   RootedScript funScript(cx, JS_GetFunctionScript(cx, fun));
-  if (funScript && !UpdateDebugMetadata(cx, funScript, options, undefValue,
-                                        nullptr, maybeScript, maybeScript)) {
+  JS::InstantiateOptions instantiateOptions(options);
+  if (funScript &&
+      !UpdateDebugMetadata(cx, funScript, instantiateOptions, undefValue,
+                           nullptr, maybeScript, maybeScript)) {
     return false;
   }
 

js/src/vm/JSScript.cpp

@@ -31,6 +31,7 @@
 #include "jsapi.h"
 #include "jstypes.h"
 
+#include "frontend/BytecodeCompilation.h"  // frontend::FireOnNewScript
 #include "frontend/BytecodeCompiler.h"
 #include "frontend/BytecodeEmitter.h"
 #include "frontend/CompilationStencil.h"  // frontend::CompilationStencil
@@ -770,7 +771,7 @@ ScriptSourceObject* ScriptSourceObject::create(JSContext* cx,
 
 [[nodiscard]] static bool MaybeValidateFilename(
     JSContext* cx, HandleScriptSourceObject sso,
-    const ReadOnlyCompileOptions& options) {
+    const JS::InstantiateOptions& options) {
   // When parsing off-thread we want to do filename validation on the main
   // thread. This makes off-thread parsing more pure and is simpler because we
   // can't easily throw exceptions off-thread.
@@ -781,7 +782,7 @@ ScriptSourceObject* ScriptSourceObject::create(JSContext* cx,
   }
 
   const char* filename = sso->source()->filename();
-  if (!filename || options.skipFilenameValidation()) {
+  if (!filename || options.skipFilenameValidation) {
     return true;
   }
 
@@ -803,7 +804,7 @@ ScriptSourceObject* ScriptSourceObject::create(JSContext* cx,
 /* static */
 bool ScriptSourceObject::initFromOptions(
     JSContext* cx, HandleScriptSourceObject source,
-    const ReadOnlyCompileOptions& options) {
+    const JS::InstantiateOptions& options) {
   cx->releaseCheck(source);
   MOZ_ASSERT(
       source->getReservedSlot(ELEMENT_PROPERTY_SLOT).isMagic(JS_GENERIC_MAGIC));

js/src/vm/JSScript.h

@@ -1084,7 +1084,7 @@ class ScriptSourceObject : public NativeObject {
   // Initialize those properties of this ScriptSourceObject whose values
   // are provided by |options|, re-wrapping as necessary.
   static bool initFromOptions(JSContext* cx, HandleScriptSourceObject source,
-                              const JS::ReadOnlyCompileOptions& options);
+                              const JS::InstantiateOptions& options);
 
   static bool initElementProperties(JSContext* cx,
                                     HandleScriptSourceObject source,

js/src/vm/SelfHosting.cpp

@@ -2823,7 +2823,9 @@ ScriptSourceObject* GlobalObject::getOrCreateSelfHostingScriptSourceObject(
     return nullptr;
   }
 
-  if (!ScriptSourceObject::initFromOptions(cx, sourceObject, options)) {
+  JS::InstantiateOptions instantiateOptions(options);
+  if (!ScriptSourceObject::initFromOptions(cx, sourceObject,
+                                           instantiateOptions)) {
     return nullptr;
   }
 

js/xpconnect/loader/ChromeScriptLoader.cpp

@@ -290,10 +290,13 @@ PrecompiledScript::PrecompiledScript(nsISupports* aParent,
     : mParent(aParent),
       mStencil(aStencil),
       mURL(aOptions.filename()),
-      mHasReturnValue(!aOptions.noScriptRval),
-      mLazilyParse(!aOptions.forceFullParse()) {
+      mHasReturnValue(!aOptions.noScriptRval) {
   MOZ_ASSERT(aParent);
   MOZ_ASSERT(aStencil);
+#ifdef DEBUG
+  JS::InstantiateOptions options(aOptions);
+  options.assertDefault();
+#endif
 };
 
 void PrecompiledScript::ExecuteInGlobal(JSContext* aCx, HandleObject aGlobal,
@@ -303,13 +306,8 @@ void PrecompiledScript::ExecuteInGlobal(JSContext* aCx, HandleObject aGlobal,
     RootedObject targetObj(aCx, JS_FindCompilationScope(aCx, aGlobal));
     JSAutoRealm ar(aCx, targetObj);
 
-    CompileOptions options(aCx);
-    if (!mLazilyParse) {
-      // See AsyncScriptCompiler::Start.
-      options.setForceFullParse();
-    }
-    // mHasReturnValue (noScriptRval) is unused during instantiation.
-
+    // See assertion in constructor.
+    JS::InstantiateOptions options;
     Rooted<JSScript*> script(
         aCx, JS::InstantiateGlobalStencil(aCx, options, mStencil));
     if (!script) {

js/xpconnect/loader/PrecompiledScript.h

@@ -54,7 +54,6 @@ class PrecompiledScript : public nsISupports, public nsWrapperCache {
   RefPtr<JS::Stencil> mStencil;
   nsCString mURL;
   const bool mHasReturnValue;
-  const bool mLazilyParse;
 };
 
 }  // namespace dom

js/xpconnect/loader/mozJSComponentLoader.cpp

@@ -819,7 +819,9 @@ nsresult mozJSComponentLoader::ObjectForLocation(
     }
   }
 
-  RootedScript script(cx, JS::InstantiateGlobalStencil(cx, options, stencil));
+  JS::InstantiateOptions instantiateOptions(options);
+  RootedScript script(
+      cx, JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil));
   if (!script) {
     // Propagate the exception, if one exists. Also, don't leave the stale
     // exception on this context.

js/xpconnect/loader/mozJSSubScriptLoader.cpp

@@ -131,8 +131,9 @@ static bool EvalStencil(JSContext* cx, HandleObject targetObj,
                         JS::Stencil* stencil) {
   MOZ_ASSERT(!js::IsWrapper(targetObj));
 
-  JS::RootedScript script(cx,
-                          JS::InstantiateGlobalStencil(cx, options, stencil));
+  JS::InstantiateOptions instantiateOptions(options);
+  JS::RootedScript script(
+      cx, JS::InstantiateGlobalStencil(cx, instantiateOptions, stencil));
   if (!script) {
     return false;
   }