fix: address review feedback on statement coverage

- Replace hardcoded kStatementTypes array with acorn-walk's generic
  "Statement" category visitor, which automatically covers all current
  and future ESTree statement types (including ClassDeclaration,
  FunctionDeclaration, and StaticBlock that were previously missing).
  BlockStatement and EmptyStatement are excluded via a small deny-set.

- Simplify AST parsing to a single pass using sourceType: 'script'
  with permissive flags (allowReturnOutsideFunction,
  allowImportExportEverywhere, allowAwaitOutsideFunction). Script mode
  is non-strict, so it handles both ESM and legacy CJS (e.g. `with`
  statements) without needing a module→script fallback.

- Flatten V8 coverage ranges before the statement matching loop,
  reducing nesting from three levels to two.

- Add coverage-class.js fixture and test for ClassDeclaration and
  StaticBlock statement coverage.

Author: Felipeness

lib/internal/test_runner/coverage.js

@@ -43,14 +43,11 @@ const { Parser: AcornParser } =
 const { simple: acornWalkSimple } =
   require('internal/deps/acorn/acorn-walk/dist/walk');
 
-const kStatementTypes = [
-  'ExpressionStatement', 'ReturnStatement', 'ThrowStatement',
-  'IfStatement', 'WhileStatement', 'DoWhileStatement',
-  'ForStatement', 'ForInStatement', 'ForOfStatement',
-  'SwitchStatement', 'TryStatement', 'BreakStatement',
-  'ContinueStatement', 'VariableDeclaration', 'LabeledStatement',
-  'WithStatement', 'DebuggerStatement',
-];
+// Statement types excluded from coverage: containers (BlockStatement)
+// and empty statements that carry no executable semantics.
+const kExcludedStatementTypes = new SafeSet([
+  'BlockStatement', 'EmptyStatement',
+]);
 
 const kCoverageFileRegex = /^coverage-(\d+)-(\d{13})-(\d+)\.json$/;
 const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
@@ -98,47 +95,37 @@ class TestCoverage {
 
     const statements = [];
 
-    // Build a visitor with one handler per concrete statement type.
-    // acorn-walk does not fire a generic "Statement" visitor for concrete
-    // node types, so each type must be registered individually.
+    // acorn-walk's simple() fires a generic "Statement" visitor for every
+    // node dispatched in a statement position (Program body, block bodies,
+    // if/for/while bodies, etc.). This automatically covers all current and
+    // future ESTree statement types without hardcoding a list.
     const visitor = { __proto__: null };
-    const handler = (node) => {
+    visitor.Statement = (node) => {
+      if (kExcludedStatementTypes.has(node.type)) return;
       ArrayPrototypePush(statements, {
         __proto__: null,
         startOffset: node.start,
         endOffset: node.end,
         count: 0,
       });
     };
-    for (let i = 0; i < kStatementTypes.length; ++i) {
-      visitor[kStatementTypes[i]] = handler;
-    }
 
-    // Try parsing as a module first, fall back to script for files that
-    // use CommonJS syntax incompatible with module mode.
+    // Parse as script with permissive flags — script mode is non-strict,
+    // so it handles legacy CJS (e.g. `with` statements) while the
+    // allow* flags enable ESM syntax (import/export/top-level await).
     let ast;
     try {
       ast = AcornParser.parse(source, {
         __proto__: null,
         ecmaVersion: 'latest',
-        sourceType: 'module',
+        sourceType: 'script',
         allowReturnOutsideFunction: true,
         allowImportExportEverywhere: true,
         allowAwaitOutsideFunction: true,
       });
     } catch {
-      try {
-        ast = AcornParser.parse(source, {
-          __proto__: null,
-          ecmaVersion: 'latest',
-          sourceType: 'script',
-          allowReturnOutsideFunction: true,
-          allowAwaitOutsideFunction: true,
-        });
-      } catch {
-        this.#sourceStatements.set(fileUrl, null);
-        return null;
-      }
+      this.#sourceStatements.set(fileUrl, null);
+      return null;
     }
 
     acornWalkSimple(ast, visitor);
@@ -341,28 +328,34 @@ class TestCoverage {
       const statementReports = [];
 
       if (statements) {
+        // Flatten all V8 coverage ranges into a single array so
+        // the statement loop only needs two levels of iteration.
+        const allRanges = [];
+        for (let fi = 0; fi < functions.length; ++fi) {
+          const { ranges } = functions[fi];
+          for (let ri = 0; ri < ranges.length; ++ri) {
+            ArrayPrototypePush(allRanges, ranges[ri]);
+          }
+        }
+
         for (let j = 0; j < statements.length; ++j) {
           const stmt = statements[j];
           let bestCount = 0;
-          let bestRange = null;
-
-          for (let fi = 0; fi < functions.length; ++fi) {
-            const { ranges } = functions[fi];
-            for (let ri = 0; ri < ranges.length; ++ri) {
-              const range = ranges[ri];
-              if (range.startOffset <= stmt.startOffset &&
-                  range.endOffset >= stmt.endOffset) {
-                const size = range.endOffset - range.startOffset;
-                if (bestRange === null ||
-                    size < (bestRange.endOffset - bestRange.startOffset)) {
-                  bestCount = range.count;
-                  bestRange = range;
-                }
+          let bestSize = Infinity;
+
+          for (let ri = 0; ri < allRanges.length; ++ri) {
+            const range = allRanges[ri];
+            if (range.startOffset <= stmt.startOffset &&
+                range.endOffset >= stmt.endOffset) {
+              const size = range.endOffset - range.startOffset;
+              if (size < bestSize) {
+                bestCount = range.count;
+                bestSize = size;
               }
             }
           }
 
-          stmt.count = bestRange !== null ? bestCount : 0;
+          stmt.count = bestSize !== Infinity ? bestCount : 0;
 
           const stmtLine = findLineForOffset(stmt.startOffset, lines);
           const isIgnored = stmtLine != null && stmtLine.ignore;

test/fixtures/test-runner/coverage-class.js

@@ -0,0 +1,38 @@
+'use strict';
+const test = require('node:test');
+
+class Animal {
+  constructor(name) {
+    this.name = name;
+  }
+
+  speak() {
+    return `${this.name} makes a sound`;
+  }
+
+  static create(name) {
+    return new Animal(name);
+  }
+}
+
+class Dog extends Animal {
+  static {
+    Dog.species = 'Canis familiaris';
+  }
+
+  speak() {
+    return `${this.name} barks`;
+  }
+}
+
+// This class is never instantiated — its body should be uncovered.
+class UnusedClass {
+  doSomething() {
+    return 42;
+  }
+}
+
+test('class coverage', () => {
+  const dog = Dog.create('Rex');
+  dog.speak();
+});

test/parallel/test-runner-coverage-statements.js

@@ -202,3 +202,32 @@ test('100% statement coverage for fully covered file', () => {
   assert.ok(invalidTap, 'invalid-tap.js should be in the report');
   assert.strictEqual(invalidTap.coveredStatementPercent, 100);
 });
+
+test('statement coverage counts class and function declarations', () => {
+  const classFixture = fixtures.path('test-runner', 'coverage-class.js');
+  const result = spawnSync(process.execPath, [
+    '--test',
+    '--experimental-test-coverage',
+    '--test-coverage-exclude=!test/**',
+    '--test-reporter', reporter,
+    classFixture,
+  ]);
+
+  assert.strictEqual(result.stderr.toString(), '');
+  assert.strictEqual(result.status, 0);
+
+  const { summary } = JSON.parse(result.stdout.toString());
+  const classFile = summary.files.find(
+    (f) => f.path.endsWith('coverage-class.js'),
+  );
+
+  assert.ok(classFile, 'coverage-class.js should be in the report');
+  assert.ok(classFile.totalStatementCount > 0,
+            `totalStatementCount must be > 0, got ${classFile.totalStatementCount}`);
+
+  // The file has an unused class, so statement coverage should be < 100%.
+  assert.ok(classFile.coveredStatementPercent < 100,
+            'should have uncovered statements from UnusedClass');
+  assert.ok(classFile.coveredStatementPercent > 0,
+            'should have covered statements from Dog/Animal');
+});