vm: "afterEvaluate", make module.evaluate() return a promise from the outer context

Consider the default context A with a microtask queue QA, and a
context B with its own microtask queue QB.

Context B is constructed with vm.createContext(..., {microtaskMode:
"afterEvaluate"}). The evaluation in context B can be performed via
vm.Script or vm.SourceTextModule.

The standard (https://tc39.es/ecma262/#sec-newpromiseresolvethenablejob)
dictates that, when resolving a {promise} with {resolution}, from any
context, the {then} method on {promise} should be called within a task
enqueued on the microtask queue from the context associated with {then}.

Specifically, after evaluating a script or module in context B, any
promises created within B, if later resolved within A, will result in a
task to be enqueued back onto QB, even long after we are done evaluating
any code within B.

This creates a challenge for users of node:vm in "afterEvaluate" mode.
In ContextifyScript::EvalMachine() and in ModuleWrap::Evaluate(), we
only drain the microtask queue QB a single time after running the script
or evaluating the module. After that point, the queue will not be
drained unless another script or module is evaluated in the same
context.

In the following scenario, prior to this patch, the log statement will
not be printed:

	const microtaskMode = "afterEvaluate";
	const context = vm.createContext({}, {microtaskMode});
	const source = "";
	const module = new vm.SourceTextModule(source, {context});
	await module.link(() => null);
	await module.evaluate();
	console.log("NOT PRINTED");

To resolve the promise returned by evaluate(), which technically is the
top-level capability for {module}, a promise created within B, V8 will
enqueue a task on QB. But since this is after the PerformCheckpoint()
call in ModuleWrap::Evaluate(), the task in QB is never run. In the
meantime, since QA is empty, the Node process simply exits (with a
warning about the unsettled promise, if it happened to be a top-level
await).

While being unable to do `await module.evaluate()` is clearly a problem,
more generally, it is intended that in "afterEvaluate" mode, promises
created in the inner context cannot make progress if, and until, the
microtask queue of the inner context is checkpointed.

Therefore, to address this issue, the fix is narrow:

When the module has its own microtask queue, i.e. in "afterEvaluate"
mode, the inner-context promise returned by
v8::SourceTextModule::Evaluate() is first resolved to an outer-context
promise, then we checkpoint the microtask queue of the inner context,
then we return the outer-context promise we just built.

This ensures that in the statement `await module.evaluate()`, the
promise returned by `evaluate()` can be resolved within the outer
context, without involving the microtask queue in the inner context.

Fixes: #59541
Refs: https://issues.chromium.org/issues/441679231
Refs: https://groups.google.com/g/v8-dev/c/YIeRg8CUNS8/m/rEQdFuNZAAAJ

Author: ericrannaud

src/module_wrap.cc

@@ -735,8 +735,48 @@ void ModuleWrap::Evaluate(const FunctionCallbackInfo<Value>& args) {
   MaybeLocal<Value> result;
   auto run = [&]() {
     MaybeLocal<Value> result = module->Evaluate(context);
-    if (!result.IsEmpty() && microtask_queue)
+
+    Local<Value> res;
+    if (result.ToLocal(&res) && microtask_queue) {
+      DCHECK(res->IsPromise());
+
+      // To address https://github.com/nodejs/node/issues/59541 when the
+      // module has its own separate microtask queue in microtaskMode
+      // "afterEvaluate", we avoid returning a promise built inside the
+      // module's own context.
+      //
+      // Instead, we build a promise in the outer context, which we resolve
+      // with {result}, then we checkpoint the module's own queue, and finally
+      // we return the outer-context promise.
+      //
+      // If we simply returned the inner promise {result} directly, per
+      // https://tc39.es/ecma262/#sec-newpromiseresolvethenablejob the outer
+      // context, when resolving a promise coming from a different context,
+      // would need to enqueue a task (known as a thenable job task) onto the
+      // queue of that different context (the module's context). But this queue
+      // will normally not be checkpointed after evaluate() returns.
+      //
+      // This means that the execution flow in the outer context would
+      // silently fall through at the statement:
+      //   await module.evaluate();
+      //
+      // This is true for any promises created inside the module's context
+      // and made available to the outer context, as the node:vm doc explains.
+      //
+      // We must handle this particular return value differently to make it
+      // possible to await on the result of evaluate().
+      Local<Context> outer_context = isolate->GetCurrentContext();
+      Local<Promise::Resolver> resolver;
+      if (!Promise::Resolver::New(outer_context).ToLocal(&resolver)) {
+        return MaybeLocal<Value>();
+      }
+      if (resolver->Resolve(outer_context, res).IsNothing()) {
+        return MaybeLocal<Value>();
+      }
+      result = resolver->GetPromise();
+
       microtask_queue->PerformCheckpoint(isolate);
+    }
     return result;
   };
   if (break_on_sigint && timeout != -1) {

test/parallel/test-vm-module-after-evaluate.js

@@ -14,7 +14,7 @@ const microtaskMode = 'afterEvaluate';
 
 (async () => {
   const mustNotCall1 = common.mustNotCall();
-  const mustNotCall2 = common.mustNotCall();
+  const mustCall1 = common.mustCall();
 
   const inner = {};
 
@@ -28,7 +28,6 @@ const microtaskMode = 'afterEvaluate';
   await module.link(mustNotCall1);
   await module.evaluate();
 
-  // This is Issue 59541, the next statement is not executed, of course
-  // it should be.
-  mustNotCall2();
+  // Prior to the fix for Issue 59541, the next statement was never executed.
+  mustCall1();
 })().then(common.mustNotCall());