From a4ab0b53e2c683eb2b6b6e332066a57cfadfa1c6 Mon Sep 17 00:00:00 2001
From: legendecas <legendecas@gmail.com>
Date: Tue, 27 Sep 2022 00:55:59 +0800
Subject: [PATCH] src,lib: retrieve parsed source map url from v8

V8 already parses the source map magic comments. Currently only scripts
and functions exposes the parsed source map urls. It is unnecessary to
parse the source map magic comments again when the parsed information is
available.
---
 doc/api/vm.md                               |  23 ++++
 lib/internal/modules/cjs/loader.js          |  20 +++-
 lib/internal/source_map/source_map_cache.js |  31 ++++--
 lib/internal/vm.js                          | 113 ++++++++++++++++++++
 lib/vm.js                                   |  92 +---------------
 src/env_properties.h                        |   1 +
 src/node_contextify.cc                      |  24 +++--
 test/parallel/test-bootstrap-modules.js     |   1 +
 8 files changed, 195 insertions(+), 110 deletions(-)
 create mode 100644 lib/internal/vm.js

diff --git a/doc/api/vm.md b/doc/api/vm.md
index f99f4966db82b6..c79f8bc104a579 100644
--- a/doc/api/vm.md
+++ b/doc/api/vm.md
@@ -344,6 +344,29 @@ console.log(globalVar);
 // 1000
 ```
 
+### `script.sourceMapURL`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {string|undefined}
+
+When the script is compiled from a source that contains a source map magic
+comment, this property will be set to the URL of the source map.
+
+```js
+const vm = require('node:vm');
+
+const script = new vm.Script(`
+function myFunc() {}
+//# sourceMappingURL=sourcemap.json
+`);
+
+console.log(script.sourceMapURL);
+// Prints: sourcemap.json
+```
+
 ## Class: `vm.Module`
 
 <!-- YAML
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 68edd781e33a3e..219f3844b1ed7a 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -86,7 +86,8 @@ const {
   filterOwnProperties,
   setOwnProperty,
 } = require('internal/util');
-const vm = require('vm');
+const { Script } = require('vm');
+const { internalCompileFunction } = require('internal/vm');
 const assert = require('internal/assert');
 const fs = require('fs');
 const internalFS = require('internal/fs/utils');
@@ -1073,19 +1074,25 @@ let hasPausedEntry = false;
 function wrapSafe(filename, content, cjsModuleInstance) {
   if (patched) {
     const wrapper = Module.wrap(content);
-    return vm.runInThisContext(wrapper, {
+    const script = new Script(wrapper, {
       filename,
       lineOffset: 0,
-      displayErrors: true,
       importModuleDynamically: async (specifier, _, importAssertions) => {
         const loader = asyncESM.esmLoader;
         return loader.import(specifier, normalizeReferrerURL(filename),
                              importAssertions);
       },
     });
+
+    maybeCacheSourceMap(filename, content, this, false, undefined, script.sourceMapURL);
+
+    return script.runInThisContext({
+      displayErrors: true,
+    });
   }
+
   try {
-    return vm.compileFunction(content, [
+    const result = internalCompileFunction(content, [
       'exports',
       'require',
       'module',
@@ -1099,6 +1106,10 @@ function wrapSafe(filename, content, cjsModuleInstance) {
                              importAssertions);
       },
     });
+
+    maybeCacheSourceMap(filename, content, this, false, undefined, result.sourceMapURL);
+
+    return result.function;
   } catch (err) {
     if (process.mainModule === cjsModuleInstance)
       enrichCJSError(err, content);
@@ -1119,7 +1130,6 @@ Module.prototype._compile = function(content, filename) {
     policy.manifest.assertIntegrity(moduleURL, content);
   }
 
-  maybeCacheSourceMap(filename, content, this);
   const compiledWrapper = wrapSafe(filename, content, this);
 
   let inspectorWrapper = null;
diff --git a/lib/internal/source_map/source_map_cache.js b/lib/internal/source_map/source_map_cache.js
index ee8de441ba9316..ab077b67b22eeb 100644
--- a/lib/internal/source_map/source_map_cache.js
+++ b/lib/internal/source_map/source_map_cache.js
@@ -97,7 +97,21 @@ function extractSourceURLMagicComment(content) {
   return sourceURL;
 }
 
-function maybeCacheSourceMap(filename, content, cjsModuleInstance, isGeneratedSource, sourceURL) {
+function extractSourceMapURLMagicComment(content) {
+  let match;
+  let lastMatch;
+  // A while loop is used here to get the last occurrence of sourceMappingURL.
+  // This is needed so that we don't match sourceMappingURL in string literals.
+  while ((match = RegExpPrototypeExec(kSourceMappingURLMagicComment, content))) {
+    lastMatch = match;
+  }
+  if (lastMatch == null) {
+    return null;
+  }
+  return lastMatch.groups.sourceMappingURL;
+}
+
+function maybeCacheSourceMap(filename, content, cjsModuleInstance, isGeneratedSource, sourceURL, sourceMapURL) {
   const sourceMapsEnabled = getSourceMapsEnabled();
   if (!(process.env.NODE_V8_COVERAGE || sourceMapsEnabled)) return;
   try {
@@ -108,20 +122,17 @@ function maybeCacheSourceMap(filename, content, cjsModuleInstance, isGeneratedSo
     return;
   }
 
-  let match;
-  let lastMatch;
-  // A while loop is used here to get the last occurrence of sourceMappingURL.
-  // This is needed so that we don't match sourceMappingURL in string literals.
-  while ((match = RegExpPrototypeExec(kSourceMappingURLMagicComment, content))) {
-    lastMatch = match;
+  if (sourceMapURL === undefined) {
+    sourceMapURL = extractSourceMapURLMagicComment(content);
   }
 
   if (sourceURL === undefined) {
     sourceURL = extractSourceURLMagicComment(content);
   }
-  if (lastMatch) {
-    const data = dataFromUrl(filename, lastMatch.groups.sourceMappingURL);
-    const url = data ? null : lastMatch.groups.sourceMappingURL;
+
+  if (sourceMapURL) {
+    const data = dataFromUrl(filename, sourceMapURL);
+    const url = data ? null : sourceMapURL;
     if (cjsModuleInstance) {
       cjsSourceMapCache.set(cjsModuleInstance, {
         filename,
diff --git a/lib/internal/vm.js b/lib/internal/vm.js
new file mode 100644
index 00000000000000..7164fcd6ab2b77
--- /dev/null
+++ b/lib/internal/vm.js
@@ -0,0 +1,113 @@
+'use strict';
+
+const {
+  ArrayPrototypeForEach,
+} = primordials;
+
+const {
+  compileFunction,
+  isContext: _isContext,
+} = internalBinding('contextify');
+const {
+  validateArray,
+  validateBoolean,
+  validateBuffer,
+  validateFunction,
+  validateObject,
+  validateString,
+  validateUint32,
+} = require('internal/validators');
+const {
+  ERR_INVALID_ARG_TYPE,
+} = require('internal/errors').codes;
+
+function isContext(object) {
+  validateObject(object, 'object', { allowArray: true });
+
+  return _isContext(object);
+}
+
+function internalCompileFunction(code, params, options) {
+  validateString(code, 'code');
+  if (params !== undefined) {
+    validateArray(params, 'params');
+    ArrayPrototypeForEach(params,
+                          (param, i) => validateString(param, `params[${i}]`));
+  }
+
+  const {
+    filename = '',
+    columnOffset = 0,
+    lineOffset = 0,
+    cachedData = undefined,
+    produceCachedData = false,
+    parsingContext = undefined,
+    contextExtensions = [],
+    importModuleDynamically,
+  } = options;
+
+  validateString(filename, 'options.filename');
+  validateUint32(columnOffset, 'options.columnOffset');
+  validateUint32(lineOffset, 'options.lineOffset');
+  if (cachedData !== undefined)
+    validateBuffer(cachedData, 'options.cachedData');
+  validateBoolean(produceCachedData, 'options.produceCachedData');
+  if (parsingContext !== undefined) {
+    if (
+      typeof parsingContext !== 'object' ||
+      parsingContext === null ||
+      !isContext(parsingContext)
+    ) {
+      throw new ERR_INVALID_ARG_TYPE(
+        'options.parsingContext',
+        'Context',
+        parsingContext
+      );
+    }
+  }
+  validateArray(contextExtensions, 'options.contextExtensions');
+  ArrayPrototypeForEach(contextExtensions, (extension, i) => {
+    const name = `options.contextExtensions[${i}]`;
+    validateObject(extension, name, { nullable: true });
+  });
+
+  const result = compileFunction(
+    code,
+    filename,
+    lineOffset,
+    columnOffset,
+    cachedData,
+    produceCachedData,
+    parsingContext,
+    contextExtensions,
+    params
+  );
+
+  if (produceCachedData) {
+    result.function.cachedDataProduced = result.cachedDataProduced;
+  }
+
+  if (result.cachedData) {
+    result.function.cachedData = result.cachedData;
+  }
+
+  if (importModuleDynamically !== undefined) {
+    validateFunction(importModuleDynamically,
+                     'options.importModuleDynamically');
+    const { importModuleDynamicallyWrap } =
+      require('internal/vm/module');
+    const { callbackMap } = internalBinding('module_wrap');
+    const wrapped = importModuleDynamicallyWrap(importModuleDynamically);
+    const func = result.function;
+    callbackMap.set(result.cacheKey, {
+      importModuleDynamically: (s, _k, i) => wrapped(s, func, i),
+    });
+  }
+
+  return result;
+}
+
+module.exports = {
+  internalCompileFunction,
+  isContext,
+};
diff --git a/lib/vm.js b/lib/vm.js
index 1bb199363afbe1..ec91c8a2651775 100644
--- a/lib/vm.js
+++ b/lib/vm.js
@@ -32,9 +32,7 @@ const {
   ContextifyScript,
   MicrotaskQueue,
   makeContext,
-  isContext: _isContext,
   constants,
-  compileFunction: _compileFunction,
   measureMemory: _measureMemory,
 } = internalBinding('contextify');
 const {
@@ -45,9 +43,7 @@ const {
   isArrayBufferView,
 } = require('internal/util/types');
 const {
-  validateArray,
   validateBoolean,
-  validateBuffer,
   validateFunction,
   validateInt32,
   validateObject,
@@ -60,6 +56,10 @@ const {
   kEmptyObject,
   kVmBreakFirstLineSymbol,
 } = require('internal/util');
+const {
+  internalCompileFunction,
+  isContext,
+} = require('internal/vm');
 const kParsingContext = Symbol('script parsing context');
 
 class Script extends ContextifyScript {
@@ -213,12 +213,6 @@ function getContextOptions(options) {
   return contextOptions;
 }
 
-function isContext(object) {
-  validateObject(object, 'object', { allowArray: true });
-
-  return _isContext(object);
-}
-
 let defaultContextNameIndex = 1;
 function createContext(contextObject = {}, options = kEmptyObject) {
   if (isContext(contextObject)) {
@@ -314,83 +308,7 @@ function runInThisContext(code, options) {
 }
 
 function compileFunction(code, params, options = kEmptyObject) {
-  validateString(code, 'code');
-  if (params !== undefined) {
-    validateArray(params, 'params');
-    ArrayPrototypeForEach(params,
-                          (param, i) => validateString(param, `params[${i}]`));
-  }
-
-  const {
-    filename = '',
-    columnOffset = 0,
-    lineOffset = 0,
-    cachedData = undefined,
-    produceCachedData = false,
-    parsingContext = undefined,
-    contextExtensions = [],
-    importModuleDynamically,
-  } = options;
-
-  validateString(filename, 'options.filename');
-  validateUint32(columnOffset, 'options.columnOffset');
-  validateUint32(lineOffset, 'options.lineOffset');
-  if (cachedData !== undefined)
-    validateBuffer(cachedData, 'options.cachedData');
-  validateBoolean(produceCachedData, 'options.produceCachedData');
-  if (parsingContext !== undefined) {
-    if (
-      typeof parsingContext !== 'object' ||
-      parsingContext === null ||
-      !isContext(parsingContext)
-    ) {
-      throw new ERR_INVALID_ARG_TYPE(
-        'options.parsingContext',
-        'Context',
-        parsingContext
-      );
-    }
-  }
-  validateArray(contextExtensions, 'options.contextExtensions');
-  ArrayPrototypeForEach(contextExtensions, (extension, i) => {
-    const name = `options.contextExtensions[${i}]`;
-    validateObject(extension, name, { nullable: true });
-  });
-
-  const result = _compileFunction(
-    code,
-    filename,
-    lineOffset,
-    columnOffset,
-    cachedData,
-    produceCachedData,
-    parsingContext,
-    contextExtensions,
-    params
-  );
-
-  if (produceCachedData) {
-    result.function.cachedDataProduced = result.cachedDataProduced;
-  }
-
-  if (result.cachedData) {
-    result.function.cachedData = result.cachedData;
-  }
-
-  if (importModuleDynamically !== undefined) {
-    validateFunction(importModuleDynamically,
-                     'options.importModuleDynamically');
-    const { importModuleDynamicallyWrap } =
-      require('internal/vm/module');
-    const { callbackMap } = internalBinding('module_wrap');
-    const wrapped = importModuleDynamicallyWrap(importModuleDynamically);
-    const func = result.function;
-    callbackMap.set(result.cacheKey, {
-      importModuleDynamically: (s, _k, i) => wrapped(s, func, i),
-    });
-  }
-
-  return result.function;
+  return internalCompileFunction(code, params, options).function;
 }
 
 const measureMemoryModes = {
diff --git a/src/env_properties.h b/src/env_properties.h
index e650e4926fb3df..1da21f97902b3b 100644
--- a/src/env_properties.h
+++ b/src/env_properties.h
@@ -276,6 +276,7 @@
   V(sni_context_err_string, "Invalid SNI context")                             \
   V(sni_context_string, "sni_context")                                         \
   V(source_string, "source")                                                   \
+  V(source_map_url_string, "sourceMapURL")                                     \
   V(stack_string, "stack")                                                     \
   V(standard_name_string, "standardName")                                      \
   V(start_time_string, "startTime")                                            \
diff --git a/src/node_contextify.cc b/src/node_contextify.cc
index c2cfe5071d0094..ec2a5baad553d7 100644
--- a/src/node_contextify.cc
+++ b/src/node_contextify.cc
@@ -814,12 +814,11 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
   ShouldNotAbortOnUncaughtScope no_abort_scope(env);
   Context::Scope scope(parsing_context);
 
-  MaybeLocal<UnboundScript> v8_script = ScriptCompiler::CompileUnboundScript(
-      isolate,
-      &source,
-      compile_options);
+  MaybeLocal<UnboundScript> maybe_v8_script =
+      ScriptCompiler::CompileUnboundScript(isolate, &source, compile_options);
 
-  if (v8_script.IsEmpty()) {
+  Local<UnboundScript> v8_script;
+  if (!maybe_v8_script.ToLocal(&v8_script)) {
     errors::DecorateErrorStack(env, try_catch);
     no_abort_scope.Close();
     if (!try_catch.HasTerminated())
@@ -828,7 +827,7 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
                      "ContextifyScript::New");
     return;
   }
-  contextify_script->script_.Reset(isolate, v8_script.ToLocalChecked());
+  contextify_script->script_.Reset(isolate, v8_script);
 
   Local<Context> env_context = env->context();
   if (compile_options == ScriptCompiler::kConsumeCodeCache) {
@@ -837,8 +836,8 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
         env->cached_data_rejected_string(),
         Boolean::New(isolate, source.GetCachedData()->rejected)).Check();
   } else if (produce_cached_data) {
-    std::unique_ptr<ScriptCompiler::CachedData> cached_data {
-      ScriptCompiler::CreateCodeCache(v8_script.ToLocalChecked()) };
+    std::unique_ptr<ScriptCompiler::CachedData> cached_data{
+        ScriptCompiler::CreateCodeCache(v8_script)};
     bool cached_data_produced = cached_data != nullptr;
     if (cached_data_produced) {
       MaybeLocal<Object> buf = Buffer::Copy(
@@ -854,6 +853,13 @@ void ContextifyScript::New(const FunctionCallbackInfo<Value>& args) {
         env->cached_data_produced_string(),
         Boolean::New(isolate, cached_data_produced)).Check();
   }
+
+  args.This()
+      ->Set(env_context,
+            env->source_map_url_string(),
+            v8_script->GetSourceMappingURL())
+      .Check();
+
   TRACE_EVENT_END0(TRACING_CATEGORY_NODE2(vm, script), "ContextifyScript::New");
 }
 
@@ -1201,6 +1207,8 @@ void ContextifyContext::CompileFunction(
   if (result->Set(parsing_context, env->cache_key_string(), cache_key)
           .IsNothing())
     return;
+  if (result->Set(parsing_context, env->source_map_url_string(), fn->GetScriptOrigin().SourceMapUrl()).IsNothing())
+    return;
 
   if (produce_cached_data) {
     const std::unique_ptr<ScriptCompiler::CachedData> cached_data(
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index 88a43b51473ff2..ece194bf87920f 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -144,6 +144,7 @@ const expectedModules = new Set([
   'NativeModule internal/util/parse_args/parse_args',
   'NativeModule internal/util/types',
   'NativeModule internal/validators',
+  'NativeModule internal/vm',
   'NativeModule internal/vm/module',
   'NativeModule internal/wasm_web_api',
   'NativeModule internal/webstreams/adapters',