test_runner: avoid recompiling coverage globs for every file

`shouldSkipFileCoverage()` called `matchGlobPattern()` for each covered
file, and `matchGlobPattern()` builds a fresh Minimatch (a full glob
parse and regexp compile) on every call. The coverage exclude/include
globs never change during a run, so the same patterns were recompiled
once per file, which dominated the coverage report time.
Compile `coverageExcludeGlobs`/`coverageIncludeGlobs` to matchers once
per `TestCoverage` instance and reuse them for every file. Expose
`createMatcher()` from `internal/fs/glob` for this.
On a synthetic 200-test-file project this drops shouldSkipFileCoverage
from ~117ms to ~11ms (cpu-prof, isolation=none); the saving scales with
files * globs.
Refs: #55103
Signed-off-by: sangwook <rewq5991@gmail.com>
PR-URL: #63675
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Moshe Atlow <moshe@atlow.co.il>
Reviewed-By: Chemi Atlow <chemi@atlow.co.il>

Author: Han5991

lib/internal/fs/glob.js

@@ -947,5 +947,6 @@ function matchGlobPattern(path, pattern, windows = isWindows) {
 module.exports={
 __proto__: null,
  Glob,
+ createMatcher,
  matchGlobPattern,
 };

lib/internal/test_runner/coverage.js

@@ -38,7 +38,7 @@ const {
 ERR_SOURCE_MAP_MISSING_SOURCE,
 },
 }=require('internal/errors');
-const{matchGlobPattern}=require('internal/fs/glob');
+const{createMatcher}=require('internal/fs/glob');
 const{constants: { kMockSearchParam }}=require('internal/test_runner/mock/loader');
 
 constkCoverageFileRegex=/^coverage-(\d+)-(\d{13})-(\d+)\.json$/;
@@ -87,6 +87,8 @@ class TestCoverage {
  #sourceLines =newSafeMap();
  #typeScriptLines =newSafeSet();
  #skipCache =newSafeMap();
+ #excludeMatchers =null;
+ #includeMatchers =null;
 
 getLines(fileUrl,source){
 // Split the file source into lines. Make sure the lines maintain their
@@ -551,28 +553,27 @@ class TestCoverage {
 
 constabsolutePath=fileURLToPath(url);
 constrelativePath=relative(this.options.cwd,absolutePath);
-const{
-coverageExcludeGlobs: excludeGlobs,
-coverageIncludeGlobs: includeGlobs,
-}=this.options;
+// The exclude/include globs are fixed for the lifetime of this
+// TestCoverage instance, so compile each glob to a matcher once and reuse
+// it for every file. Building a fresh Minimatch per call (the previous
+// behavior) dominated the coverage report time, scaling with
+// files * globs.
+this.#excludeMatchers ??=ArrayPrototypeMap(
+this.options.coverageExcludeGlobs??[],(pattern)=>createMatcher(pattern));
+this.#includeMatchers ??=ArrayPrototypeMap(
+this.options.coverageIncludeGlobs??[],(pattern)=>createMatcher(pattern));
 
 // This check filters out files that match the exclude globs.
-if(excludeGlobs?.length>0){
-for(leti=0;i<excludeGlobs.length;++i){
-if(
-matchGlobPattern(relativePath,excludeGlobs[i])||
-matchGlobPattern(absolutePath,excludeGlobs[i])
-)returntrue;
-}
+for(leti=0;i<this.#excludeMatchers.length;++i){
+constmatcher=this.#excludeMatchers[i];
+if(matcher.match(relativePath)||matcher.match(absolutePath))returntrue;
 }
 
 // This check filters out files that do not match the include globs.
-if(includeGlobs?.length>0){
-for(leti=0;i<includeGlobs.length;++i){
-if(
-matchGlobPattern(relativePath,includeGlobs[i])||
-matchGlobPattern(absolutePath,includeGlobs[i])
-)returnfalse;
+if(this.#includeMatchers.length>0){
+for(leti=0;i<this.#includeMatchers.length;++i){
+constmatcher=this.#includeMatchers[i];
+if(matcher.match(relativePath)||matcher.match(absolutePath))returnfalse;
 }
 returntrue;
 }