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

@@ -37,7 +37,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');
 
 const kCoverageFileRegex = /^coverage-(\d+)-(\d{13})-(\d+)\.json$/;
@@ -86,6 +86,8 @@ class TestCoverage {
   #sourceLines = new SafeMap();
   #typeScriptLines = new SafeSet();
   #skipCache = new SafeMap();
+  #excludeMatchers = null;
+  #includeMatchers = null;
 
   getLines(fileUrl, source) {
     // Split the file source into lines. Make sure the lines maintain their
@@ -550,28 +552,27 @@ class TestCoverage {
 
     const absolutePath = fileURLToPath(url);
     const relativePath = 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 (let i = 0; i < excludeGlobs.length; ++i) {
-        if (
-          matchGlobPattern(relativePath, excludeGlobs[i]) ||
-          matchGlobPattern(absolutePath, excludeGlobs[i])
-        ) return true;
-      }
+    for (let i = 0; i < this.#excludeMatchers.length; ++i) {
+      const matcher = this.#excludeMatchers[i];
+      if (matcher.match(relativePath) || matcher.match(absolutePath)) return true;
     }
 
     // This check filters out files that do not match the include globs.
-    if (includeGlobs?.length > 0) {
-      for (let i = 0; i < includeGlobs.length; ++i) {
-        if (
-          matchGlobPattern(relativePath, includeGlobs[i]) ||
-          matchGlobPattern(absolutePath, includeGlobs[i])
-        ) return false;
+    if (this.#includeMatchers.length > 0) {
+      for (let i = 0; i < this.#includeMatchers.length; ++i) {
+        const matcher = this.#includeMatchers[i];
+        if (matcher.match(relativePath) || matcher.match(absolutePath)) return false;
       }
       return true;
     }