vm: import call should return a promise in the current context

A `import` call should returns a promise created in the context where
the `import` was called, not the context of `importModuleDynamically`
callback.

Author: legendecas

src/module_wrap.cc

@@ -1020,16 +1020,21 @@ static MaybeLocal<Promise> ImportModuleDynamicallyWithPhase(
   };
 
   Local<Value> result;
-  if (import_callback->Call(
-        context,
-        Undefined(isolate),
-        arraysize(import_args),
-        import_args).ToLocal(&result)) {
-    CHECK(result->IsPromise());
-    return handle_scope.Escape(result.As<Promise>());
+  if (!import_callback
+           ->Call(
+               context, Undefined(isolate), arraysize(import_args), import_args)
+           .ToLocal(&result)) {
+    return {};
   }
 
-  return MaybeLocal<Promise>();
+  // Wrap the returned value in a promise created in the referrer context to avoid
+  // dynamic scopes.
+  Local<Promise::Resolver> resolver;
+  if (!Promise::Resolver::New(context).ToLocal(&resolver)) {
+    return {};
+  }
+
+  return handle_scope.Escape(resolver->GetPromise());
 }
 
 static MaybeLocal<Promise> ImportModuleDynamically(

test/parallel/test-vm-module-dynamic-import-promise.js

@@ -0,0 +1,67 @@
+// Flags: --experimental-vm-modules
+'use strict';
+
+const common = require('../common');
+
+const assert = require('assert');
+const { createContext, Script, SourceTextModule } = require('vm');
+
+// Verifies that a `import` call returns a promise created in the context
+// where the `import` was called, not the context of `importModuleDynamically`
+// callback.
+
+async function testScript() {
+  const ctx = createContext();
+
+  const mod1 = new SourceTextModule('export const a = 1;', {
+    context: ctx,
+  });
+  // No import statements, so must not link statically.
+  await mod1.link(common.mustNotCall());
+
+  const script2 = new Script(`
+    const promise = import("mod1");
+    if (Object.getPrototypeOf(promise) !== Promise.prototype) {
+      throw new Error('Expected promise to be a Promise');
+    }
+  `, {
+    importModuleDynamically: common.mustCall((specifier, referrer) => {
+      assert.strictEqual(specifier, 'mod1');
+      assert.strictEqual(referrer, script2);
+      return mod1;
+    }),
+  });
+  script2.runInContext(ctx);
+}
+
+async function testModule() {
+  const ctx = createContext();
+
+  const mod1 = new SourceTextModule('export const a = 1;', {
+    context: ctx,
+  });
+  // No import statements, so must not link statically.
+  await mod1.link(common.mustNotCall());
+
+  const mod2 = new SourceTextModule(`
+    const promise = import("mod1");
+    if (Object.getPrototypeOf(promise) !== Promise.prototype) {
+      throw new Error('Expected promise to be a Promise');
+    }
+  `, {
+    context: ctx,
+    importModuleDynamically: common.mustCall((specifier, referrer) => {
+      assert.strictEqual(specifier, 'mod1');
+      assert.strictEqual(referrer, mod2);
+      return mod1;
+    }),
+  });
+  // No import statements, so must not link statically.
+  await mod2.link(common.mustNotCall());
+  await mod2.evaluate();
+}
+
+Promise.all([
+  testScript(),
+  testModule(),
+]).then(common.mustCall());