Bug 1658631 - Part 2: Add frontend::ParseModuleToStencil. r=tcampbell

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

js/public/CompileOptions.h

@@ -434,6 +434,14 @@ class MOZ_STACK_CLASS JS_PUBLIC_API CompileOptions final
     return *this;
   }
 
+  CompileOptions& setModule() {
+    // ES6 10.2.1 Module code is always strict mode code.
+    setForceStrictMode();
+    setIsRunOnce(true);
+    allowHTMLComments = false;
+    return *this;
+  }
+
   CompileOptions(const CompileOptions& rhs) = delete;
   CompileOptions& operator=(const CompileOptions& rhs) = delete;
 };

js/src/frontend/BytecodeCompiler.cpp

@@ -372,7 +372,7 @@ class MOZ_STACK_CLASS frontend::ModuleCompiler final
       : Base(cx, allocScope, options, sourceBuffer, enclosingScope,
              enclosingEnv) {}
 
-  bool compile(CompilationInfo& compilationInfo, CompilationGCOutput& gcOutput);
+  bool compile(CompilationInfo& compilationInfo);
 };
 
 template <typename Unit>
@@ -612,8 +612,7 @@ bool frontend::ScriptCompiler<Unit>::compileScriptToStencil(
 }
 
 template <typename Unit>
-bool frontend::ModuleCompiler<Unit>::compile(CompilationInfo& compilationInfo,
-                                             CompilationGCOutput& gcOutput) {
+bool frontend::ModuleCompiler<Unit>::compile(CompilationInfo& compilationInfo) {
   if (!createSourceAndParser(compilationInfo)) {
     return false;
   }
@@ -653,20 +652,6 @@ bool frontend::ModuleCompiler<Unit>::compile(CompilationInfo& compilationInfo,
 
   builder.finishFunctionDecls(moduleMetadata);
 
-  if (!compilationInfo.instantiateStencils(gcOutput)) {
-    return false;
-  }
-
-  MOZ_ASSERT(gcOutput.script);
-  MOZ_ASSERT(gcOutput.module);
-
-  // Enqueue an off-thread source compression task after finishing parsing.
-  if (!cx->isHelperThreadContext()) {
-    if (!compilationInfo.input.source()->tryCompressOffThread(cx)) {
-      return false;
-    }
-  }
-
   MOZ_ASSERT_IF(!cx->isHelperThreadContext(), !cx->isExceptionPending());
   return true;
 }
@@ -769,65 +754,59 @@ bool frontend::StandaloneFunctionCompiler<Unit>::compile(
 }
 
 template <typename Unit>
-static bool InternalParseModule(JSContext* cx,
-                                const ReadOnlyCompileOptions& optionsInput,
-                                SourceText<Unit>& srcBuf,
-                                CompilationGCOutput& gcOutput) {
+static bool InternalParseModuleToStencil(CompilationInfo& compilationInfo,
+                                         SourceText<Unit>& srcBuf) {
+  JSContext* cx = compilationInfo.cx;
+
   MOZ_ASSERT(srcBuf.get());
 
   AutoAssertReportedException assertException(cx);
 
-  CompileOptions options(cx, optionsInput);
-  options.setForceStrictMode();  // ES6 10.2.1 Module code is always strict mode
-                                 // code.
-  options.setIsRunOnce(true);
-  options.allowHTMLComments = false;
-
-  Rooted<CompilationInfo> compilationInfo(cx, CompilationInfo(cx, options));
-  if (!compilationInfo.get().input.initForModule(cx)) {
-    return false;
-  }
-
   LifoAllocScope allocScope(&cx->tempLifoAlloc());
-  ModuleCompiler<Unit> compiler(cx, allocScope,
-                                compilationInfo.get().input.options, srcBuf);
-  if (!compiler.compile(compilationInfo.get(), gcOutput)) {
+  ModuleCompiler<Unit> compiler(cx, allocScope, compilationInfo.input.options,
+                                srcBuf);
+  if (!compiler.compile(compilationInfo)) {
     return false;
   }
 
-  tellDebuggerAboutCompiledScript(cx, options.hideScriptFromDebugger,
-                                  gcOutput.script);
-
   assertException.reset();
   return true;
 }
 
-bool frontend::ParseModule(JSContext* cx,
-                           const ReadOnlyCompileOptions& optionsInput,
-                           SourceText<char16_t>& srcBuf,
-                           CompilationGCOutput& gcOutput) {
-  return InternalParseModule(cx, optionsInput, srcBuf, gcOutput);
+bool frontend::ParseModuleToStencil(CompilationInfo& compilationInfo,
+                                    SourceText<char16_t>& srcBuf) {
+  return InternalParseModuleToStencil(compilationInfo, srcBuf);
 }
 
-bool frontend::ParseModule(JSContext* cx,
-                           const ReadOnlyCompileOptions& optionsInput,
-                           SourceText<Utf8Unit>& srcBuf,
-                           CompilationGCOutput& gcOutput) {
-  return InternalParseModule(cx, optionsInput, srcBuf, gcOutput);
+bool frontend::ParseModuleToStencil(CompilationInfo& compilationInfo,
+                                    SourceText<Utf8Unit>& srcBuf) {
+  return InternalParseModuleToStencil(compilationInfo, srcBuf);
 }
 
 template <typename Unit>
-static ModuleObject* CreateModule(JSContext* cx,
-                                  const JS::ReadOnlyCompileOptions& options,
-                                  SourceText<Unit>& srcBuf) {
+static ModuleObject* CreateModule(
+    JSContext* cx, const JS::ReadOnlyCompileOptions& optionsInput,
+    SourceText<Unit>& srcBuf) {
   AutoAssertReportedException assertException(cx);
 
   if (!GlobalObject::ensureModulePrototypesCreated(cx, cx->global())) {
     return nullptr;
   }
 
+  CompileOptions options(cx, optionsInput);
+  options.setModule();
+
+  Rooted<CompilationInfo> compilationInfo(cx, CompilationInfo(cx, options));
+  if (!compilationInfo.get().input.initForModule(cx)) {
+    return nullptr;
+  }
+
+  if (!ParseModuleToStencil(compilationInfo.get(), srcBuf)) {
+    return nullptr;
+  }
+
   CompilationGCOutput gcOutput(cx);
-  if (!ParseModule(cx, options, srcBuf, gcOutput)) {
+  if (!InstantiateStencils(compilationInfo.get(), gcOutput)) {
     return nullptr;
   }
 

js/src/frontend/BytecodeCompiler.h

@@ -104,6 +104,7 @@ class ScriptSourceObject;
 
 namespace frontend {
 
+struct CompilationInfo;
 struct CompilationGCOutput;
 class ErrorReporter;
 class FunctionBox;
@@ -120,12 +121,10 @@ ModuleObject* CompileModule(JSContext* cx,
 
 // Parse a module of the given source.  This is an internal API; if you want to
 // compile a module as a user, use CompileModule above.
-bool ParseModule(JSContext* cx, const JS::ReadOnlyCompileOptions& options,
-                 JS::SourceText<char16_t>& srcBuf,
-                 CompilationGCOutput& gcOutput);
-bool ParseModule(JSContext* cx, const JS::ReadOnlyCompileOptions& options,
-                 JS::SourceText<mozilla::Utf8Unit>& srcBuf,
-                 CompilationGCOutput& gcOutput);
+bool ParseModuleToStencil(CompilationInfo& compilationInfo,
+                          JS::SourceText<char16_t>& srcBuf);
+bool ParseModuleToStencil(CompilationInfo& compilationInfo,
+                          JS::SourceText<mozilla::Utf8Unit>& srcBuf);
 
 //
 // Compile a single function. The source in srcBuf must match the ECMA-262

js/src/shell/js.cpp

@@ -4939,6 +4939,7 @@ static bool ParseModule(JSContext* cx, unsigned argc, Value* vp) {
   } else {
     options.setFileAndLine("<string>", 1);
   }
+  options.setModule();
 
   AutoStableStringChars stableChars(cx);
   if (!stableChars.initTwoByte(cx, scriptContents)) {

js/src/vm/HelperThreads.cpp

@@ -657,8 +657,21 @@ template <typename Unit>
 void ModuleParseTask<Unit>::parse(JSContext* cx) {
   MOZ_ASSERT(cx->isHelperThreadContext());
 
+  CompileOptions moduleOptions(cx, options);
+  moduleOptions.setModule();
+
+  Rooted<frontend::CompilationInfo> compilationInfo(
+      cx, frontend::CompilationInfo(cx, moduleOptions));
+  if (!compilationInfo.get().input.initForModule(cx)) {
+    return;
+  }
+
+  if (!frontend::ParseModuleToStencil(compilationInfo.get(), data)) {
+    return;
+  }
+
   frontend::CompilationGCOutput gcOutput(cx);
-  bool result = frontend::ParseModule(cx, options, data, gcOutput);
+  bool result = frontend::InstantiateStencils(compilationInfo.get(), gcOutput);
 
   // Whatever happens to the top-level script compilation (even if it fails),
   // we must finish initializing the SSO.  This is because there may be valid
@@ -672,9 +685,9 @@ void ModuleParseTask<Unit>::parse(JSContext* cx) {
     return;
   }
 
-  if (gcOutput.module) {
-    scripts.infallibleAppend(gcOutput.module->script());
-  }
+  MOZ_ASSERT(gcOutput.module);
+  MOZ_ASSERT(gcOutput.module->script());
+  scripts.infallibleAppend(gcOutput.module->script());
 }
 
 ScriptDecodeTask::ScriptDecodeTask(JSContext* cx,