module: use file: URL as sourceURL for type-stripped CommonJS

The CommonJS loader was passing the bare filesystem path as the
`//# sourceURL` comment of type-stripped TypeScript, this leads to
two problems:
1. It reports hasSourceURL = false if the path contains any
whitespaces as this breaks V8's magic comment parser.
2. The inspector would incorrectly report a file path verbatim as
the script's URL.
Pass the module's file: URL as the sourceURL so the reported URL
is consistent across loaders and won't lead to an issue in
inspector clients that actually except a real URL for the
scripts.
Signed-off-by: Joyee Cheung <joyeec9h3@gmail.com>
PR-URL: #63705
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Marco Ippolito <marcoippolito54@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>

Author: joyeecheung

lib/internal/modules/cjs/loader.js

@@ -1822,7 +1822,8 @@ function wrapSafe(filename, content, cjsModuleInstance, format) {
  */
 Module.prototype._compile=function(content,filename,format){
 if(format==='commonjs-typescript'||format==='module-typescript'||format==='typescript'){
-content=stripTypeScriptModuleTypes(content,filename);
+this[kURL]??=convertCJSFilenameToURL(filename);
+content=stripTypeScriptModuleTypes(content,filename,this[kURL]);
 switch(format){
 case'commonjs-typescript': {
 format='commonjs';

lib/internal/modules/typescript.js

@@ -175,9 +175,10 @@ function getCachedCodeType(mode, sourceMap) {
  * It is used by internal loaders.
  * @param {string} source TypeScript code to parse.
  * @param {string} filename The filename of the source code.
+ * @param {string} [sourceURL] The source URL of the source code. If not specified, use filename.
  * @returns {TransformOutput} The stripped TypeScript code.
  */
-functionstripTypeScriptModuleTypes(source,filename){
+functionstripTypeScriptModuleTypes(source,filename,sourceURL){
 assert(typeofsource==='string');
 if(isUnderNodeModules(filename)){
 thrownewERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename);
@@ -203,7 +204,7 @@ function stripTypeScriptModuleTypes(source, filename) {
 constoptions={
  mode,
  sourceMap,
- filename,
+filename: sourceURL??filename,
 };
 
 consttranspiled=processTypeScriptCode(source,options);

test/parallel/test-inspector-strip-types.js

@@ -1,23 +1,61 @@
+// Verifies that type-stripped TypeScript reports a file: URL as its script
+// sourceURL to the inspector across all module loading paths, hinting that it
+// is a generated source.
 'use strict';
 
 constcommon=require('../common');
+const{ describe, it }=require('node:test');
 common.skipIfInspectorDisabled();
 if(!process.config.variables.node_use_amaro)common.skip('Requires Amaro');
 
 const{ NodeInstance }=require('../common/inspector-helper.js');
 constfixtures=require('../common/fixtures');
 constassert=require('assert');
-const{ pathToFileURL }=require('url');
 
-constscriptPath=fixtures.path('typescript/ts/test-typescript.ts');
-constscriptURL=pathToFileURL(scriptPath);
-
-asyncfunctionrunTest(){
-constchild=newNodeInstance(
-['--inspect-brk=0'],
-undefined,
-scriptPath);
+constscenarios=[
+{
+// CommonJS: a .ts entry point.
+entry: 'typescript/ts/test-typescript.ts',
+expected: [
+fixtures.fileURL('typescript/ts/test-typescript.ts').href,
+],
+},
+{
+// CommonJS: a .ts entry that require()s a .cts dependency.
+entry: 'typescript/ts/test-require-cts.ts',
+expected: [
+fixtures.fileURL('typescript/ts/test-require-cts.ts').href,
+fixtures.fileURL('typescript/cts/test-cts-export-foo.cts').href,
+],
+},
+{
+// CommonJS: a .ts entry that require()s a .mts dependency.
+entry: 'typescript/ts/test-require-mts.ts',
+expected: [
+fixtures.fileURL('typescript/ts/test-require-mts.ts').href,
+fixtures.fileURL('typescript/mts/test-mts-export-foo.mts').href,
+],
+},
+{
+// ESM: a .mts entry that imports a .ts dependency.
+entry: 'typescript/mts/test-import-ts-file.mts',
+expected: [
+fixtures.fileURL('typescript/mts/test-import-ts-file.mts').href,
+fixtures.fileURL('typescript/mts/test-module-export.ts').href,
+],
+},
+{
+// ESM: a .mts entry that imports a .cts dependency.
+entry: 'typescript/mts/test-import-commonjs.mts',
+expected: [
+fixtures.fileURL('typescript/mts/test-import-commonjs.mts').href,
+fixtures.fileURL('typescript/cts/test-cts-export-foo.cts').href,
+],
+},
+];
 
+asyncfunctioncollectParsedScripts(scriptPath){
+constchild=newNodeInstance(['--inspect-brk=0'],undefined,scriptPath);
 constsession=awaitchild.connectInspectorSession();
 
 awaitsession.send({method: 'NodeRuntime.enable'});
@@ -29,18 +67,39 @@ async function runTest() {
 ]);
 awaitsession.send({method: 'NodeRuntime.disable'});
 
-constscriptParsed=awaitsession.waitForNotification((notification)=>{
-if(notification.method!=='Debugger.scriptParsed')returnfalse;
-
-returnnotification.params.url===scriptPath||notification.params.url===scriptURL.href;
+// Collect every parsed script while resuming through the break on start and
+// any later pauses, until the main execution context is destroyed.
+constscripts=newMap();
+awaitsession.waitForNotification((notification)=>{
+if(notification.method==='Debugger.scriptParsed'){
+const{ url }=notification.params;
+if(!url.startsWith('node:')){
+scripts.set(url,notification.params);
+}
+}
+if(notification.method==='Debugger.paused'){
+session.send({method: 'Debugger.resume'});
+}
+returnnotification.method==='Runtime.executionContextDestroyed'&&
+notification.params.executionContextId===1;
 });
-// Verify that the script has a sourceURL, hinting that it is a generated source.
-assert(scriptParsed.params.hasSourceURL||common.isInsideDirWithUnusualChars);
-
-awaitsession.waitForPauseOnStart();
-awaitsession.runToCompletion();
+awaitsession.waitForDisconnect();
 
 assert.strictEqual((awaitchild.expectShutdown()).exitCode,0);
+returnscripts;
 }
 
-runTest().then(common.mustCall());
+describe('type stripping source URLs',{concurrency: !process.env.TEST_PARALLEL},()=>{
+for(const{ entry, expected }ofscenarios){
+it(entry,async()=>{
+constscripts=awaitcollectParsedScripts(fixtures.path(entry));
+for(consthrefofexpected){
+constparams=scripts.get(href);
+assert(params,
+`expected ${entry} to report ${href} to the inspector, `+
+`got:\n- ${[...scripts.keys()].join('\n- ')}`);
+assert(params.hasSourceURL);
+}
+});
+}
+});