test_runner: ignore erased TS lines in coverage

Fixes: #54753
Signed-off-by: Matteo Collina <matteo.collina@gmail.com>
PR-URL: #63510
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>
Reviewed-By: Pietro Marchini <pietro.marchini94@gmail.com>

Author: mcollina

lib/internal/modules/typescript.js

@@ -170,6 +170,11 @@ function getCachedCodeType(mode, sourceMap) {
 returnkStrippedTypeScript;
 }
 
+functionstripTypeScriptTypesForCoverage(code){
+validateString(code,'code');
+returnprocessTypeScriptCode(code,{mode: 'strip-only'});
+}
+
 /**
  * Performs type-stripping to TypeScript source code internally.
  * It is used by internal loaders.
@@ -236,4 +241,5 @@ function addSourceMap(code, sourceMap) {
 module.exports={
  stripTypeScriptModuleTypes,
  stripTypeScriptTypes,
+ stripTypeScriptTypesForCoverage,
 };

lib/internal/test_runner/coverage.js

@@ -16,6 +16,7 @@ const {
  StringPrototypeIncludes,
  StringPrototypeLocaleCompare,
  StringPrototypeStartsWith,
+ StringPrototypeTrim,
 }=primordials;
 const{
  copyFileSync,
@@ -45,6 +46,20 @@ const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 constkLineEndingRegex=/\r?\n$/u;
 constkLineSplitRegex=/(?<=\r?\n)/u;
 constkStatusRegex=/\/\*node:coverage(?<status>enable|disable)\*\//;
+constkTypeOnlyImportRegex=/^\s*import\s+type\b/u;
+constkTypeScriptSourceRegex=/\.(?:cts|mts|ts)$/u;
+
+letstripTypeScriptTypesForCoverage;
+
+functiongetStripTypeScriptTypesForCoverage(){
+if(!process.config.variables.node_use_amaro){
+return;
+}
+
+stripTypeScriptTypesForCoverage??=
+require('internal/modules/typescript').stripTypeScriptTypesForCoverage;
+returnstripTypeScriptTypesForCoverage;
+}
 
 classCoverageLine{
 constructor(line,startOffset,src,length=src?.length){
@@ -70,6 +85,7 @@ class TestCoverage {
 }
 
  #sourceLines =newSafeMap();
+ #typeScriptLines =newSafeSet();
 
 getLines(fileUrl,source){
 // Split the file source into lines. Make sure the lines maintain their
@@ -134,6 +150,57 @@ class TestCoverage {
 returnlines;
 }
 
+markTypeScriptOnlyLines(fileUrl,source){
+if(this.#typeScriptLines.has(fileUrl)){
+return;
+}
+this.#typeScriptLines.add(fileUrl);
+
+if(RegExpPrototypeExec(kTypeScriptSourceRegex,fileUrl)===null){
+return;
+}
+
+constlines=this.getLines(fileUrl,source);
+if(!lines){
+return;
+}
+
+letstrippedLines;
+conststripSource=getStripTypeScriptTypesForCoverage();
+
+if(stripSource){
+source??=readFileSync(fileURLToPath(fileUrl),'utf8');
+
+try{
+strippedLines=RegExpPrototypeSymbolSplit(
+kLineSplitRegex,
+stripSource(source),
+);
+}catch{
+strippedLines=undefined;
+}
+}
+
+for(leti=0;i<lines.length;++i){
+constoriginalLine=lines[i].src;
+
+if(StringPrototypeTrim(originalLine).length===0){
+continue;
+}
+
+if(strippedLines?.[i]!==undefined){
+if(StringPrototypeTrim(strippedLines[i]).length===0){
+lines[i].ignore=true;
+}
+continue;
+}
+
+if(RegExpPrototypeExec(kTypeOnlyImportRegex,originalLine)!==null){
+lines[i].ignore=true;
+}
+}
+}
+
 summary(){
 internalBinding('profiler').takeCoverage();
 constcoverage=this.getCoverageFromDirectory();
@@ -369,10 +436,12 @@ class TestCoverage {
 offset+=length+1;
 returncoverageLine;
 });
-if(data.sourcesContent!=null){
-for(letj=0;j<data.sources.length;++j){
-this.getLines(data.sources[j],data.sourcesContent[j]);
+for(letj=0;j<data.sources.length;++j){
+constsource=data.sourcesContent?.[j];
+if(source!=null){
+this.getLines(data.sources[j],source);
 }
+this.markTypeScriptOnlyLines(data.sources[j],source);
 }
 constsourceMap=newSourceMap(data,{__proto__: null, lineLengths });
 

test/fixtures/test-runner/source-maps/type-only-import/dist/a.mjs

@@ -0,0 +1,3 @@
+console.log('Hi');
+export{};
+//# sourceMappingURL=a.mjs.map

test/fixtures/test-runner/source-maps/type-only-import/dist/a.mjs.map

@@ -0,0 +1,3 @@
+importtype{}from'node:assert';
+
+console.log('Hi');

test/fixtures/test-runner/source-maps/type-only-import/src/a.mts

@@ -0,0 +1 @@
+import'./dist/a.mjs';

test/fixtures/test-runner/source-maps/type-only-import/test.mjs

@@ -73,6 +73,31 @@ describe('Coverage with source maps', async () => {
 t.assert.strictEqual(spawned.code,1);
 });
 
+awaitit('should ignore erased TypeScript import type lines',async(t)=>{
+constreport=generateReport([
+'# ----------------------------------------------------------',
+'# file | line % | branch % | funcs % | uncovered lines',
+'# ----------------------------------------------------------',
+'# src | | | | ',
+'# a.mts | 100.00 | 100.00 | 100.00 | ',
+'# test.mjs | 100.00 | 100.00 | 100.00 | ',
+'# ----------------------------------------------------------',
+'# all files | 100.00 | 100.00 | 100.00 | ',
+'# ----------------------------------------------------------',
+]);
+
+constspawned=awaitcommon.spawnPromisified(process.execPath,[
+ ...flags,
+'test.mjs',
+],{
+cwd: fixtures.path('test-runner','source-maps','type-only-import'),
+});
+
+t.assert.strictEqual(spawned.stderr,'');
+t.assert.ok(spawned.stdout.includes(report));
+t.assert.strictEqual(spawned.code,0);
+});
+
 awaitit('properly accounts for line endings in source maps',async(t)=>{
 constreport=generateReport([
 '# ------------------------------------------------------------------',